@lucasreiners/lead 0.1.0

package/dist/index.js

@@ -0,0 +1,3811 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/shared/log.ts
+var LEVEL_ORDER = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3
+};
+var sdkClient;
+var currentLevel = process.env.LEAD_LOG_LEVEL ?? "INFO";
+function setClient(client) {
+  sdkClient = client;
+}
+function shouldLog(level) {
+  return LEVEL_ORDER[level] >= LEVEL_ORDER[currentLevel];
+}
+function writeLog(level, message, ...args) {
+  if (!shouldLog(level))
+    return;
+  const extra = args.length > 0 ? ` ${args.map((a) => JSON.stringify(a)).join(" ")}` : "";
+  const full = message + extra;
+  if (sdkClient) {
+    try {
+      sdkClient.app.log({
+        body: {
+          service: "lead",
+          level: level.toLowerCase(),
+          message: full
+        }
+      });
+    } catch {
+      process.stderr.write(`[lead:${level}] ${full}
+`);
+    }
+  } else {
+    process.stderr.write(`[lead:${level}] ${full}
+`);
+  }
+}
+function debug(message, ...args) {
+  writeLog("DEBUG", message, ...args);
+}
+function info(message, ...args) {
+  writeLog("INFO", message, ...args);
+}
+function warn(message, ...args) {
+  writeLog("WARN", message, ...args);
+}
+
+// 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/infrastructure/fs/config-fs-loader.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// src/config/schema.ts
+import { z } from "zod";
+var ToolPermissionMapSchema = z.record(z.string(), z.boolean());
+var AgentOverrideConfigSchema = z.object({
+  model: z.string().optional(),
+  skills: z.array(z.string()).optional(),
+  tools: ToolPermissionMapSchema.optional(),
+  display_name: z.string().optional()
+});
+var CustomAgentConfigSchema = z.object({
+  prompt: z.string().optional(),
+  prompt_file: z.string().optional(),
+  model: z.string().optional(),
+  skills: z.array(z.string()).optional(),
+  tools: ToolPermissionMapSchema.optional(),
+  display_name: z.string().optional(),
+  mode: z.enum(["subagent", "primary", "all"]).optional(),
+  triggers: z.array(z.object({
+    domain: z.string(),
+    trigger: z.string()
+  })).optional(),
+  description: z.string().optional()
+});
+var CategoryConfigSchema = z.object({
+  model: z.string().optional(),
+  skills: z.array(z.string()).optional()
+});
+var CategoriesConfigSchema = z.record(z.string(), CategoryConfigSchema);
+var BackgroundConfigSchema = z.object({
+  max_concurrent: z.number().int().positive().optional()
+});
+var ContinuationRecoveryConfigSchema = z.object({
+  compaction: z.boolean().optional()
+});
+var ContinuationIdleConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  work: z.boolean().optional(),
+  workflow: z.boolean().optional(),
+  todo_prompt: z.boolean().optional()
+});
+var ContinuationConfigSchema = z.object({
+  recovery: ContinuationRecoveryConfigSchema.optional(),
+  idle: ContinuationIdleConfigSchema.optional()
+});
+var WorkflowConfigSchema = z.object({
+  disabled_workflows: z.array(z.string()).optional(),
+  directories: z.array(z.string()).optional()
+});
+var ExperimentalConfigSchema = z.object({
+  enabled: z.boolean().optional()
+});
+var LeadConfigSchema = z.object({
+  $schema: z.string().optional(),
+  agents: z.record(z.string(), AgentOverrideConfigSchema).optional(),
+  custom_agents: z.record(z.string(), CustomAgentConfigSchema).optional(),
+  categories: CategoriesConfigSchema.optional(),
+  disabled_hooks: z.array(z.string()).optional(),
+  disabled_tools: z.array(z.string()).optional(),
+  disabled_agents: z.array(z.string()).optional(),
+  disabled_skills: z.array(z.string()).optional(),
+  skill_directories: z.array(z.string()).optional(),
+  background: BackgroundConfigSchema.optional(),
+  continuation: ContinuationConfigSchema.optional(),
+  workflows: WorkflowConfigSchema.optional(),
+  experimental: ExperimentalConfigSchema.optional(),
+  log_level: z.enum(["DEBUG", "INFO", "WARN", "ERROR"]).optional()
+});
+
+// src/infrastructure/fs/config-fs-loader.ts
+var CONFIG_FILENAME = "lead.jsonc";
+function readJsoncFile(filePath) {
+  if (!existsSync(filePath))
+    return {};
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const errors = [];
+    const parsed = parse2(content, errors);
+    if (errors.length > 0) {
+      warn(`Config file has parse errors: ${filePath}`, errors);
+    }
+    if (parsed === null || parsed === undefined || typeof parsed !== "object") {
+      warn(`Config file is not a valid object: ${filePath}`);
+      return {};
+    }
+    const result = LeadConfigSchema.safeParse(parsed);
+    if (!result.success) {
+      warn(`Config file validation warnings in ${filePath}:`, result.error.issues);
+      return parsed ?? {};
+    }
+    return result.data;
+  } catch (err) {
+    warn(`Failed to read config file: ${filePath}`, err);
+    return {};
+  }
+}
+function createConfigFsLoader() {
+  return {
+    loadUserConfig(homeDir) {
+      const home = homeDir ?? homedir();
+      const configPath = join(home, ".config", "opencode", CONFIG_FILENAME);
+      return readJsoncFile(configPath);
+    },
+    loadProjectConfig(projectDir) {
+      const configPath = join(projectDir, ".opencode", CONFIG_FILENAME);
+      return readJsoncFile(configPath);
+    }
+  };
+}
+
+// src/config/merge.ts
+function mergeConfigs(user, project) {
+  const merged = { ...user };
+  if (project.log_level !== undefined)
+    merged.log_level = project.log_level;
+  merged.disabled_agents = mergeArrays(user.disabled_agents, project.disabled_agents);
+  merged.disabled_tools = mergeArrays(user.disabled_tools, project.disabled_tools);
+  merged.disabled_hooks = mergeArrays(user.disabled_hooks, project.disabled_hooks);
+  merged.disabled_skills = mergeArrays(user.disabled_skills, project.disabled_skills);
+  merged.skill_directories = mergeArrays(user.skill_directories, project.skill_directories);
+  merged.agents = mergeRecords(user.agents, project.agents);
+  merged.custom_agents = mergeRecords(user.custom_agents, project.custom_agents);
+  merged.categories = mergeRecords(user.categories, project.categories);
+  if (project.background !== undefined) {
+    merged.background = { ...user.background, ...project.background };
+  }
+  if (project.continuation !== undefined) {
+    merged.continuation = {
+      recovery: { ...user.continuation?.recovery, ...project.continuation.recovery },
+      idle: { ...user.continuation?.idle, ...project.continuation.idle }
+    };
+  }
+  if (project.workflows !== undefined) {
+    merged.workflows = {
+      disabled_workflows: mergeArrays(user.workflows?.disabled_workflows, project.workflows.disabled_workflows),
+      directories: mergeArrays(user.workflows?.directories, project.workflows.directories)
+    };
+  }
+  if (project.experimental !== undefined) {
+    merged.experimental = { ...user.experimental, ...project.experimental };
+  }
+  return merged;
+}
+function mergeArrays(a, b) {
+  if (!a && !b)
+    return;
+  const combined = [...a ?? [], ...b ?? []];
+  return [...new Set(combined)];
+}
+function mergeRecords(a, b) {
+  if (!a && !b)
+    return;
+  const result = { ...a ?? {} };
+  for (const [key, val] of Object.entries(b ?? {})) {
+    result[key] = { ...result[key] ?? {}, ...val };
+  }
+  return result;
+}
+
+// src/config/loader.ts
+var _loader;
+function getLoader() {
+  if (!_loader)
+    _loader = createConfigFsLoader();
+  return _loader;
+}
+function loadLeadConfig(directory, options) {
+  const loader = getLoader();
+  const userConfig = loader.loadUserConfig(options?.homeDir);
+  const projectConfig = loader.loadProjectConfig(directory);
+  const merged = mergeConfigs(userConfig, projectConfig);
+  info(`Config loaded for directory: ${directory}`);
+  return merged;
+}
+
+// src/config/continuation.ts
+var DEFAULTS = {
+  recovery: {
+    compaction: true
+  },
+  idle: {
+    enabled: true,
+    work: true,
+    workflow: true,
+    todo_prompt: true
+  }
+};
+function resolveContinuationConfig(raw) {
+  if (!raw)
+    return DEFAULTS;
+  return {
+    recovery: {
+      compaction: raw.recovery?.compaction ?? DEFAULTS.recovery.compaction
+    },
+    idle: {
+      enabled: raw.idle?.enabled ?? DEFAULTS.idle.enabled,
+      work: raw.idle?.work ?? DEFAULTS.idle.work,
+      workflow: raw.idle?.workflow ?? DEFAULTS.idle.workflow,
+      todo_prompt: raw.idle?.todo_prompt ?? DEFAULTS.idle.todo_prompt
+    }
+  };
+}
+
+// src/features/skill-loader/opencode-client.ts
+async function fetchSkillsFromApi(serverUrl, directory, timeoutMs = 3000) {
+  try {
+    const url = new URL("/skill", serverUrl);
+    url.searchParams.set("directory", directory);
+    const controller = new AbortController;
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let response;
+    try {
+      response = await fetch(url.toString(), { signal: controller.signal });
+    } finally {
+      clearTimeout(timer);
+    }
+    if (!response.ok) {
+      return [];
+    }
+    const json = await response.json();
+    if (!Array.isArray(json)) {
+      return [];
+    }
+    const skills = [];
+    for (const item of json) {
+      if (item && typeof item === "object" && typeof item.name === "string" && typeof item.content === "string") {
+        const raw = item;
+        const location = typeof raw.location === "string" ? raw.location : "";
+        const source = location.includes(".opencode") ? "project" : "user";
+        skills.push({
+          name: raw.name,
+          content: raw.content,
+          source,
+          metadata: {
+            description: typeof raw.description === "string" ? raw.description : undefined
+          }
+        });
+      }
+    }
+    return skills;
+  } catch {
+    return [];
+  }
+}
+
+// src/features/skill-loader/discovery.ts
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { join as join2, resolve as resolve2 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/shared/resolve-safe-path.ts
+import { resolve, relative, isAbsolute } from "path";
+function resolveSafePath(base, relativePath) {
+  if (isAbsolute(relativePath)) {
+    throw new Error(`Path traversal rejected: absolute path not allowed: ${relativePath}`);
+  }
+  if (relativePath.includes("..")) {
+    throw new Error(`Path traversal rejected: ".." not allowed in path: ${relativePath}`);
+  }
+  const resolved = resolve(base, relativePath);
+  const rel = relative(base, resolved);
+  if (rel.startsWith("..") || isAbsolute(rel)) {
+    throw new Error(`Path traversal rejected: path escapes sandbox: ${relativePath}`);
+  }
+  return resolved;
+}
+
+// src/features/skill-loader/discovery.ts
+function parseFrontmatter(text) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(text);
+  if (!match) {
+    return { metadata: {}, content: text };
+  }
+  const frontmatter = match[1];
+  const content = match[2];
+  const metadata = {};
+  const lines = frontmatter.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) {
+      i++;
+      continue;
+    }
+    const key = line.slice(0, colonIdx).trim();
+    const rawValue = line.slice(colonIdx + 1).trim();
+    if (rawValue.startsWith("[")) {
+      const inner = rawValue.slice(1, rawValue.lastIndexOf("]"));
+      const items = inner.split(",").map((s) => s.trim().replace(/^["']|["']$/g, ""));
+      if (key === "tools") {
+        metadata.tools = items;
+      }
+      i++;
+      continue;
+    }
+    if (rawValue === "") {
+      const items = [];
+      i++;
+      while (i < lines.length && lines[i].trim().startsWith("-")) {
+        items.push(lines[i].trim().slice(1).trim());
+        i++;
+      }
+      if (key === "tools") {
+        metadata.tools = items;
+      }
+      continue;
+    }
+    const value = rawValue.replace(/^["']|["']$/g, "");
+    if (key === "name" || key === "description" || key === "model") {
+      metadata[key] = value;
+    } else if (key === "tools") {
+      metadata.tools = [value];
+    }
+    i++;
+  }
+  return { metadata, content };
+}
+function loadSkillFile(filePath, source) {
+  try {
+    const text = readFileSync2(filePath, "utf-8");
+    const { metadata, content } = parseFrontmatter(text);
+    const name = metadata.name ?? filePath.split(/[\\/]/).slice(-2, -1)[0]?.replace(/[^a-z0-9-]/gi, "-").toLowerCase();
+    if (!name)
+      return null;
+    const tools = metadata.tools == null ? undefined : Array.isArray(metadata.tools) ? metadata.tools : [metadata.tools];
+    return {
+      name,
+      content: content.trim(),
+      source,
+      metadata: {
+        description: metadata.description,
+        model: metadata.model,
+        tools
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+function scanDirectory(dir, source) {
+  if (!existsSync2(dir))
+    return [];
+  const skills = [];
+  try {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      const fullPath = join2(dir, entry);
+      let stat;
+      try {
+        stat = statSync(fullPath);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        const skillPath = join2(fullPath, "SKILL.md");
+        if (existsSync2(skillPath)) {
+          const skill = loadSkillFile(skillPath, source);
+          if (skill)
+            skills.push(skill);
+        }
+        skills.push(...scanDirectory(fullPath, source));
+      } else if (entry === "SKILL.md") {
+        const skill = loadSkillFile(fullPath, source);
+        if (skill)
+          skills.push(skill);
+      }
+    }
+  } catch {}
+  return skills;
+}
+function discoverSkillsFromDirs(options) {
+  const { projectDirectory, customDirs = [] } = options;
+  const results = [];
+  const userSkillsDir = join2(homedir2(), ".config", "opencode", "skills");
+  results.push(...scanDirectory(userSkillsDir, "user"));
+  const projectSkillsDir = join2(projectDirectory, ".opencode", "skills");
+  results.push(...scanDirectory(projectSkillsDir, "project"));
+  for (const customDir of customDirs) {
+    try {
+      const safeDir = resolveSafePath(projectDirectory, customDir);
+      const fullPath = resolve2(projectDirectory, safeDir);
+      results.push(...scanDirectory(fullPath, "custom"));
+    } catch {}
+  }
+  return results;
+}
+
+// src/features/skill-loader/loader.ts
+async function loadSkills(options) {
+  const {
+    serverUrl,
+    projectDirectory,
+    customDirs = [],
+    disabledSkills = []
+  } = options;
+  const errors = [];
+  const disabledSet = new Set(disabledSkills);
+  let apiSkills = [];
+  if (serverUrl) {
+    try {
+      apiSkills = await fetchSkillsFromApi(serverUrl, projectDirectory);
+    } catch (err) {
+      errors.push(`API skill fetch failed: ${String(err)}`);
+    }
+  }
+  let fsSkills = [];
+  try {
+    fsSkills = discoverSkillsFromDirs({ projectDirectory, customDirs });
+  } catch (err) {
+    errors.push(`Filesystem skill discovery failed: ${String(err)}`);
+  }
+  const merged = new Map;
+  for (const skill of fsSkills) {
+    merged.set(skill.name, skill);
+  }
+  for (const skill of apiSkills) {
+    merged.set(skill.name, skill);
+  }
+  const skills = [];
+  for (const skill of merged.values()) {
+    if (!disabledSet.has(skill.name)) {
+      skills.push(skill);
+    }
+  }
+  return { skills, errors };
+}
+
+// src/features/skill-loader/resolver.ts
+function createSkillResolver(loadResult) {
+  const skillMap = new Map;
+  for (const skill of loadResult.skills) {
+    skillMap.set(skill.name, skill);
+  }
+  return (skillNames, disabledSkills) => {
+    const parts = [];
+    for (const name of skillNames) {
+      if (disabledSkills?.has(name))
+        continue;
+      const skill = skillMap.get(name);
+      if (skill?.content) {
+        parts.push(skill.content);
+      }
+    }
+    return parts.join(`
+
+`);
+  };
+}
+
+// src/create-tools.ts
+async function createTools(options) {
+  const { ctx, pluginConfig } = options;
+  const skillResult = await loadSkills({
+    serverUrl: ctx.serverUrl,
+    projectDirectory: ctx.directory,
+    disabledSkills: pluginConfig.disabled_skills,
+    customDirs: pluginConfig.skill_directories
+  });
+  const resolveSkills = createSkillResolver(skillResult);
+  return {
+    availableSkills: skillResult.skills,
+    resolveSkills,
+    tools: {}
+  };
+}
+
+// src/agents/types.ts
+function isFactory(source) {
+  return typeof source === "function";
+}
+
+// src/agents/agent-builder.ts
+var AGENT_NAME_VARIANTS = {
+  "tech-lead": ["tech-lead", "Tech Lead"],
+  "lead-dev": ["lead-dev", "Lead Developer"],
+  engineer: ["engineer", "Engineer", "Software Engineer"],
+  architect: ["architect", "Architect", "Software Architect"],
+  "code-analyst": ["code-analyst", "Code Analyst"],
+  researcher: ["researcher", "Researcher", "Technical Researcher"],
+  reviewer: ["reviewer", "Reviewer", "Code Reviewer"],
+  tester: ["tester", "Tester"],
+  guardian: ["guardian", "Guardian", "Security Guardian"]
+};
+function stripDisabledAgentReferences(prompt, disabledAgents) {
+  if (disabledAgents.size === 0)
+    return prompt;
+  const disabledVariants = new Set;
+  for (const name of disabledAgents) {
+    const variants = AGENT_NAME_VARIANTS[name] ?? [name];
+    for (const v of variants) {
+      disabledVariants.add(v);
+    }
+  }
+  const lines = prompt.split(`
+`);
+  const filtered = lines.filter((line) => {
+    for (const variant of disabledVariants) {
+      if (line.includes(variant))
+        return false;
+    }
+    return true;
+  });
+  return filtered.join(`
+`);
+}
+function applyCategoryConfig(base, categories) {
+  const category = base["category"];
+  if (!category)
+    return base;
+  const categoryConfig = categories[category];
+  if (!categoryConfig)
+    return base;
+  return {
+    ...base,
+    ...categoryConfig.model !== undefined && { model: categoryConfig.model },
+    ...categoryConfig.temperature !== undefined && { temperature: categoryConfig.temperature },
+    ...categoryConfig.tools !== undefined && {
+      tools: { ...base.tools ?? {}, ...categoryConfig.tools }
+    }
+  };
+}
+function buildAgent(source, model, options) {
+  let config = isFactory(source) ? { ...source(model) } : { ...source };
+  if (options?.categories) {
+    config = applyCategoryConfig(config, options.categories);
+  }
+  const skills = config["skills"];
+  if (skills?.length && options?.resolveSkills) {
+    const skillContent = options.resolveSkills(skills, options.disabledSkills);
+    if (skillContent) {
+      config.prompt = skillContent + (config.prompt ? `
+
+` + config.prompt : "");
+    }
+  }
+  if (options?.disabledAgents && options.disabledAgents.size > 0 && config.prompt) {
+    config.prompt = stripDisabledAgentReferences(config.prompt, options.disabledAgents);
+  }
+  return config;
+}
+
+// src/agents/model-resolution.ts
+var STRATEGIC_AGENTS = new Set([
+  "tech-lead",
+  "architect",
+  "lead-dev"
+]);
+var STRATEGIC_MODEL_CHAIN = [
+  "github-copilot/claude-opus-4.6",
+  "github-copilot/claude-opus-4.5",
+  "github-copilot/claude-sonnet-4.6",
+  "github-copilot/claude-sonnet-4.5",
+  "anthropic/claude-opus-4",
+  "anthropic/claude-sonnet-4",
+  "github-copilot/gpt-5.4",
+  "github-copilot/gpt-4o"
+];
+var ENGINEERING_MODEL_CHAIN = [
+  "github-copilot/claude-sonnet-4.6",
+  "github-copilot/claude-sonnet-4.5",
+  "github-copilot/claude-sonnet-4",
+  "anthropic/claude-sonnet-4",
+  "github-copilot/gpt-5.4-mini",
+  "github-copilot/gpt-4o"
+];
+function getModelChain(agentName) {
+  return STRATEGIC_AGENTS.has(agentName) ? STRATEGIC_MODEL_CHAIN : ENGINEERING_MODEL_CHAIN;
+}
+function getDefaultModel(agentName) {
+  return getModelChain(agentName)[0];
+}
+
+// src/agents/prompt-loader.ts
+function readPromptMd(importMetaUrl) {
+  try {
+    const url = new URL("prompt.md", importMetaUrl);
+    const content = __require("fs").readFileSync(new URL(url).pathname, "utf-8");
+    return content;
+  } catch {
+    return null;
+  }
+}
+
+// src/agents/prompt-utils.ts
+function trimPrompt(text) {
+  const lines = text.split(`
+`);
+  const trimmedLines = lines.map((line) => line.trimEnd());
+  const collapsed = [];
+  let previousWasBlank = false;
+  for (const line of trimmedLines) {
+    const isBlank = line.trim() === "";
+    if (isBlank && previousWasBlank)
+      continue;
+    collapsed.push(line);
+    previousWasBlank = isBlank;
+  }
+  return collapsed.join(`
+`).trim();
+}
+
+// src/agents/dynamic-prompt-builder.ts
+function buildDelegationTable(agents) {
+  const rows = agents.map((a) => `| **${a.displayName}** | ${a.description} | ${a.useWhen ?? "Complex tasks in domain"} |`).join(`
+`);
+  return `## Team Members
+
+| Agent | Role | Delegate When |
+|-------|------|---------------|
+${rows}`;
+}
+function buildDynamicLeadPrompt(options) {
+  const { enabledAgents, fingerprint, customAgentCount = 0 } = options;
+  const sections = [];
+  sections.push(buildDelegationTable(enabledAgents));
+  if (customAgentCount > 0) {
+    sections.push(`> **Note**: ${customAgentCount} custom agent(s) are also available. Check the full agent list when routing.`);
+  }
+  if (fingerprint) {
+    sections.push(`<!-- fingerprint: ${fingerprint} -->`);
+  }
+  return trimPrompt(sections.join(`
+
+`));
+}
+var BUILTIN_AGENT_DISPLAY = {
+  "tech-lead": {
+    name: "tech-lead",
+    displayName: "Tech Lead",
+    description: "Sets technical direction, orchestrates complex multi-step tasks, routes to specialists",
+    useWhen: "Complex tasks needing full orchestration across multiple domains",
+    avoidWhen: "Simple single-domain tasks"
+  },
+  "lead-dev": {
+    name: "lead-dev",
+    displayName: "Lead Developer",
+    description: "Owns implementation — drives plan execution step-by-step, tracks progress",
+    useWhen: "Executing an existing implementation plan",
+    avoidWhen: "No plan exists yet"
+  },
+  engineer: {
+    name: "engineer",
+    displayName: "Software Engineer",
+    description: "Domain-specific implementation work",
+    useWhen: "Writing code, fixing bugs, implementing features",
+    avoidWhen: "Planning or research phases"
+  },
+  architect: {
+    name: "architect",
+    displayName: "Software Architect",
+    description: "Strategic planning and task breakdown",
+    useWhen: "Creating implementation plans, breaking down complex features",
+    avoidWhen: "Direct code writing"
+  },
+  "code-analyst": {
+    name: "code-analyst",
+    displayName: "Code Analyst",
+    description: "Read-only codebase exploration and pattern discovery",
+    useWhen: "Understanding existing code, finding patterns, mapping structure",
+    avoidWhen: "Writing or modifying files"
+  },
+  researcher: {
+    name: "researcher",
+    displayName: "Technical Researcher",
+    description: "External documentation, libraries, and best practices",
+    useWhen: "Looking up APIs, frameworks, or external resources",
+    avoidWhen: "Internal codebase tasks"
+  },
+  reviewer: {
+    name: "reviewer",
+    displayName: "Code Reviewer",
+    description: "Quality review and acceptance validation",
+    useWhen: "Reviewing PRs, validating implementations, quality checks",
+    avoidWhen: "Initial implementation"
+  },
+  tester: {
+    name: "tester",
+    displayName: "Tester",
+    description: "Runs tests, linters, and type checks to verify implementation quality",
+    useWhen: "Verifying code compiles, tests pass, linting is clean",
+    avoidWhen: "Writing code — tester only observes and reports"
+  },
+  guardian: {
+    name: "guardian",
+    displayName: "Security Guardian",
+    description: "Security review and spec compliance",
+    useWhen: "Security audits, vulnerability checks, compliance review",
+    avoidWhen: "Non-security tasks"
+  }
+};
+
+// src/agents/tech-lead/index.ts
+var INLINE_PROMPT = `<Role>
+You are the Tech Lead of the L.E.A.D. team — an enterprise software engineering team
+that delivers high-quality, secure, production-grade software.
+
+You set technical direction, analyze incoming requests, determine the right specialist
+to handle them, and orchestrate complex multi-step work across the team.
+You see the big picture and make the high-level decisions.
+</Role>
+
+<Clarification>
+Before acting on any non-trivial request, verify you have enough context:
+
+- Is the user's intent clear and unambiguous? If not — ask.
+- Is critical context missing (e.g. no project familiarity, unclear scope, ambiguous requirements)? Ask.
+- Are there implicit assumptions that could lead the team down the wrong path? Surface them.
+- Could this be interpreted multiple ways? Confirm the interpretation before proceeding.
+
+Use the question tool when available. Keep questions concise and specific — one focused
+question is better than a wall of five. Don't over-ask on obvious requests; use judgment.
+
+Examples of when to ask:
+- "Add authentication" → what kind? OAuth? API keys? Session-based?
+- "Fix the bug" → which bug? Can you reproduce? Expected vs actual behavior?
+- "Refactor the API" → what's the goal? Performance? Maintainability? New requirements?
+
+Examples of when NOT to ask:
+- "Fix the typo in README.md" → just do it
+- "Add a unit test for the login function" → clear enough, proceed
+- "Run the tests" → just route to engineer
+</Clarification>
+
+<Discipline>
+- Break complex tasks into well-defined subtasks and delegate to the right specialist
+- Always identify the user's true intent before routing
+- Route planning tasks to the architect
+- Route codebase exploration to the code-analyst
+- Route research tasks to the researcher
+- Route implementation to the engineer or lead-dev
+- Route review tasks to the reviewer
+- Route security concerns to the guardian
+- For simple single-step tasks, handle them directly
+</Discipline>
+
+<TicketLinking>
+Before delegating planning tasks to the architect, determine if the work is linked to a ticket:
+
+1. Check the user's request for ticket references (e.g. PROJ-123, #45, GH-123, Jira keys like ABC-456)
+2. If NO ticket is mentioned, ask the user:
+   "Does this feature have a ticket number (GitHub issue, Jira, etc.) for reference?"
+3. Pass the ticket reference to the architect so the plan is stored in .lead/<ticket>/
+4. If the user says there's no ticket, tell the architect this is an ad-hoc task (plan goes in .lead/_adhoc/)
+
+This ensures plans are organized by ticket for version control traceability.
+</TicketLinking>
+
+<PlanApproval>
+You are the gatekeeper between planning and implementation.
+
+When the architect produces a plan:
+1. REVIEW it — read the plan file yourself
+2. Check: Is it complete? Are acceptance criteria clear? Are tasks independently executable?
+3. Check: Does it match the user's original intent? (Refer back to what was asked)
+4. If the plan is solid → tell the user it's ready and offer to start implementation
+5. If the plan has gaps → send it back to the architect with specific feedback, or ask the user for clarification
+
+NEVER hand a plan to the lead-dev for implementation unless you've reviewed it and are confident it's ready.
+The lead-dev runs autonomously — a bad plan means bad output with no course correction.
+</PlanApproval>
+
+<Style>
+- Terse, professional communication
+- No filler phrases or meta-commentary
+- Focused on deliverables and outcomes
+- Enterprise-grade quality standards
+</Style>`;
+var BASE_PROMPT = readPromptMd(import.meta.url) ?? INLINE_PROMPT;
+var LEAD_DEFAULTS = {
+  description: "Tech Lead",
+  temperature: 1,
+  tools: {
+    bash: false,
+    edit: false,
+    write: false
+  }
+};
+function createLeadAgentWithOptions(model, options = {}) {
+  const { disabledAgents = new Set, fingerprint, customAgents = [] } = options;
+  const enabledBuiltins = Object.values(BUILTIN_AGENT_DISPLAY).filter((a) => !disabledAgents.has(a.name) && a.name !== "tech-lead");
+  const allAgents = [...enabledBuiltins, ...customAgents];
+  const dynamicSection = buildDynamicLeadPrompt({
+    enabledAgents: allAgents,
+    fingerprint,
+    customAgentCount: customAgents.length
+  });
+  const fullPrompt = [BASE_PROMPT, dynamicSection].filter(Boolean).join(`
+
+`);
+  return {
+    ...LEAD_DEFAULTS,
+    model,
+    prompt: fullPrompt
+  };
+}
+var createLeadAgent = Object.assign((model) => createLeadAgentWithOptions(model), { mode: "primary" });
+
+// src/agents/lead-dev/index.ts
+var INLINE_PROMPT2 = `<Role>
+You are the Lead Developer of the L.E.A.D. team.
+You own the implementation — taking approved plans and driving them to completion
+step-by-step, tracking progress, running verifications, and ensuring quality at each stage.
+</Role>
+
+<AutonomousExecution>
+You run autonomously. The plan you receive has been reviewed and approved by the Tech Lead.
+Trust it. Execute it. Do not second-guess scope or re-negotiate requirements.
+
+If you encounter a genuine blocker (broken dependency, missing API, contradictory requirements),
+report it clearly and stop — but do NOT stop for minor ambiguities you can resolve yourself.
+Use your engineering judgment for implementation details the plan leaves open.
+</AutonomousExecution>
+
+<Discipline>
+TODO OBSESSION (NON-NEGOTIABLE):
+- Load existing todos first — never re-plan if a plan exists
+- Mark in_progress before starting EACH task (ONE at a time)
+- Mark completed IMMEDIATELY after finishing
+- NEVER skip steps, NEVER batch completions
+
+Execution without todos = lost work.
+</Discipline>
+
+<PlanExecution>
+When activated by /implement with a plan file:
+
+1. READ the plan file first — understand the full scope
+2. FIND the first unchecked \`- [ ]\` task
+3. For each task:
+   a. Read the task description, files, and acceptance criteria
+   b. Execute the work (write code, run commands, create files)
+   c. DELEGATE to the **tester** agent for verification (see Verification Cycle below)
+   d. If tester returns [PASS]: mark complete (\`- [ ]\` → \`- [x]\`) and report "Completed task N/M: [title]"
+   e. If tester returns [FAIL]: fix the issues, then delegate to tester again. Repeat until [PASS].
+4. CONTINUE to the next unchecked task
+5. When ALL checkboxes are checked, report final summary
+
+NEVER stop mid-plan unless explicitly told to or completely blocked.
+</PlanExecution>
+
+<VerificationCycle>
+After implementing each task, delegate to the **tester** agent to run project-specific
+verification (type checks, linting, tests). This is your implement → verify → fix loop:
+
+  implement → tester [PASS] → mark complete → next task
+  implement → tester [FAIL] → fix → tester [PASS] → mark complete → next task
+
+Rules:
+- ALWAYS delegate to tester after implementing a task — do not self-verify
+- Only mark \`- [x]\` after receiving [PASS] from tester
+- If tester returns [FAIL], fix the reported issues and delegate to tester again
+- Maximum 3 fix cycles per task — if still failing after 3 attempts, note the failure and move on
+
+EXCEPTION — Compilation blockers:
+If code does not compile at all (e.g., missing types from a not-yet-implemented task),
+you may batch a logical group of related tasks before running verification.
+Complete the group, THEN delegate to tester for the batch.
+Mark individual tasks only after the group passes verification.
+</VerificationCycle>
+
+<Style>
+- Terse status updates only
+- No meta-commentary
+- Dense > verbose
+</Style>`;
+var BASE_PROMPT2 = readPromptMd(import.meta.url) ?? INLINE_PROMPT2;
+var EXECUTOR_DEFAULTS = {
+  description: "Lead Developer",
+  temperature: 1
+};
+function createExecutorAgentWithOptions(model, _disabledAgents, _continuation) {
+  return {
+    ...EXECUTOR_DEFAULTS,
+    model,
+    prompt: BASE_PROMPT2
+  };
+}
+var createExecutorAgent = Object.assign((model) => createExecutorAgentWithOptions(model), { mode: "subagent" });
+
+// src/agents/engineer/index.ts
+var INLINE_PROMPT3 = `<Role>
+You are a Software Engineer on the L.E.A.D. team.
+You implement features, fix bugs, write tests, and deliver working, production-grade code.
+</Role>
+
+<Discipline>
+- Write clean, well-typed, maintainable code
+- Follow existing patterns and conventions in the codebase
+- Add tests for all new logic
+- Verify your implementation compiles and tests pass before finishing
+- Prefer existing utilities and libraries over custom implementations
+</Discipline>
+
+<QualityStandards>
+- Enterprise-grade error handling
+- Comprehensive TypeScript types
+- No console.log or debug artifacts in production code
+- Security-conscious by default
+</QualityStandards>
+
+<Style>
+- Professional and concise
+- Show implementation evidence (file paths, test output)
+- No meta-commentary
+</Style>`;
+var BASE_PROMPT3 = readPromptMd(import.meta.url) ?? INLINE_PROMPT3;
+var ENGINEER_DEFAULTS = {
+  description: "Software Engineer",
+  temperature: 1
+};
+var createEngineerAgent = Object.assign((model) => ({
+  ...ENGINEER_DEFAULTS,
+  model,
+  prompt: BASE_PROMPT3
+}), { mode: "all" });
+
+// src/agents/architect/index.ts
+var INLINE_PROMPT4 = `<Role>
+You are the Software Architect of the L.E.A.D. team.
+You produce strategic implementation plans, break down complex features,
+and define the technical approach before any code is written.
+</Role>
+
+<Constraints>
+- ONLY write .md files inside the .lead/ directory
+- NEVER write code files (.ts, .js, .py, .go, etc.)
+- NEVER edit source code
+</Constraints>
+
+<PlanLocation>
+Plan storage depends on whether a ticket is linked:
+
+- **Ticket-linked**: \`.lead/<ticket>/plan.md\` (e.g. \`.lead/PROJ-123/plan.md\`, \`.lead/GH-45/plan.md\`)
+- **Ad-hoc (no ticket)**: \`.lead/_adhoc/{slug}.md\` (e.g. \`.lead/_adhoc/build-auth.md\`)
+
+The Tech Lead will tell you which applies. If a ticket reference is provided, use it as the directory name.
+The plan file inside a ticket directory is always named \`plan.md\`.
+</PlanLocation>
+
+<PlanFormat>
+Each plan must contain:
+- TL;DR with summary and estimated effort
+- Context section with key findings
+- Objectives with deliverables and acceptance criteria
+- TODOs with task descriptions, file targets, and acceptance criteria per task
+- Verification checklist
+
+Plans must be actionable — each TODO must be independently executable.
+</PlanFormat>
+
+<Style>
+- Precise and unambiguous
+- Every task has clear acceptance criteria
+- Plans are complete enough to hand off without follow-up questions
+</Style>`;
+var BASE_PROMPT4 = readPromptMd(import.meta.url) ?? INLINE_PROMPT4;
+var ARCHITECT_DEFAULTS = {
+  description: "Software Architect",
+  temperature: 1,
+  tools: {
+    bash: false,
+    edit: false
+  }
+};
+var createArchitectAgent = Object.assign((model) => ({
+  ...ARCHITECT_DEFAULTS,
+  model,
+  prompt: BASE_PROMPT4
+}), { mode: "subagent" });
+
+// src/agents/code-analyst/index.ts
+var INLINE_PROMPT5 = `<Role>
+You are the Code Analyst of the L.E.A.D. team.
+You explore, map, and understand codebases — reading files, tracing dependencies,
+identifying patterns, and surfacing insights for other team members.
+</Role>
+
+<Constraints>
+- READ ONLY — never write, edit, or delete files
+- Never execute code or run commands that modify state
+- Return findings as structured summaries
+</Constraints>
+
+<Discipline>
+- Always start with a high-level structural scan before diving into details
+- Trace call chains and data flows to understand behavior
+- Identify patterns: naming conventions, error handling, test structure
+- Note anomalies, inconsistencies, and technical debt
+- Provide file paths and line numbers for all findings
+</Discipline>
+
+<Style>
+- Dense, structured output (use headers, code blocks, file paths)
+- Lead with the most important findings
+- No speculation — only what the code actually shows
+</Style>`;
+var BASE_PROMPT5 = readPromptMd(import.meta.url) ?? INLINE_PROMPT5;
+var CODE_ANALYST_DEFAULTS = {
+  description: "Code Analyst",
+  temperature: 1,
+  tools: {
+    bash: false,
+    edit: false,
+    write: false
+  }
+};
+var createCodeAnalystAgent = Object.assign((model) => ({
+  ...CODE_ANALYST_DEFAULTS,
+  model,
+  prompt: BASE_PROMPT5
+}), { mode: "subagent" });
+
+// src/agents/researcher/index.ts
+var INLINE_PROMPT6 = `<Role>
+You are the Technical Researcher of the L.E.A.D. team.
+You research external documentation, libraries, APIs, and best practices —
+providing accurate, up-to-date information to inform technical decisions.
+</Role>
+
+<Discipline>
+- Always fetch from authoritative sources (official docs, npm, GitHub)
+- Verify version compatibility before recommending dependencies
+- Prefer stable, well-maintained packages
+- Return structured summaries with code examples
+- Cite sources with URLs and version numbers
+</Discipline>
+
+<Style>
+- Structured output with clear sections
+- Include code examples from docs
+- Note caveats, gotchas, and version differences
+- Always indicate confidence level and source recency
+</Style>`;
+var BASE_PROMPT6 = readPromptMd(import.meta.url) ?? INLINE_PROMPT6;
+var RESEARCHER_DEFAULTS = {
+  description: "Technical Researcher",
+  temperature: 1,
+  tools: {
+    edit: false,
+    write: false,
+    bash: false
+  }
+};
+var createResearcherAgent = Object.assign((model) => ({
+  ...RESEARCHER_DEFAULTS,
+  model,
+  prompt: BASE_PROMPT6
+}), { mode: "subagent" });
+
+// src/agents/reviewer/index.ts
+var INLINE_PROMPT7 = `<Role>
+You are the Code Reviewer of the L.E.A.D. team.
+You perform thorough, objective code reviews — validating implementations against
+requirements, ensuring quality, and identifying issues before they reach production.
+</Role>
+
+<ReviewProcess>
+For each review:
+1. Verify the implementation matches the stated requirements
+2. Check for correctness: logic errors, edge cases, error handling
+3. Assess code quality: readability, naming, structure
+4. Verify tests exist and are meaningful
+5. Check for security issues (injection, auth, data exposure)
+6. Return a verdict: [APPROVE] or [REJECT]
+</ReviewProcess>
+
+<Verdict>
+Always end your review with one of:
+- [APPROVE] — implementation is correct and meets quality standards
+- [REJECT] — implementation has blocking issues (list each one)
+
+A rejection must list every blocking issue clearly.
+</Verdict>
+
+<Style>
+- Objective and evidence-based
+- Reference specific files and line numbers
+- No praise without substance — focus on findings
+</Style>`;
+var BASE_PROMPT7 = readPromptMd(import.meta.url) ?? INLINE_PROMPT7;
+var REVIEWER_DEFAULTS = {
+  description: "Code Reviewer",
+  temperature: 1,
+  tools: {
+    edit: false,
+    write: false,
+    bash: false
+  }
+};
+var createReviewerAgent = Object.assign((model) => ({
+  ...REVIEWER_DEFAULTS,
+  model,
+  prompt: BASE_PROMPT7
+}), { mode: "subagent" });
+
+// src/agents/guardian/index.ts
+var INLINE_PROMPT8 = `<Role>
+You are the Security Guardian of the L.E.A.D. team.
+You perform security reviews, identify vulnerabilities, and ensure enterprise-grade
+security posture across all implementations.
+</Role>
+
+<SecurityFramework>
+Evaluate against OWASP Top 10 and enterprise security requirements:
+1. Injection (SQL, command, path traversal)
+2. Broken authentication and session management
+3. Sensitive data exposure
+4. Insecure direct object references
+5. Security misconfiguration
+6. Cryptographic failures
+7. Vulnerable dependencies
+8. Insufficient logging and monitoring
+9. SSRF and request forgery
+10. Supply chain risks
+</SecurityFramework>
+
+<ReviewProcess>
+For each security review:
+1. Map the attack surface: inputs, outputs, trust boundaries
+2. Check authentication and authorization flows
+3. Verify data validation and sanitization
+4. Assess secret and credential handling
+5. Review dependency security posture
+6. Return verdict: [APPROVE] or [REJECT]
+</ReviewProcess>
+
+<Verdict>
+Always end your review with:
+- [APPROVE] — no critical or high security issues found
+- [REJECT] — critical or high issues found (list each with severity)
+
+Self-triage: if no security-relevant changes, fast-exit with [APPROVE].
+</Verdict>
+
+<Style>
+- Severity-first: CRITICAL > HIGH > MEDIUM > LOW
+- Include CVE references where applicable
+- Provide remediation guidance for each finding
+</Style>`;
+var BASE_PROMPT8 = readPromptMd(import.meta.url) ?? INLINE_PROMPT8;
+var GUARDIAN_DEFAULTS = {
+  description: "Security Guardian",
+  temperature: 1,
+  tools: {
+    edit: false,
+    write: false,
+    bash: false
+  }
+};
+var createGuardianAgent = Object.assign((model) => ({
+  ...GUARDIAN_DEFAULTS,
+  model,
+  prompt: BASE_PROMPT8
+}), { mode: "subagent" });
+
+// src/agents/tester/index.ts
+var INLINE_PROMPT9 = `<Role>
+You are the Tester of the L.E.A.D. team.
+You verify implementation quality by running project-specific tests, linters, and type checks.
+You report objective pass/fail results — you never fix code yourself.
+</Role>
+
+<ProjectContext>
+ALWAYS look for an AGENTS.md file in the project root first. This file contains
+project-specific instructions for testing, linting, building, and verification commands.
+
+If AGENTS.md exists, follow its verification instructions exactly.
+If AGENTS.md does not exist, use standard detection:
+1. Check for common config files (package.json, build.gradle, Cargo.toml, Makefile, etc.)
+2. Infer the appropriate test/lint/build commands from the project structure
+3. Run what's available — don't fail just because a specific tool is missing
+</ProjectContext>
+
+<VerificationProcess>
+For each verification request:
+
+1. READ the AGENTS.md file (if it exists) for project-specific commands
+2. RUN the verification steps in order:
+   a. Type check / Compile — ensure the code compiles without errors
+   b. Lint — run the project's linter if configured
+   c. Unit tests — run the test suite (or relevant subset)
+   d. Targeted check — if specific files were changed, focus tests on those areas
+3. ANALYZE the output — distinguish real failures from pre-existing issues
+4. REPORT with a clear verdict
+
+If a command fails to run (tool not installed, config missing), note it as SKIPPED, not FAIL.
+Only report FAIL for actual code quality or correctness issues introduced by the recent changes.
+</VerificationProcess>
+
+<Verdict>
+Always end your verification with exactly one of:
+
+- [PASS] — all verification steps passed or had only pre-existing issues
+- [FAIL] — new issues found that need fixing
+
+A [FAIL] verdict MUST include:
+1. Which step failed (typecheck, lint, test)
+2. The exact error output (trimmed to relevant lines)
+3. Which file(s) and line(s) are affected
+
+Keep it concise — the engineer needs actionable information, not a wall of logs.
+</Verdict>
+
+<Style>
+- Report results, not process
+- Quote exact error messages
+- No opinions on code style — only objective failures
+- Dense > verbose
+</Style>`;
+var BASE_PROMPT9 = readPromptMd(import.meta.url) ?? INLINE_PROMPT9;
+var TESTER_DEFAULTS = {
+  description: "Tester",
+  temperature: 1,
+  tools: {
+    edit: false,
+    write: false
+  }
+};
+var createTesterAgent = Object.assign((model) => ({
+  ...TESTER_DEFAULTS,
+  model,
+  prompt: BASE_PROMPT9
+}), { mode: "subagent" });
+
+// src/agents/builtin-agents.ts
+var AGENT_FACTORIES = {
+  "tech-lead": createLeadAgent,
+  "lead-dev": createExecutorAgent,
+  engineer: createEngineerAgent,
+  architect: createArchitectAgent,
+  "code-analyst": createCodeAnalystAgent,
+  researcher: createResearcherAgent,
+  reviewer: createReviewerAgent,
+  tester: createTesterAgent,
+  guardian: createGuardianAgent
+};
+var customAgentMetadata = new Map;
+function registerCustomAgentMetadata(name, metadata) {
+  customAgentMetadata.set(name, metadata);
+}
+function createBuiltinAgents(options = {}) {
+  const {
+    uiModel,
+    disabledAgents = new Set,
+    configOverrides = {},
+    buildOptions = {}
+  } = options;
+  const result = {};
+  for (const [name, factory] of Object.entries(AGENT_FACTORIES)) {
+    if (disabledAgents.has(name))
+      continue;
+    const resolvedModel = factory.mode === "primary" && uiModel ? uiModel : getDefaultModel(name);
+    let config = buildAgent(factory, resolvedModel, {
+      ...buildOptions,
+      disabledAgents
+    });
+    config.mode = factory.mode;
+    const override = configOverrides[name];
+    if (override) {
+      config = {
+        ...config,
+        ...override.model !== undefined && { model: override.model },
+        ...override.tools !== undefined && {
+          tools: { ...config.tools ?? {}, ...override.tools }
+        }
+      };
+    }
+    result[name] = config;
+  }
+  return result;
+}
+
+// src/agents/custom-agent-factory.ts
+import { readFileSync as readFileSync3 } from "fs";
+function buildCustomAgent(name, config, options = {}) {
+  const { directory } = options;
+  let promptText = config.prompt;
+  if (!promptText && config.prompt_file && directory) {
+    const safePath = resolveSafePath(directory, config.prompt_file);
+    if (safePath) {
+      try {
+        promptText = readFileSync3(safePath, "utf-8");
+      } catch {}
+    }
+  }
+  const baseConfig = {
+    description: config.description ?? name,
+    model: config.model,
+    mode: config.mode,
+    prompt: promptText,
+    tools: config.tools,
+    skills: config.skills
+  };
+  for (const key of Object.keys(baseConfig)) {
+    if (baseConfig[key] === undefined) {
+      delete baseConfig[key];
+    }
+  }
+  return buildAgent(baseConfig, options.buildOptions?.model ?? config.model ?? "", {
+    ...options,
+    disabledAgents: options.disabledAgents,
+    resolveSkills: options.resolveSkills,
+    disabledSkills: options.disabledSkills
+  });
+}
+function buildCustomAgentMetadata(name, config) {
+  return {
+    category: "custom",
+    cost: "MODERATE",
+    triggers: (config.triggers ?? []).map((t) => ({
+      domain: t.domain,
+      trigger: t.trigger
+    })),
+    useWhen: config.description ?? `Custom agent: ${name}`
+  };
+}
+
+// src/shared/agent-display-names.ts
+var BUILTIN_DISPLAY_NAMES = {
+  "tech-lead": "Tech Lead",
+  engineer: "Engineer",
+  "lead-dev": "Lead Developer",
+  architect: "Architect",
+  "code-analyst": "Code Analyst",
+  researcher: "Researcher",
+  reviewer: "Reviewer",
+  tester: "Tester",
+  guardian: "Guardian"
+};
+var overrides = {};
+function getAgentDisplayName(key) {
+  return overrides[key] ?? BUILTIN_DISPLAY_NAMES[key] ?? key;
+}
+
+// src/managers/config-handler.ts
+class ConfigHandler {
+  builtinAgents;
+  customAgents;
+  constructor(options) {
+    this.builtinAgents = options.builtinAgents;
+    this.customAgents = options.customAgents ?? {};
+  }
+  handle(config) {
+    const existing = config.agent ?? {};
+    const merged = {};
+    for (const [name, agentConfig] of Object.entries(this.builtinAgents)) {
+      const displayName = getAgentDisplayName(name);
+      merged[displayName] = {
+        ...agentConfig,
+        description: agentConfig.description ?? displayName
+      };
+    }
+    for (const [name, agentConfig] of Object.entries(this.customAgents)) {
+      const displayName = getAgentDisplayName(name);
+      merged[displayName] = agentConfig;
+    }
+    for (const [name, agentConfig] of Object.entries(existing)) {
+      if (!(name in merged)) {
+        merged[name] = agentConfig;
+      }
+    }
+    config.agent = merged;
+    config.default_agent = getAgentDisplayName("tech-lead");
+    if (!config.permission || typeof config.permission === "string") {
+      config.permission = { question: "allow" };
+    } else if (!config.permission.question) {
+      config.permission.question = "allow";
+    }
+    const dcpPlugin = "@tarquinen/opencode-dcp@latest";
+    if (!config.plugin) {
+      config.plugin = [dcpPlugin];
+    } else {
+      const alreadyPresent = config.plugin.some((entry) => typeof entry === "string" ? entry.startsWith("@tarquinen/opencode-dcp") : Array.isArray(entry) && entry[0]?.startsWith("@tarquinen/opencode-dcp"));
+      if (!alreadyPresent) {
+        config.plugin.push(dcpPlugin);
+      }
+    }
+  }
+  getAgentNames() {
+    return [...Object.keys(this.builtinAgents), ...Object.keys(this.customAgents)];
+  }
+}
+
+// src/managers/background-manager.ts
+var taskCounter = 0;
+function generateTaskId() {
+  taskCounter++;
+  return `task-${Date.now()}-${taskCounter}`;
+}
+
+class BackgroundManager {
+  tasks = new Map;
+  maxConcurrent;
+  constructor(maxConcurrent = 3) {
+    this.maxConcurrent = maxConcurrent;
+  }
+  spawn(options) {
+    const id = generateTaskId();
+    const record = {
+      id,
+      status: this.getRunningCount() < this.maxConcurrent ? "running" : "pending",
+      options,
+      startedAt: new Date
+    };
+    this.tasks.set(id, record);
+    return id;
+  }
+  getTask(taskId) {
+    return this.tasks.get(taskId);
+  }
+  cancel(taskId) {
+    const task = this.tasks.get(taskId);
+    if (!task || task.status === "completed" || task.status === "failed") {
+      return false;
+    }
+    task.status = "cancelled";
+    task.completedAt = new Date;
+    return true;
+  }
+  cancelAll() {
+    for (const task of this.tasks.values()) {
+      if (task.status === "pending" || task.status === "running") {
+        task.status = "cancelled";
+        task.completedAt = new Date;
+      }
+    }
+  }
+  list(filter) {
+    const all = Array.from(this.tasks.values());
+    if (!filter?.status)
+      return all;
+    return all.filter((t) => t.status === filter.status);
+  }
+  getRunningCount() {
+    return Array.from(this.tasks.values()).filter((t) => t.status === "running").length;
+  }
+  complete(taskId, result) {
+    const task = this.tasks.get(taskId);
+    if (!task || task.status !== "running")
+      return false;
+    task.status = "completed";
+    task.result = result;
+    task.completedAt = new Date;
+    return true;
+  }
+  fail(taskId, error) {
+    const task = this.tasks.get(taskId);
+    if (!task || task.status !== "running")
+      return false;
+    task.status = "failed";
+    task.error = error;
+    task.completedAt = new Date;
+    return true;
+  }
+}
+
+// src/managers/skill-mcp-manager.ts
+class SkillMcpManager {
+  async getOrCreateClient(_info, _config) {
+    throw new Error("SkillMcpManager.getOrCreateClient not implemented in v0.1");
+  }
+  async callTool(_info, _config, _name, _args) {
+    throw new Error("SkillMcpManager.callTool not implemented in v0.1");
+  }
+  async disconnectSession(_sessionId) {}
+  async disconnectAll() {}
+}
+
+// src/create-managers.ts
+async function createManagers(options) {
+  const { ctx, pluginConfig, resolveSkills } = options;
+  const disabledAgents = new Set(pluginConfig.disabled_agents ?? []);
+  const disabledSkills = new Set(pluginConfig.disabled_skills ?? []);
+  const builtinAgents = createBuiltinAgents({
+    disabledAgents,
+    configOverrides: pluginConfig.agents ?? {},
+    buildOptions: {
+      resolveSkills,
+      disabledSkills
+    }
+  });
+  const customAgents = {};
+  if (pluginConfig.custom_agents) {
+    for (const [name, customConfig] of Object.entries(pluginConfig.custom_agents)) {
+      if (disabledAgents.has(name))
+        continue;
+      const agentConfig = await buildCustomAgent(name, customConfig, {
+        directory: ctx.directory,
+        resolveSkills,
+        disabledSkills
+      });
+      customAgents[name] = agentConfig;
+      const metadata = buildCustomAgentMetadata(name, customConfig);
+      registerCustomAgentMetadata(name, metadata);
+    }
+  }
+  const allAgents = { ...builtinAgents, ...customAgents };
+  for (const [name, config] of Object.entries(allAgents)) {
+    const displayName = getAgentDisplayName(name);
+    if (displayName !== name && !config.description) {
+      config.description = displayName;
+    }
+  }
+  const configHandler = new ConfigHandler({
+    builtinAgents,
+    customAgents
+  });
+  const backgroundManager = new BackgroundManager(pluginConfig.background?.max_concurrent ?? 3);
+  const skillMcpManager = new SkillMcpManager;
+  return {
+    configHandler,
+    backgroundManager,
+    skillMcpManager,
+    agents: allAgents
+  };
+}
+
+// src/hooks/context-window-monitor.ts
+var DEFAULT_WARNING = 0.75;
+var DEFAULT_CRITICAL = 0.9;
+function checkContextWindow(usage, thresholds = {}) {
+  const warningPercent = thresholds.warningPercent ?? DEFAULT_WARNING;
+  const criticalPercent = thresholds.criticalPercent ?? DEFAULT_CRITICAL;
+  if (usage.contextWindow <= 0) {
+    return { severity: "ok", usagePercent: 0 };
+  }
+  const totalUsed = usage.inputTokens + usage.outputTokens;
+  const usagePercent = totalUsed / usage.contextWindow;
+  if (usagePercent >= criticalPercent) {
+    return {
+      severity: "critical",
+      usagePercent,
+      message: `⚠️ Critical: Context window ${Math.round(usagePercent * 100)}% full (${totalUsed.toLocaleString()}/${usage.contextWindow.toLocaleString()} tokens). Compact context soon to avoid truncation.`
+    };
+  }
+  if (usagePercent >= warningPercent) {
+    return {
+      severity: "warning",
+      usagePercent,
+      message: `ℹ️ Context window ${Math.round(usagePercent * 100)}% full (${totalUsed.toLocaleString()}/${usage.contextWindow.toLocaleString()} tokens). Consider compacting context.`
+    };
+  }
+  return { severity: "ok", usagePercent };
+}
+
+// src/hooks/write-existing-file-guard.ts
+var WRITE_TOOLS = new Set(["write", "Write", "edit", "Edit"]);
+var READ_TOOLS = new Set(["read", "Read", "cat"]);
+function createWriteGuard() {
+  const state = {
+    readFiles: new Set,
+    writtenFiles: new Set
+  };
+  function markRead(filePath) {
+    state.readFiles.add(filePath);
+  }
+  function markWritten(filePath) {
+    state.writtenFiles.add(filePath);
+  }
+  async function checkWrite(filePath) {
+    if (state.writtenFiles.has(filePath)) {
+      return { allowed: true };
+    }
+    if (state.readFiles.has(filePath)) {
+      return { allowed: true };
+    }
+    try {
+      const exists = await Bun.file(filePath).exists();
+      if (exists) {
+        return {
+          allowed: false,
+          reason: `File ${filePath} already exists. Read it first with the Read tool before overwriting.`
+        };
+      }
+    } catch {}
+    return { allowed: true };
+  }
+  function processToolCall(toolName, args) {
+    const path = args["path"] || args["filePath"];
+    if (!path)
+      return;
+    if (READ_TOOLS.has(toolName)) {
+      markRead(path);
+    } else if (WRITE_TOOLS.has(toolName)) {
+      markWritten(path);
+    }
+  }
+  return {
+    markRead,
+    markWritten,
+    checkWrite,
+    processToolCall,
+    getState: () => ({ ...state })
+  };
+}
+
+// src/hooks/first-message-variant.ts
+var appliedSessions = new Set;
+var createdSessions = new Set;
+function shouldApplyVariant(sessionId, _agentName) {
+  return createdSessions.has(sessionId) && !appliedSessions.has(sessionId);
+}
+function markApplied(sessionId) {
+  appliedSessions.add(sessionId);
+}
+function markSessionCreated(sessionId) {
+  createdSessions.add(sessionId);
+}
+function clearSession(sessionId) {
+  appliedSessions.delete(sessionId);
+  createdSessions.delete(sessionId);
+}
+
+// src/hooks/keyword-detector.ts
+var KEYWORD_PATTERNS = [
+  {
+    keyword: "run-workflow",
+    patterns: [/^\/run-workflow\b/i, /^run-workflow\b/i]
+  },
+  {
+    keyword: "implement",
+    patterns: [/^\/implement\b/i, /^implement\b/i]
+  },
+  {
+    keyword: "workflow-pause",
+    patterns: [/\bworkflow\s+pause\b/i, /\bpause\s+workflow\b/i]
+  },
+  {
+    keyword: "workflow-skip",
+    patterns: [/\bworkflow\s+skip\b/i, /\bskip\s+step\b/i]
+  },
+  {
+    keyword: "workflow-abort",
+    patterns: [/\bworkflow\s+abort\b/i, /\babort\s+workflow\b/i]
+  },
+  {
+    keyword: "workflow-status",
+    patterns: [/\bworkflow\s+status\b/i]
+  },
+  {
+    keyword: "workflow-resume",
+    patterns: [/\bworkflow\s+resume\b/i, /\bresume\s+workflow\b/i]
+  }
+];
+function processMessageForKeywords(message) {
+  const detected = [];
+  let primary;
+  let args;
+  for (const { keyword, patterns } of KEYWORD_PATTERNS) {
+    for (const pattern of patterns) {
+      if (pattern.test(message)) {
+        detected.push(keyword);
+        if (!primary) {
+          primary = keyword;
+          const match = message.match(pattern);
+          if (match) {
+            const afterKeyword = message.slice(match.index + match[0].length).trim();
+            if (afterKeyword) {
+              args = afterKeyword;
+            }
+          }
+        }
+        break;
+      }
+    }
+  }
+  return { keywords: detected, primary, args };
+}
+
+// src/domain/policy/policy-result.ts
+function allow(reason) {
+  return { verdict: "allow", reason };
+}
+function deny(reason, metadata) {
+  return { verdict: "deny", reason, metadata };
+}
+
+// src/hooks/architect-md-only.ts
+var ARCHITECT_AGENT = "architect";
+var ALLOWED_DIR = ".lead/";
+var WRITE_TOOLS2 = new Set(["write", "Write", "edit", "Edit"]);
+function checkArchitectWrite(input) {
+  const { toolName, args, agentName } = input;
+  if (agentName !== ARCHITECT_AGENT) {
+    return allow();
+  }
+  if (!WRITE_TOOLS2.has(toolName)) {
+    return allow();
+  }
+  const filePath = args["path"] || args["filePath"] || "";
+  if (!filePath) {
+    return allow();
+  }
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  if (!normalizedPath.endsWith(".md")) {
+    return deny(`Architect agent may only write Markdown (.md) files in the ${ALLOWED_DIR} directory. Attempted: ${filePath}`, { toolName, filePath });
+  }
+  if (!normalizedPath.includes(ALLOWED_DIR) && !normalizedPath.includes("/" + ALLOWED_DIR.replace(/\/$/, ""))) {
+    return deny(`Architect agent may only write files in the ${ALLOWED_DIR} directory. Attempted: ${filePath}`, { toolName, filePath });
+  }
+  return allow();
+}
+
+// src/hooks/start-implementation-hook.ts
+import { join as join4 } from "path";
+
+// src/features/work-state/storage.ts
+import { existsSync as existsSync3, readFileSync as readFileSync4, writeFileSync, mkdirSync } from "fs";
+import { join as join3, dirname } from "path";
+
+// src/features/work-state/constants.ts
+var STATE_DIR = ".lead";
+var STATE_FILE = ".lead/state.json";
+var ADHOC_DIR = ".lead/_adhoc";
+
+// src/features/work-state/storage.ts
+function readWorkState(dir) {
+  const filePath = join3(dir, STATE_FILE);
+  if (!existsSync3(filePath))
+    return null;
+  try {
+    const raw = readFileSync4(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeWorkState(dir, state) {
+  const filePath = join3(dir, STATE_FILE);
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, JSON.stringify(state, null, 2));
+}
+function getPlanProgress(planPath) {
+  if (!existsSync3(planPath)) {
+    return { total: 0, completed: 0, isComplete: false };
+  }
+  try {
+    const content = readFileSync4(planPath, "utf-8");
+    const unchecked = (content.match(/- \[ \]/g) ?? []).length;
+    const checked = (content.match(/- \[x\]/gi) ?? []).length;
+    const total = unchecked + checked;
+    return {
+      total,
+      completed: checked,
+      isComplete: total === 0 || checked === total
+    };
+  } catch {
+    return { total: 0, completed: 0, isComplete: false };
+  }
+}
+
+// src/hooks/start-implementation-hook.ts
+async function findPlanFile(directory, planNameOrPath) {
+  if (planNameOrPath.startsWith("/")) {
+    try {
+      if (await Bun.file(planNameOrPath).exists())
+        return planNameOrPath;
+    } catch {}
+    return null;
+  }
+  const directPath = join4(directory, planNameOrPath);
+  try {
+    if (await Bun.file(directPath).exists())
+      return directPath;
+  } catch {}
+  const ticketPlanPath = join4(directory, STATE_DIR, planNameOrPath, "plan.md");
+  try {
+    if (await Bun.file(ticketPlanPath).exists())
+      return ticketPlanPath;
+  } catch {}
+  const adhocName = planNameOrPath.endsWith(".md") ? planNameOrPath : `${planNameOrPath}.md`;
+  const adhocPath = join4(directory, ADHOC_DIR, adhocName);
+  try {
+    if (await Bun.file(adhocPath).exists())
+      return adhocPath;
+  } catch {}
+  try {
+    const glob = new Bun.Glob("**/*.md");
+    const leadDir = join4(directory, STATE_DIR);
+    const needle = planNameOrPath.toLowerCase();
+    for await (const entry of glob.scan(leadDir)) {
+      if (entry === "state.json")
+        continue;
+      const basename = entry.replace(/\.md$/, "").toLowerCase();
+      const parts = basename.split("/");
+      const leaf = parts[parts.length - 1];
+      if (leaf === needle || leaf.includes(needle) || parts.some((p) => p === needle || p.includes(needle))) {
+        return join4(leadDir, entry);
+      }
+    }
+  } catch {}
+  return null;
+}
+async function handleStartImplementation(options) {
+  const { args, sessionId, directory, startSha } = options;
+  const trimmedArgs = args.trim();
+  if (!trimmedArgs) {
+    const existingState = readWorkState(directory);
+    if (existingState && !existingState.paused) {
+      const progress2 = getPlanProgress(existingState.active_plan);
+      return {
+        prompt: buildContinuationPrompt(existingState, progress2)
+      };
+    }
+    return {
+      prompt: null,
+      error: `No plan specified. Usage: /implement <plan-name-or-ticket>
+
+Plans are in .lead/<ticket>/plan.md or .lead/_adhoc/`
+    };
+  }
+  const planPath = await findPlanFile(directory, trimmedArgs);
+  if (!planPath) {
+    return {
+      prompt: null,
+      error: `Plan not found: "${trimmedArgs}"
+
+Looked in:
+- .lead/${trimmedArgs}/plan.md
+- .lead/_adhoc/${trimmedArgs}.md
+
+Create a plan first with the architect agent.`
+    };
+  }
+  let planContent = "";
+  try {
+    planContent = await Bun.file(planPath).text();
+  } catch {
+    return { prompt: null, error: `Could not read plan file: ${planPath}` };
+  }
+  const titleMatch = planContent.match(/^#\s+(.+)$/m);
+  const planName = titleMatch?.[1]?.trim() ?? trimmedArgs;
+  const workState = {
+    active_plan: planPath,
+    started_at: new Date().toISOString(),
+    session_ids: [sessionId],
+    plan_name: planName,
+    start_sha: startSha,
+    paused: false,
+    continuation_completed_snapshot: 0,
+    stale_continuation_count: 0
+  };
+  writeWorkState(directory, workState);
+  const progress = getPlanProgress(planPath);
+  const prompt = buildStartPrompt(workState, progress, planContent);
+  return { prompt };
+}
+function buildStartPrompt(state, progress, _planContent) {
+  const remaining = progress.total - progress.completed;
+  return `You are now the **Executor** — your job is to execute the plan at \`${state.active_plan}\`.
+
+**Plan**: ${state.plan_name}
+**Progress**: ${progress.completed}/${progress.total} tasks complete (${remaining} remaining)
+
+Start by reading the plan file to understand the current state. Find the first unchecked \`- [ ]\` task and begin executing it. Work through tasks sequentially, marking each \`- [x]\` when complete.
+
+**Execution protocol**:
+1. Read the plan file to find the first unchecked task
+2. Mark it in_progress in the sidebar todos
+3. Execute the task step by step
+4. Verify acceptance criteria are met
+5. Mark \`- [ ]\` → \`- [x]\` in the plan file
+6. Continue to the next task
+
+Do not stop until all tasks are complete or you are explicitly blocked.`;
+}
+function buildContinuationPrompt(state, progress) {
+  const remaining = progress.total - progress.completed;
+  return `Resuming work on plan: **${state.plan_name}**
+
+**Progress**: ${progress.completed}/${progress.total} tasks complete (${remaining} remaining)
+**Plan file**: \`${state.active_plan}\`
+
+Read the plan file, find the next unchecked \`- [ ]\` task, and continue execution.`;
+}
+
+// src/hooks/work-continuation.ts
+var MAX_STALE_CONTINUATIONS = 3;
+function checkContinuation(options) {
+  const { sessionId, directory, lastAssistantMessage } = options;
+  const state = readWorkState(directory);
+  if (!state || state.paused) {
+    return { continuationPrompt: null };
+  }
+  const progress = getPlanProgress(state.active_plan);
+  if (progress.isComplete) {
+    return {
+      continuationPrompt: `✅ Plan **${state.plan_name}** is complete! All ${progress.total} tasks done.`,
+      planComplete: true
+    };
+  }
+  const isStaleContinuation = lastAssistantMessage?.includes(state.active_plan) && lastAssistantMessage?.includes("- [ ]");
+  const completedSnapshot = state.continuation_completed_snapshot ?? 0;
+  const isNoProgress = progress.completed === completedSnapshot;
+  if (isStaleContinuation && isNoProgress) {
+    const staleCount = (state.stale_continuation_count ?? 0) + 1;
+    if (staleCount >= MAX_STALE_CONTINUATIONS) {
+      writeWorkState(directory, { ...state, paused: true });
+      return {
+        continuationPrompt: `⚠️ Work on plan **${state.plan_name}** has been paused after ${staleCount} continuations with no progress. Resume manually with \`/implement ${state.plan_name}\`.`
+      };
+    }
+    writeWorkState(directory, {
+      ...state,
+      stale_continuation_count: staleCount,
+      session_ids: state.session_ids.includes(sessionId) ? state.session_ids : [...state.session_ids, sessionId]
+    });
+  } else {
+    writeWorkState(directory, {
+      ...state,
+      continuation_completed_snapshot: progress.completed,
+      stale_continuation_count: 0,
+      session_ids: state.session_ids.includes(sessionId) ? state.session_ids : [...state.session_ids, sessionId]
+    });
+  }
+  const remaining = progress.total - progress.completed;
+  return {
+    continuationPrompt: `Continue working on plan: **${state.plan_name}**
+
+**Progress**: ${progress.completed}/${progress.total} tasks complete (${remaining} remaining)
+**Plan file**: \`${state.active_plan}\`
+
+Read the plan file, find the next unchecked \`- [ ]\` task, and continue execution. Do not stop until all tasks are complete.`
+  };
+}
+
+// src/features/workflow/storage.ts
+import { existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join5 } from "path";
+
+// src/features/workflow/constants.ts
+var WORKFLOW_STATE_DIR = ".lead/workflows";
+var ACTIVE_INSTANCE_FILE = ".lead/workflows/active-instance.json";
+var WORKFLOW_CONTINUATION_MARKER = "<!-- lead:workflow-continuation -->";
+var WORKFLOW_STEP_COMPLETE_SIGNAL = "<!-- workflow:step-complete -->";
+
+// src/features/workflow/storage.ts
+function ensureWorkflowDir(dir) {
+  const stateDir = join5(dir, WORKFLOW_STATE_DIR);
+  mkdirSync2(stateDir, { recursive: true });
+}
+function saveWorkflowInstance(dir, instance) {
+  ensureWorkflowDir(dir);
+  const filePath = join5(dir, WORKFLOW_STATE_DIR, `${instance.instance_id}.json`);
+  writeFileSync2(filePath, JSON.stringify(instance, null, 2));
+}
+function loadWorkflowInstance(dir, instanceId) {
+  const filePath = join5(dir, WORKFLOW_STATE_DIR, `${instanceId}.json`);
+  if (!existsSync4(filePath))
+    return null;
+  try {
+    return JSON.parse(readFileSync5(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function loadActiveInstance(dir) {
+  const pointerPath = join5(dir, ACTIVE_INSTANCE_FILE);
+  if (!existsSync4(pointerPath))
+    return null;
+  try {
+    const pointer = JSON.parse(readFileSync5(pointerPath, "utf-8"));
+    return loadWorkflowInstance(dir, pointer.instance_id);
+  } catch {
+    return null;
+  }
+}
+function setActiveInstance(dir, instanceId) {
+  ensureWorkflowDir(dir);
+  const pointerPath = join5(dir, ACTIVE_INSTANCE_FILE);
+  const pointer = { instance_id: instanceId };
+  writeFileSync2(pointerPath, JSON.stringify(pointer, null, 2));
+}
+function clearActiveInstance(dir) {
+  const pointerPath = join5(dir, ACTIVE_INSTANCE_FILE);
+  if (existsSync4(pointerPath)) {
+    try {
+      const { unlinkSync } = __require("fs");
+      unlinkSync(pointerPath);
+    } catch {}
+  }
+}
+
+// src/hooks/compaction-recovery.ts
+function checkCompactionRecovery(options) {
+  const { directory } = options;
+  const parts = [];
+  const workState = readWorkState(directory);
+  if (workState && !workState.paused) {
+    const progress = getPlanProgress(workState.active_plan);
+    if (!progress.isComplete) {
+      parts.push(`## Active Plan: ${workState.plan_name}
+
+**File**: \`${workState.active_plan}\`
+**Progress**: ${progress.completed}/${progress.total} tasks complete
+
+You were executing this plan. Read the plan file to find the next unchecked \`- [ ]\` task and continue execution.`);
+    }
+  }
+  const workflowInstance = loadActiveInstance(directory);
+  if (workflowInstance && workflowInstance.status === "running") {
+    parts.push(`## Active Workflow: ${workflowInstance.definition_name}
+
+**Instance**: ${workflowInstance.instance_id}
+**Goal**: ${workflowInstance.goal}
+**Current Step**: ${workflowInstance.current_step_id}
+
+You were executing a workflow. Continue from the current step.`);
+  }
+  if (parts.length === 0) {
+    return { recoveryPrompt: null };
+  }
+  const recoveryPrompt = `# Context Recovery After Compaction
+
+Your context was compacted. Here is a summary of your active work:
+
+${parts.join(`
+
+---
+
+`)}
+
+Resume where you left off.`;
+  return { recoveryPrompt };
+}
+
+// src/hooks/verification-reminder.ts
+var IMPLEMENTATION_TOOLS = new Set([
+  "write",
+  "Write",
+  "edit",
+  "Edit",
+  "bash",
+  "Bash"
+]);
+var REMINDER_AGENTS = new Set(["lead-dev", "engineer", "tester"]);
+function buildVerificationReminder(options) {
+  const { toolName, agentName } = options;
+  if (!IMPLEMENTATION_TOOLS.has(toolName)) {
+    return { reminderText: null };
+  }
+  if (agentName && !REMINDER_AGENTS.has(agentName)) {
+    return { reminderText: null };
+  }
+  return {
+    reminderText: `After making changes, verify your work:
+1. Run \`bun run typecheck\` to check for TypeScript errors
+2. Run \`bun test\` to ensure tests pass
+3. Review changed files for correctness before proceeding`
+  };
+}
+
+// src/hooks/todo-description-override.ts
+var TODO_WRITE_TOOL = "todowrite";
+var ENHANCED_DESCRIPTION = `Manage the sidebar todo list. 
+
+CRITICAL RULES:
+- This tool performs a FULL ARRAY REPLACEMENT on every call
+- ALWAYS include ALL current todos in EVERY call — never drop items
+- Max 35 chars per todo content
+- Mark tasks in_progress BEFORE starting, completed IMMEDIATELY after finishing
+- NEVER batch completions — mark one at a time
+- Status values: "pending", "in_progress", "completed", "cancelled"
+- Priority values: "high", "medium", "low"
+- Use format: "N/M: Task title" for numbered tasks
+- ALWAYS issue a final todowrite before your last response marking all in_progress → completed`;
+function applyTodoDescriptionOverride(toolName, originalDescription) {
+  if (toolName.toLowerCase() === TODO_WRITE_TOOL.toLowerCase()) {
+    return ENHANCED_DESCRIPTION;
+  }
+  return originalDescription;
+}
+
+// src/hooks/todo-continuation-enforcer.ts
+function checkStaleTodos(todos) {
+  const staleTodos = todos.filter((t) => t.status === "in_progress");
+  if (staleTodos.length === 0) {
+    return { hasStale: false, prompt: null, staleTodos: [] };
+  }
+  const staleList = staleTodos.map((t) => `- "${t.content}"`).join(`
+`);
+  return {
+    hasStale: true,
+    staleTodos,
+    prompt: `You have ${staleTodos.length} in_progress todo(s) that appear stale:
+
+${staleList}
+
+Please either:
+1. Complete the tasks and mark them "completed"
+2. Update the todos with current status using the todowrite tool
+3. Mark them "cancelled" if they are no longer needed
+
+Never leave in_progress items unattended — they are tracked as work in progress.`
+  };
+}
+
+// src/hooks/compaction-todo-preserver.ts
+var todoStateStore = new Map;
+function saveTodoStateForCompaction(sessionId, todos) {
+  todoStateStore.set(sessionId, [...todos]);
+}
+function getPreservedTodoState(sessionId) {
+  return todoStateStore.get(sessionId) ?? null;
+}
+function buildTodoPreservationPrompt(sessionId) {
+  const todos = getPreservedTodoState(sessionId);
+  if (!todos || todos.length === 0)
+    return null;
+  const inProgress = todos.filter((t) => t.status === "in_progress");
+  const pending = todos.filter((t) => t.status === "pending");
+  if (inProgress.length === 0 && pending.length === 0)
+    return null;
+  const parts = ["## Preserved Todo State (Before Compaction)"];
+  if (inProgress.length > 0) {
+    parts.push(`**In Progress** (${inProgress.length}):
+${inProgress.map((t) => `- ${t.content}`).join(`
+`)}`);
+  }
+  if (pending.length > 0) {
+    parts.push(`**Pending** (${pending.length}):
+${pending.map((t) => `- ${t.content}`).join(`
+`)}`);
+  }
+  parts.push("Restore this todo state using the todowrite tool before continuing.");
+  return parts.join(`
+
+`);
+}
+
+// src/hooks/todo-writer.ts
+var TODO_WRITE_TOOL2 = "todowrite";
+function captureToDoWrite(input) {
+  const { toolName, args, sessionId } = input;
+  if (toolName.toLowerCase() !== TODO_WRITE_TOOL2.toLowerCase()) {
+    return { captured: false };
+  }
+  const rawTodos = args["todos"];
+  if (!Array.isArray(rawTodos)) {
+    return { captured: false };
+  }
+  const todos = rawTodos.filter((t) => typeof t === "object" && t !== null).map((t) => ({
+    content: String(t["content"] ?? ""),
+    status: t["status"] ?? "pending",
+    priority: t["priority"] ?? "medium"
+  }));
+  saveTodoStateForCompaction(sessionId, todos);
+  return { captured: true, todos };
+}
+
+// src/hooks/session-token-state.ts
+var tokenStateStore = new Map;
+function updateTokenState(sessionId, delta) {
+  const existing = tokenStateStore.get(sessionId) ?? {
+    sessionId,
+    inputTokens: 0,
+    outputTokens: 0,
+    contextWindow: 0,
+    lastUpdatedAt: new Date
+  };
+  const updated = {
+    ...existing,
+    inputTokens: existing.inputTokens + (delta.inputTokens ?? 0),
+    outputTokens: existing.outputTokens + (delta.outputTokens ?? 0),
+    contextWindow: delta.contextWindow ?? existing.contextWindow,
+    lastUpdatedAt: new Date
+  };
+  tokenStateStore.set(sessionId, updated);
+  return updated;
+}
+
+// src/hooks/create-hooks.ts
+function isHookEnabled(hookName, disabledHooks) {
+  return !disabledHooks.includes(hookName);
+}
+function createHooks(args) {
+  const disabled = args.pluginConfig.disabled_hooks ?? [];
+  const _ = isHookEnabled;
+  return {
+    checkContextWindow: isHookEnabled("context-window-monitor", disabled) ? checkContextWindow : () => ({ severity: "ok", usagePercent: 0 }),
+    createWriteGuard: isHookEnabled("write-guard", disabled) ? createWriteGuard : () => ({
+      markRead: () => {},
+      markWritten: () => {},
+      checkWrite: async () => ({ allowed: true }),
+      processToolCall: () => {},
+      getState: () => ({ readFiles: new Set, writtenFiles: new Set })
+    }),
+    shouldApplyVariant: isHookEnabled("first-message-variant", disabled) ? shouldApplyVariant : () => false,
+    markApplied,
+    markSessionCreated,
+    clearSession,
+    processMessageForKeywords: isHookEnabled("keyword-detector", disabled) ? processMessageForKeywords : () => ({ keywords: [] }),
+    checkArchitectWrite: isHookEnabled("architect-md-only", disabled) ? checkArchitectWrite : () => ({ verdict: "allow" }),
+    handleStartImplementation: isHookEnabled("implement", disabled) ? handleStartImplementation : async () => ({ prompt: null }),
+    checkContinuation: isHookEnabled("work-continuation", disabled) ? checkContinuation : () => ({ continuationPrompt: null }),
+    checkCompactionRecovery: isHookEnabled("compaction-recovery", disabled) ? checkCompactionRecovery : () => ({ recoveryPrompt: null }),
+    buildVerificationReminder: isHookEnabled("verification-reminder", disabled) ? buildVerificationReminder : () => ({ reminderText: null }),
+    applyTodoDescriptionOverride: isHookEnabled("todo-description-override", disabled) ? applyTodoDescriptionOverride : (_tool, desc) => desc,
+    checkStaleTodos: isHookEnabled("todo-continuation", disabled) ? checkStaleTodos : () => ({ hasStale: false, prompt: null, staleTodos: [] }),
+    buildTodoPreservationPrompt: isHookEnabled("compaction-todo-preserver", disabled) ? buildTodoPreservationPrompt : () => null,
+    captureToDoWrite: isHookEnabled("todo-writer", disabled) ? captureToDoWrite : () => ({ captured: false }),
+    updateTokenState: isHookEnabled("session-token-state", disabled) ? updateTokenState : (_sessionId, _delta) => ({
+      sessionId: _sessionId,
+      inputTokens: 0,
+      outputTokens: 0,
+      contextWindow: 0,
+      lastUpdatedAt: new Date
+    })
+  };
+}
+
+// src/features/workflow/discovery.ts
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir3 } from "os";
+
+// src/features/workflow/schema.ts
+import { z as z2 } from "zod";
+var StepTypeSchema = z2.enum(["interactive", "autonomous", "gate"]);
+var CompletionMethodSchema = z2.enum([
+  "user_confirm",
+  "plan_created",
+  "plan_complete",
+  "review_verdict",
+  "agent_signal"
+]);
+var CompletionConfigSchema = z2.object({
+  method: CompletionMethodSchema,
+  plan_name: z2.string().optional(),
+  keywords: z2.array(z2.string()).optional()
+});
+var StepArtifactRefSchema = z2.object({
+  name: z2.string().min(1),
+  description: z2.string().optional()
+});
+var StepArtifactsSchema = z2.object({
+  inputs: z2.array(StepArtifactRefSchema).optional(),
+  outputs: z2.array(StepArtifactRefSchema).optional()
+});
+var WorkflowStepDefinitionSchema = z2.object({
+  id: z2.string().regex(/^[a-z0-9-]+$/, "Step ID must be lowercase alphanumeric with hyphens"),
+  name: z2.string().min(1),
+  type: StepTypeSchema,
+  agent: z2.string().min(1),
+  prompt: z2.string().min(1),
+  completion: CompletionConfigSchema,
+  artifacts: StepArtifactsSchema.optional(),
+  on_reject: z2.enum(["pause", "fail"]).optional()
+});
+var WorkflowDefinitionSchema = z2.object({
+  name: z2.string().regex(/^[a-z0-9-]+$/, "Workflow name must be lowercase alphanumeric with hyphens"),
+  description: z2.string().optional(),
+  version: z2.literal(1),
+  steps: z2.array(WorkflowStepDefinitionSchema).min(1, "Workflow must have at least one step")
+}).superRefine((data, ctx) => {
+  const ids = data.steps.map((s) => s.id);
+  const unique = new Set(ids);
+  if (ids.length !== unique.size) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: "Workflow step IDs must be unique"
+    });
+  }
+});
+
+// src/features/workflow/discovery.ts
+function parseWorkflowFile(filePath, scope) {
+  try {
+    const content = readFileSync6(filePath, "utf-8");
+    const raw = parse2(content);
+    const result = WorkflowDefinitionSchema.safeParse(raw);
+    if (!result.success) {
+      return null;
+    }
+    return {
+      definition: result.data,
+      path: filePath,
+      scope
+    };
+  } catch {
+    return null;
+  }
+}
+function scanWorkflowDir(dir, scope) {
+  if (!existsSync5(dir))
+    return [];
+  const results = [];
+  try {
+    const entries = readdirSync2(dir);
+    for (const entry of entries) {
+      if (entry.endsWith(".jsonc") || entry.endsWith(".json")) {
+        const fullPath = join6(dir, entry);
+        const workflow = parseWorkflowFile(fullPath, scope);
+        if (workflow) {
+          results.push(workflow);
+        }
+      }
+    }
+  } catch {}
+  return results;
+}
+function discoverWorkflows(options) {
+  const { projectDirectory, customDirs = [] } = options;
+  const byName = new Map;
+  const userDir = join6(homedir3(), ".config", "opencode", "workflows");
+  for (const wf of scanWorkflowDir(userDir, "user")) {
+    byName.set(wf.definition.name, wf);
+  }
+  const projectDir = join6(projectDirectory, ".opencode", "workflows");
+  for (const wf of scanWorkflowDir(projectDir, "project")) {
+    byName.set(wf.definition.name, wf);
+  }
+  for (const customDir of customDirs) {
+    const safePath = resolveSafePath(projectDirectory, customDir);
+    if (!safePath)
+      continue;
+    for (const wf of scanWorkflowDir(safePath, "project")) {
+      byName.set(wf.definition.name, wf);
+    }
+  }
+  return Array.from(byName.values());
+}
+
+// src/features/workflow/engine.ts
+import { randomBytes } from "crypto";
+
+// src/features/workflow/context.ts
+function substituteTemplateVars(template, instance, stepDef) {
+  return template.replace(/\{\{instance\.goal\}\}/g, instance.goal).replace(/\{\{instance\.slug\}\}/g, instance.slug).replace(/\{\{instance\.instance_id\}\}/g, instance.instance_id).replace(/\{\{step\.id\}\}/g, stepDef.id).replace(/\{\{step\.name\}\}/g, stepDef.name).replace(/\{\{artifacts\.([^}]+)\}\}/g, (_match, name) => {
+    return instance.artifacts[name] ?? `[artifact '${name}' not available]`;
+  });
+}
+function buildStepContext(instance, stepDef, definition) {
+  const renderedPrompt = substituteTemplateVars(stepDef.prompt, instance, stepDef);
+  const artifactSummary = Object.keys(instance.artifacts).length > 0 ? Object.entries(instance.artifacts).map(([k, v]) => `**${k}**: ${v}`).join(`
+`) : "(none)";
+  const stepIndex = definition.steps.findIndex((s) => s.id === stepDef.id);
+  const totalSteps = definition.steps.length;
+  return [
+    renderedPrompt,
+    "",
+    `**Workflow**: "${definition.name}"`,
+    `**Goal**: "${instance.goal}"`,
+    `**Step**: ${stepDef.name} (${stepIndex + 1}/${totalSteps})`,
+    `**Previous Artifacts**:`,
+    artifactSummary
+  ].join(`
+`);
+}
+
+// src/features/workflow/completion.ts
+import { existsSync as existsSync6, readdirSync as readdirSync3 } from "fs";
+import { join as join7 } from "path";
+var DEFAULT_USER_CONFIRM_KEYWORDS = [
+  "confirmed",
+  "approved",
+  "continue",
+  "done",
+  "let's proceed",
+  "looks good",
+  "lgtm"
+];
+function containsKeyword(text, keywords) {
+  const lower = text.toLowerCase();
+  return keywords.some((kw) => lower.includes(kw.toLowerCase()));
+}
+function checkStepCompletion(method, ctx) {
+  switch (method) {
+    case "user_confirm": {
+      const keywords = ctx.config.keywords?.length ? ctx.config.keywords : DEFAULT_USER_CONFIRM_KEYWORDS;
+      const msg = ctx.lastUserMessage ?? "";
+      if (containsKeyword(msg, keywords)) {
+        return {
+          complete: true,
+          summary: `User confirmed: "${msg.slice(0, 80)}"`
+        };
+      }
+      return { complete: false };
+    }
+    case "plan_created": {
+      const planName = ctx.config.plan_name;
+      if (!planName)
+        return { complete: false };
+      const leadDir = join7(ctx.directory, ".lead");
+      if (!existsSync6(leadDir))
+        return { complete: false };
+      let found = null;
+      try {
+        const entries = readdirSync3(leadDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory() && entry.name !== "_adhoc" && entry.name !== "workflow") {
+            const ticketPlan = join7(leadDir, entry.name, "plan.md");
+            if (existsSync6(ticketPlan)) {
+              found = ticketPlan;
+              break;
+            }
+          }
+        }
+        if (!found) {
+          const adhocDir = join7(leadDir, "_adhoc");
+          if (existsSync6(adhocDir)) {
+            const adhocEntries = readdirSync3(adhocDir);
+            for (const e of adhocEntries) {
+              if (e === `${planName}.md` || e.includes(planName)) {
+                found = join7(adhocDir, e);
+                break;
+              }
+            }
+          }
+        }
+      } catch {
+        return { complete: false };
+      }
+      if (found) {
+        return {
+          complete: true,
+          artifacts: { plan_path: found },
+          summary: `Plan created at: ${found}`
+        };
+      }
+      return { complete: false };
+    }
+    case "plan_complete": {
+      const planName = ctx.config.plan_name;
+      if (!planName)
+        return { complete: false };
+      const plansDir = join7(ctx.directory, ".lead", "plans");
+      if (!existsSync6(plansDir))
+        return { complete: false };
+      let planPath = null;
+      try {
+        const entries = readdirSync3(plansDir);
+        for (const entry of entries) {
+          if (entry === `${planName}.md` || entry.includes(planName)) {
+            planPath = join7(plansDir, entry);
+            break;
+          }
+        }
+      } catch {
+        return { complete: false };
+      }
+      if (!planPath)
+        return { complete: false };
+      const progress = getPlanProgress(planPath);
+      if (progress.isComplete) {
+        return {
+          complete: true,
+          summary: `Plan completed: ${progress.completed}/${progress.total} tasks done`
+        };
+      }
+      return { complete: false };
+    }
+    case "review_verdict": {
+      const msg = ctx.lastAssistantMessage ?? "";
+      if (/\[\s*APPROVE\s*\]/i.test(msg)) {
+        return {
+          complete: true,
+          verdict: "approve",
+          summary: "Review verdict: APPROVE"
+        };
+      }
+      if (/\[\s*REJECT\s*\]/i.test(msg)) {
+        return {
+          complete: true,
+          verdict: "reject",
+          summary: "Review verdict: REJECT"
+        };
+      }
+      return { complete: false };
+    }
+    case "agent_signal": {
+      const msg = ctx.lastAssistantMessage ?? "";
+      if (msg.includes(WORKFLOW_STEP_COMPLETE_SIGNAL)) {
+        return {
+          complete: true,
+          summary: "Agent signaled step completion"
+        };
+      }
+      const keywords = ctx.config.keywords ?? [];
+      if (keywords.length > 0 && containsKeyword(msg, keywords)) {
+        return {
+          complete: true,
+          summary: `Agent signaled via keyword`
+        };
+      }
+      return { complete: false };
+    }
+    default:
+      return { complete: false };
+  }
+}
+
+// src/features/workflow/engine.ts
+function generateInstanceId() {
+  return "wf_" + randomBytes(4).toString("hex");
+}
+function generateSlug(goal) {
+  return goal.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").slice(0, 50).replace(/-+$/, "");
+}
+function nowIso() {
+  return new Date().toISOString();
+}
+function startWorkflow(input) {
+  const { definition, definitionPath, goal, sessionId, directory } = input;
+  const instanceId = generateInstanceId();
+  const slug = generateSlug(goal);
+  const firstStep = definition.steps[0];
+  const steps = {};
+  for (const [i, stepDef] of definition.steps.entries()) {
+    steps[stepDef.id] = {
+      id: stepDef.id,
+      status: i === 0 ? "active" : "pending"
+    };
+  }
+  const instance = {
+    instance_id: instanceId,
+    definition_id: definition.name,
+    definition_name: definition.name,
+    definition_path: definitionPath,
+    goal,
+    slug,
+    status: "running",
+    started_at: nowIso(),
+    session_ids: [sessionId],
+    current_step_id: firstStep.id,
+    steps,
+    artifacts: {}
+  };
+  saveWorkflowInstance(directory, instance);
+  setActiveInstance(directory, instanceId);
+  const prompt = buildStepContext(instance, firstStep, definition);
+  return { type: "inject_prompt", prompt, agent: firstStep.agent };
+}
+function checkAndAdvance(input) {
+  const { directory, context, definition } = input;
+  const instance = loadActiveInstance(directory);
+  if (!instance || instance.status !== "running") {
+    return { type: "none" };
+  }
+  const currentStepDef = definition.steps.find((s) => s.id === instance.current_step_id);
+  if (!currentStepDef) {
+    return { type: "none" };
+  }
+  const result = checkStepCompletion(currentStepDef.completion.method, {
+    ...context,
+    config: currentStepDef.completion,
+    artifacts: instance.artifacts
+  });
+  if (!result.complete) {
+    return { type: "none" };
+  }
+  if (result.verdict === "reject") {
+    const onReject = currentStepDef.on_reject ?? "pause";
+    if (onReject === "pause") {
+      instance.status = "paused";
+      instance.pause_reason = result.summary;
+    } else {
+      instance.status = "failed";
+      instance.ended_at = nowIso();
+      clearActiveInstance(directory);
+    }
+    instance.steps[currentStepDef.id].status = "failed";
+    instance.steps[currentStepDef.id].verdict = "reject";
+    saveWorkflowInstance(directory, instance);
+    return { type: "pause", reason: result.summary };
+  }
+  instance.steps[currentStepDef.id].status = "completed";
+  instance.steps[currentStepDef.id].completed_at = nowIso();
+  instance.steps[currentStepDef.id].verdict = result.verdict;
+  instance.steps[currentStepDef.id].summary = result.summary;
+  if (result.artifacts) {
+    Object.assign(instance.artifacts, result.artifacts);
+  }
+  const currentIndex = definition.steps.findIndex((s) => s.id === instance.current_step_id);
+  const nextStep = definition.steps[currentIndex + 1];
+  if (!nextStep) {
+    instance.status = "completed";
+    instance.ended_at = nowIso();
+    saveWorkflowInstance(directory, instance);
+    clearActiveInstance(directory);
+    return { type: "complete", reason: "All workflow steps completed" };
+  }
+  instance.current_step_id = nextStep.id;
+  instance.steps[nextStep.id].status = "active";
+  instance.steps[nextStep.id].started_at = nowIso();
+  saveWorkflowInstance(directory, instance);
+  const prompt = buildStepContext(instance, nextStep, definition);
+  return { type: "inject_prompt", prompt, agent: nextStep.agent };
+}
+function pauseWorkflow(directory, reason) {
+  const instance = loadActiveInstance(directory);
+  if (!instance)
+    return false;
+  instance.status = "paused";
+  if (reason)
+    instance.pause_reason = reason;
+  saveWorkflowInstance(directory, instance);
+  return true;
+}
+function resumeWorkflow(directory, definition) {
+  const instance = loadActiveInstance(directory);
+  if (!instance || instance.status !== "paused")
+    return { type: "none" };
+  instance.status = "running";
+  instance.pause_reason = undefined;
+  saveWorkflowInstance(directory, instance);
+  const stepDef = definition.steps.find((s) => s.id === instance.current_step_id);
+  if (!stepDef)
+    return { type: "none" };
+  const prompt = buildStepContext(instance, stepDef, definition);
+  return { type: "inject_prompt", prompt, agent: stepDef.agent };
+}
+function abortWorkflow(directory) {
+  const instance = loadActiveInstance(directory);
+  if (!instance)
+    return false;
+  instance.status = "cancelled";
+  instance.ended_at = nowIso();
+  saveWorkflowInstance(directory, instance);
+  clearActiveInstance(directory);
+  return true;
+}
+
+// src/features/workflow/hook.ts
+function parseWorkflowArgs(args) {
+  const trimmed = args.trim();
+  if (!trimmed)
+    return { workflowName: null, goal: null };
+  const quotedMatch = /^([^\s"]+)\s+"([^"]+)"/.exec(trimmed);
+  if (quotedMatch) {
+    return { workflowName: quotedMatch[1], goal: quotedMatch[2] };
+  }
+  const spaceIdx = trimmed.indexOf(" ");
+  if (spaceIdx !== -1) {
+    return {
+      workflowName: trimmed.slice(0, spaceIdx),
+      goal: trimmed.slice(spaceIdx + 1).trim()
+    };
+  }
+  return { workflowName: trimmed, goal: null };
+}
+async function handleRunWorkflow(input) {
+  const { promptText, sessionId, directory, customDirs } = input;
+  const argsText = promptText.replace(/^\/run-workflow\s*/, "").trim();
+  const { workflowName, goal } = parseWorkflowArgs(argsText);
+  const discovered = discoverWorkflows({ projectDirectory: directory, customDirs });
+  const active = loadActiveInstance(directory);
+  if (!workflowName) {
+    if (active) {
+      const def2 = discovered.find((d) => d.definition.name === active.definition_id);
+      if (!def2) {
+        return {
+          handled: true,
+          message: `Active workflow '${active.definition_id}' definition not found.`
+        };
+      }
+      const action2 = resumeWorkflow(directory, def2.definition);
+      return { handled: true, action: action2 };
+    }
+    if (discovered.length === 0) {
+      return {
+        handled: true,
+        message: "No workflows found. Create workflow definitions in `.opencode/workflows/` or `~/.config/opencode/workflows/`."
+      };
+    }
+    const list = discovered.map((d) => `- **${d.definition.name}**: ${d.definition.description ?? "no description"}`).join(`
+`);
+    return {
+      handled: true,
+      message: `Available workflows:
+${list}
+
+Use \`/run-workflow <name> "your goal"\` to start.`
+    };
+  }
+  const def = discovered.find((d) => d.definition.name === workflowName);
+  if (!def) {
+    return {
+      handled: true,
+      message: `Workflow '${workflowName}' not found. Available: ${discovered.map((d) => d.definition.name).join(", ") || "none"}`
+    };
+  }
+  if (!goal) {
+    if (active?.definition_id === workflowName) {
+      const action2 = resumeWorkflow(directory, def.definition);
+      return { handled: true, action: action2 };
+    }
+    return {
+      handled: true,
+      message: `Please provide a goal for workflow '${workflowName}'. Usage: /run-workflow ${workflowName} "your goal"`
+    };
+  }
+  if (active && active.status === "running") {
+    return {
+      handled: true,
+      message: `A workflow is already active: '${active.definition_id}'. Abort it first with "workflow abort".`
+    };
+  }
+  const action = startWorkflow({
+    definition: def.definition,
+    definitionPath: def.path,
+    goal,
+    sessionId,
+    directory
+  });
+  return { handled: true, action };
+}
+async function checkWorkflowContinuation(input) {
+  const { directory, lastAssistantMessage, lastUserMessage, customDirs } = input;
+  const active = loadActiveInstance(directory);
+  if (!active || active.status !== "running") {
+    return { continuationPrompt: null, switchAgent: null };
+  }
+  const discovered = discoverWorkflows({ projectDirectory: directory, customDirs });
+  const def = discovered.find((d) => d.definition.name === active.definition_id);
+  if (!def) {
+    return { continuationPrompt: null, switchAgent: null };
+  }
+  const action = checkAndAdvance({
+    directory,
+    context: { lastAssistantMessage, lastUserMessage, directory },
+    definition: def.definition
+  });
+  if (action.type === "inject_prompt" && action.prompt) {
+    return {
+      continuationPrompt: `${WORKFLOW_CONTINUATION_MARKER}
+
+${action.prompt}`,
+      switchAgent: action.agent ?? null
+    };
+  }
+  if (action.type === "complete") {
+    return {
+      continuationPrompt: `${WORKFLOW_CONTINUATION_MARKER}
+
+Workflow "${active.definition_name}" completed! All steps are done.`,
+      switchAgent: null
+    };
+  }
+  return { continuationPrompt: null, switchAgent: null };
+}
+function handleWorkflowCommand(message, directory) {
+  const lower = message.toLowerCase().trim();
+  if (lower === "workflow pause" || lower === "pause workflow") {
+    const ok = pauseWorkflow(directory, "User requested pause");
+    return ok ? "Workflow paused." : "No active workflow to pause.";
+  }
+  if (lower === "workflow abort" || lower === "abort workflow") {
+    const ok = abortWorkflow(directory);
+    return ok ? "Workflow aborted." : "No active workflow to abort.";
+  }
+  if (lower === "workflow status" || lower === "status workflow") {
+    const active = loadActiveInstance(directory);
+    if (!active)
+      return "No active workflow.";
+    return `Workflow: **${active.definition_name}** | Status: ${active.status} | Step: ${active.current_step_id}`;
+  }
+  return null;
+}
+
+// src/runtime/opencode/plugin-adapter.ts
+function textPart(text) {
+  return {
+    id: `synthetic-${Date.now()}`,
+    sessionID: "",
+    messageID: "",
+    type: "text",
+    text
+  };
+}
+var sessionAgentMap = new Map;
+var pendingContinuations = new Map;
+function createPluginAdapter(args) {
+  const { pluginConfig, directory, configHandler, hooks } = args;
+  return {
+    config: async (config) => {
+      debug("plugin", "config hook called");
+      configHandler.handle(config);
+    },
+    tool: {},
+    "chat.message": async (input, output) => {
+      const { sessionID, agent } = input;
+      debug("plugin", `chat.message: session=${sessionID} agent=${agent}`);
+      if (agent) {
+        sessionAgentMap.set(sessionID, agent);
+      }
+      markSessionCreated(sessionID);
+      const pending = pendingContinuations.get(sessionID);
+      if (pending && pending.length > 0) {
+        for (const prompt of pending) {
+          output.parts.push(textPart(prompt));
+        }
+        pendingContinuations.delete(sessionID);
+      }
+    },
+    "chat.params": async (_input, _output) => {},
+    event: async ({ event }) => {
+      debug("plugin", `event: ${event.type}`);
+      if (event.type === "session.idle" || event.type === "session.updated") {
+        const sessionID = event.sessionID ?? "";
+        const prompts = [];
+        const continuationResult = checkContinuation({
+          sessionId: sessionID,
+          directory
+        });
+        if (continuationResult.continuationPrompt) {
+          info("plugin", "Work continuation detected");
+          prompts.push(continuationResult.continuationPrompt);
+        }
+        const workflowResult = await checkWorkflowContinuation({
+          sessionId: sessionID,
+          directory,
+          customDirs: pluginConfig.workflows?.directories
+        });
+        if (workflowResult?.continuationPrompt) {
+          info("plugin", "Workflow continuation detected");
+          prompts.push(workflowResult.continuationPrompt);
+        }
+        if (prompts.length > 0) {
+          pendingContinuations.set(sessionID, prompts);
+        }
+      }
+    },
+    "tool.execute.before": async (input, output) => {
+      const { tool, sessionID } = input;
+      const args2 = output.args;
+      debug("plugin", `tool.execute.before: ${tool}`);
+      const activeAgent = sessionAgentMap.get(sessionID);
+      const architectResult = hooks.checkArchitectWrite({ toolName: tool, args: args2, agentName: activeAgent });
+      if (architectResult.verdict === "deny") {
+        info("plugin", `Architect md-only guard blocked: ${architectResult.reason}`);
+        if ("filePath" in args2)
+          args2["filePath"] = "";
+        if ("path" in args2)
+          args2["path"] = "";
+        if ("content" in args2)
+          args2["content"] = `<!-- BLOCKED: ${architectResult.reason} -->`;
+        return;
+      }
+      captureToDoWrite({ toolName: tool, args: args2, sessionId: sessionID });
+    },
+    "tool.execute.after": async (input, _output) => {
+      const { tool, sessionID } = input;
+      debug("plugin", `tool.execute.after: ${tool}`);
+      const reminder = hooks.buildVerificationReminder({
+        toolName: tool,
+        directory
+      });
+      if (reminder.reminderText) {
+        debug("plugin", "Verification reminder triggered");
+      }
+    },
+    "command.execute.before": async (input, output) => {
+      const { command, sessionID, arguments: cmdArgs } = input;
+      debug("plugin", `command: /${command} ${cmdArgs}`);
+      if (command === "implement") {
+        const result = await hooks.handleStartImplementation({
+          args: cmdArgs,
+          sessionId: sessionID,
+          directory
+        });
+        if (result.prompt) {
+          output.parts = [textPart(result.prompt)];
+        } else if (result.error) {
+          output.parts = [textPart(`❌ ${result.error}`)];
+        }
+        return;
+      }
+      if (command === "run-workflow") {
+        const result = await handleRunWorkflow({
+          promptText: cmdArgs,
+          sessionId: sessionID,
+          directory,
+          customDirs: pluginConfig.workflows?.directories
+        });
+        if (result.message) {
+          output.parts = [textPart(result.message)];
+        }
+        return;
+      }
+      const workflowResult = handleWorkflowCommand(cmdArgs, directory);
+      if (workflowResult) {
+        output.parts = [textPart(workflowResult)];
+      }
+    },
+    "tool.definition": async (input, output) => {
+      const { toolID } = input;
+      const overriddenDesc = hooks.applyTodoDescriptionOverride(toolID, output.description);
+      if (overriddenDesc !== output.description) {
+        output.description = overriddenDesc;
+      }
+    },
+    "experimental.session.compacting": async (input, output) => {
+      const { sessionID } = input;
+      const recovery = checkCompactionRecovery({ sessionId: sessionID, directory });
+      if (recovery.recoveryPrompt) {
+        output.context.push(recovery.recoveryPrompt);
+      }
+      const todoPreservation = buildTodoPreservationPrompt(sessionID);
+      if (todoPreservation) {
+        output.context.push(todoPreservation);
+      }
+    }
+  };
+}
+
+// src/plugin/plugin-interface.ts
+function createPluginInterface(args) {
+  return createPluginAdapter(args);
+}
+
+// src/index.ts
+var LeadPlugin = async (ctx) => {
+  setClient(ctx.client);
+  const pluginConfig = loadLeadConfig(ctx.directory);
+  ctx.client.tui.showToast({
+    body: {
+      title: "L.E.A.D.",
+      message: "Lucas Engineering Automation & Delivery — ready",
+      variant: "success",
+      duration: 4000
+    }
+  }).catch(() => {});
+  const continuation = resolveContinuationConfig(pluginConfig.continuation);
+  const { resolveSkills } = await createTools({ ctx, pluginConfig });
+  const { configHandler } = await createManagers({
+    ctx,
+    pluginConfig,
+    continuation,
+    resolveSkills
+  });
+  const hooks = createHooks({
+    pluginConfig,
+    continuation,
+    directory: ctx.directory
+  });
+  return createPluginInterface({
+    pluginConfig,
+    directory: ctx.directory,
+    configHandler,
+    hooks
+  });
+};
+var src_default = {
+  id: "lead",
+  server: LeadPlugin
+};
+export {
+  src_default as default,
+  LeadPlugin
+};