@brainervirus/workit-claude-code 8.26.1 → 8.28.0

package/dist/workit.js

@@ -9240,7 +9240,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@brainervirus/workit-cli",
-    version: "8.26.1",
+    version: "8.28.0",
     private: false,
     description: "Workit CLI — setup wizard, doctor, and task control for agentic coding workflows",
     keywords: [
@@ -9278,13 +9278,13 @@ var init_package = __esm(() => {
     },
     dependencies: {
       "@babel/parser": "7.29.9",
-      "@brainervirus/workit-cursor": "^8.26.1",
+      "@brainervirus/workit-cursor": "^8.28.0",
       "@inkjs/ui": "2.0.0",
       ink: "7.1.1",
       react: "19.2.8"
     },
     devDependencies: {
-      "@brainervirus/workit-core": "^8.26.1"
+      "@brainervirus/workit-core": "^8.28.0"
     },
     engines: {
       node: ">=24"
@@ -58217,7 +58217,7 @@ var init_cli_boxes = __esm(() => {
   cli_boxes_default = boxes_default;
 });
 
-// node_modules/chalk/source/vendor/ansi-styles/index.js
+// node_modules/ink/node_modules/chalk/source/vendor/ansi-styles/index.js
 function assembleStyles2() {
   const codes = new Map;
   for (const [groupName, group] of Object.entries(styles3)) {
@@ -58393,7 +58393,7 @@ var init_ansi_styles2 = __esm(() => {
   ansi_styles_default2 = ansiStyles2;
 });
 
-// node_modules/chalk/source/vendor/supports-color/index.js
+// node_modules/ink/node_modules/chalk/source/vendor/supports-color/index.js
 import process5 from "node:process";
 import os7 from "node:os";
 import tty2 from "node:tty";
@@ -58527,7 +58527,7 @@ var init_supports_color = __esm(() => {
   supports_color_default = supportsColor;
 });
 
-// node_modules/chalk/source/utilities.js
+// node_modules/ink/node_modules/chalk/source/utilities.js
 function stringReplaceAll(string, substring, replacer) {
   let index = string.indexOf(substring);
   if (index === -1) {
@@ -58560,7 +58560,7 @@ function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
   return returnValue;
 }
 
-// node_modules/chalk/source/index.js
+// node_modules/ink/node_modules/chalk/source/index.js
 function createChalk(options) {
   return chalkFactory(options);
 }
@@ -63983,13 +63983,502 @@ var init_use_text_input_state = __esm(() => {
   import_react50 = __toESM(require_react(), 1);
 });
 
+// node_modules/@inkjs/ui/node_modules/chalk/source/vendor/ansi-styles/index.js
+function assembleStyles3() {
+  const codes = new Map;
+  for (const [groupName, group] of Object.entries(styles5)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles5[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles5[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles5, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles5, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles5.color.close = "\x1B[39m";
+  styles5.bgColor.close = "\x1B[49m";
+  styles5.color.ansi = wrapAnsi163();
+  styles5.color.ansi256 = wrapAnsi2563();
+  styles5.color.ansi16m = wrapAnsi16m3();
+  styles5.bgColor.ansi = wrapAnsi163(ANSI_BACKGROUND_OFFSET3);
+  styles5.bgColor.ansi256 = wrapAnsi2563(ANSI_BACKGROUND_OFFSET3);
+  styles5.bgColor.ansi16m = wrapAnsi16m3(ANSI_BACKGROUND_OFFSET3);
+  Object.defineProperties(styles5, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles5.rgbToAnsi256(...styles5.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles5.ansi256ToAnsi(styles5.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles5.ansi256ToAnsi(styles5.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles5;
+}
+var ANSI_BACKGROUND_OFFSET3 = 10, wrapAnsi163 = (offset = 0) => (code) => `\x1B[${code + offset}m`, wrapAnsi2563 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`, wrapAnsi16m3 = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`, styles5, modifierNames3, foregroundColorNames3, backgroundColorNames3, colorNames3, ansiStyles3, ansi_styles_default3;
+var init_ansi_styles3 = __esm(() => {
+  styles5 = {
+    modifier: {
+      reset: [0, 0],
+      bold: [1, 22],
+      dim: [2, 22],
+      italic: [3, 23],
+      underline: [4, 24],
+      overline: [53, 55],
+      inverse: [7, 27],
+      hidden: [8, 28],
+      strikethrough: [9, 29]
+    },
+    color: {
+      black: [30, 39],
+      red: [31, 39],
+      green: [32, 39],
+      yellow: [33, 39],
+      blue: [34, 39],
+      magenta: [35, 39],
+      cyan: [36, 39],
+      white: [37, 39],
+      blackBright: [90, 39],
+      gray: [90, 39],
+      grey: [90, 39],
+      redBright: [91, 39],
+      greenBright: [92, 39],
+      yellowBright: [93, 39],
+      blueBright: [94, 39],
+      magentaBright: [95, 39],
+      cyanBright: [96, 39],
+      whiteBright: [97, 39]
+    },
+    bgColor: {
+      bgBlack: [40, 49],
+      bgRed: [41, 49],
+      bgGreen: [42, 49],
+      bgYellow: [43, 49],
+      bgBlue: [44, 49],
+      bgMagenta: [45, 49],
+      bgCyan: [46, 49],
+      bgWhite: [47, 49],
+      bgBlackBright: [100, 49],
+      bgGray: [100, 49],
+      bgGrey: [100, 49],
+      bgRedBright: [101, 49],
+      bgGreenBright: [102, 49],
+      bgYellowBright: [103, 49],
+      bgBlueBright: [104, 49],
+      bgMagentaBright: [105, 49],
+      bgCyanBright: [106, 49],
+      bgWhiteBright: [107, 49]
+    }
+  };
+  modifierNames3 = Object.keys(styles5.modifier);
+  foregroundColorNames3 = Object.keys(styles5.color);
+  backgroundColorNames3 = Object.keys(styles5.bgColor);
+  colorNames3 = [...foregroundColorNames3, ...backgroundColorNames3];
+  ansiStyles3 = assembleStyles3();
+  ansi_styles_default3 = ansiStyles3;
+});
+
+// node_modules/@inkjs/ui/node_modules/chalk/source/vendor/supports-color/index.js
+import process15 from "node:process";
+import os8 from "node:os";
+import tty3 from "node:tty";
+function hasFlag2(flag, argv = globalThis.Deno ? globalThis.Deno.args : process15.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+function envForceColor2() {
+  if ("FORCE_COLOR" in env3) {
+    if (env3.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env3.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env3.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env3.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel2(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor2(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor2();
+  if (noFlagForceColor !== undefined) {
+    flagForceColor2 = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor2 : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag2("color=16m") || hasFlag2("color=full") || hasFlag2("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag2("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env3 && "AGENT_NAME" in env3) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === undefined) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env3.TERM === "dumb") {
+    return min;
+  }
+  if (process15.platform === "win32") {
+    const osRelease = os8.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env3) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => (key in env3))) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => (sign in env3)) || env3.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env3) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env3.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env3.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env3.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env3.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env3.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env3) {
+    const version = Number.parseInt((env3.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env3.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env3.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env3.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env3) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor2(stream, options = {}) {
+  const level = _supportsColor2(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel2(level);
+}
+var env3, flagForceColor2, supportsColor2, supports_color_default2;
+var init_supports_color2 = __esm(() => {
+  ({ env: env3 } = process15);
+  if (hasFlag2("no-color") || hasFlag2("no-colors") || hasFlag2("color=false") || hasFlag2("color=never")) {
+    flagForceColor2 = 0;
+  } else if (hasFlag2("color") || hasFlag2("colors") || hasFlag2("color=true") || hasFlag2("color=always")) {
+    flagForceColor2 = 1;
+  }
+  supportsColor2 = {
+    stdout: createSupportsColor2({ isTTY: tty3.isatty(1) }),
+    stderr: createSupportsColor2({ isTTY: tty3.isatty(2) })
+  };
+  supports_color_default2 = supportsColor2;
+});
+
+// node_modules/@inkjs/ui/node_modules/chalk/source/utilities.js
+function stringReplaceAll2(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex2(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? `\r
+` : `
+`) + postfix;
+    endIndex = index + 1;
+    index = string.indexOf(`
+`, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+
+// node_modules/@inkjs/ui/node_modules/chalk/source/index.js
+function createChalk2(options) {
+  return chalkFactory2(options);
+}
+var stdoutColor2, stderrColor2, GENERATOR2, STYLER2, IS_EMPTY2, levelMapping2, styles6, applyOptions2 = (object, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
+  }
+  const colorLevel = stdoutColor2 ? stdoutColor2.level : 0;
+  object.level = options.level === undefined ? colorLevel : options.level;
+}, chalkFactory2 = (options) => {
+  const chalk = (...strings) => strings.join(" ");
+  applyOptions2(chalk, options);
+  Object.setPrototypeOf(chalk, createChalk2.prototype);
+  return chalk;
+}, getModelAnsi2 = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default3[type].ansi16m(...arguments_);
+    }
+    if (level === "ansi256") {
+      return ansi_styles_default3[type].ansi256(ansi_styles_default3.rgbToAnsi256(...arguments_));
+    }
+    return ansi_styles_default3[type].ansi(ansi_styles_default3.rgbToAnsi(...arguments_));
+  }
+  if (model === "hex") {
+    return getModelAnsi2("rgb", level, type, ...ansi_styles_default3.hexToRgb(...arguments_));
+  }
+  return ansi_styles_default3[type][model](...arguments_);
+}, usedModels2, proto2, createStyler2 = (open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === undefined) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+}, createBuilder2 = (self2, _styler, _isEmpty) => {
+  const builder = (...arguments_) => applyStyle2(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto2);
+  builder[GENERATOR2] = self2;
+  builder[STYLER2] = _styler;
+  builder[IS_EMPTY2] = _isEmpty;
+  return builder;
+}, applyStyle2 = (self2, string) => {
+  if (self2.level <= 0 || !string) {
+    return self2[IS_EMPTY2] ? "" : string;
+  }
+  let styler = self2[STYLER2];
+  if (styler === undefined) {
+    return string;
+  }
+  const { openAll, closeAll } = styler;
+  if (string.includes("\x1B")) {
+    while (styler !== undefined) {
+      string = stringReplaceAll2(string, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+  const lfIndex = string.indexOf(`
+`);
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex2(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+}, chalk2, chalkStderr2, source_default2;
+var init_source2 = __esm(() => {
+  init_ansi_styles3();
+  init_supports_color2();
+  ({ stdout: stdoutColor2, stderr: stderrColor2 } = supports_color_default2);
+  GENERATOR2 = Symbol("GENERATOR");
+  STYLER2 = Symbol("STYLER");
+  IS_EMPTY2 = Symbol("IS_EMPTY");
+  levelMapping2 = [
+    "ansi",
+    "ansi",
+    "ansi256",
+    "ansi16m"
+  ];
+  styles6 = Object.create(null);
+  Object.setPrototypeOf(createChalk2.prototype, Function.prototype);
+  for (const [styleName, style] of Object.entries(ansi_styles_default3)) {
+    styles6[styleName] = {
+      get() {
+        const builder = createBuilder2(this, createStyler2(style.open, style.close, this[STYLER2]), this[IS_EMPTY2]);
+        Object.defineProperty(this, styleName, { value: builder });
+        return builder;
+      }
+    };
+  }
+  styles6.visible = {
+    get() {
+      const builder = createBuilder2(this, this[STYLER2], true);
+      Object.defineProperty(this, "visible", { value: builder });
+      return builder;
+    }
+  };
+  usedModels2 = ["rgb", "hex", "ansi256"];
+  for (const model of usedModels2) {
+    styles6[model] = {
+      get() {
+        const { level } = this;
+        return function(...arguments_) {
+          const styler = createStyler2(getModelAnsi2(model, levelMapping2[level], "color", ...arguments_), ansi_styles_default3.color.close, this[STYLER2]);
+          return createBuilder2(this, styler, this[IS_EMPTY2]);
+        };
+      }
+    };
+    const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+    styles6[bgModel] = {
+      get() {
+        const { level } = this;
+        return function(...arguments_) {
+          const styler = createStyler2(getModelAnsi2(model, levelMapping2[level], "bgColor", ...arguments_), ansi_styles_default3.bgColor.close, this[STYLER2]);
+          return createBuilder2(this, styler, this[IS_EMPTY2]);
+        };
+      }
+    };
+  }
+  proto2 = Object.defineProperties(() => {}, {
+    ...styles6,
+    level: {
+      enumerable: true,
+      get() {
+        return this[GENERATOR2].level;
+      },
+      set(level) {
+        this[GENERATOR2].level = level;
+      }
+    }
+  });
+  Object.defineProperties(createChalk2.prototype, styles6);
+  chalk2 = createChalk2();
+  chalkStderr2 = createChalk2({ level: stderrColor2 ? stderrColor2.level : 0 });
+  source_default2 = chalk2;
+});
+
 // node_modules/@inkjs/ui/build/components/text-input/use-text-input.js
 var import_react51, cursor, useTextInput = ({ isDisabled = false, state, placeholder = "" }) => {
   const renderedPlaceholder = import_react51.useMemo(() => {
     if (isDisabled) {
-      return placeholder ? source_default.dim(placeholder) : "";
+      return placeholder ? source_default2.dim(placeholder) : "";
     }
-    return placeholder && placeholder.length > 0 ? source_default.inverse(placeholder[0]) + source_default.dim(placeholder.slice(1)) : cursor;
+    return placeholder && placeholder.length > 0 ? source_default2.inverse(placeholder[0]) + source_default2.dim(placeholder.slice(1)) : cursor;
   }, [isDisabled, placeholder]);
   const renderedValue = import_react51.useMemo(() => {
     if (isDisabled) {
@@ -63998,14 +64487,14 @@ var import_react51, cursor, useTextInput = ({ isDisabled = false, state, placeho
     let index = 0;
     let result = state.value.length > 0 ? "" : cursor;
     for (const char of state.value) {
-      result += index === state.cursorOffset ? source_default.inverse(char) : char;
+      result += index === state.cursorOffset ? source_default2.inverse(char) : char;
       index++;
     }
     if (state.suggestion) {
       if (state.cursorOffset === state.value.length) {
-        result += source_default.inverse(state.suggestion[0]) + source_default.dim(state.suggestion.slice(1));
+        result += source_default2.inverse(state.suggestion[0]) + source_default2.dim(state.suggestion.slice(1));
       } else {
-        result += source_default.dim(state.suggestion);
+        result += source_default2.dim(state.suggestion);
       }
       return result;
     }
@@ -64037,10 +64526,10 @@ var import_react51, cursor, useTextInput = ({ isDisabled = false, state, placeho
   };
 };
 var init_use_text_input = __esm(async () => {
-  init_source();
+  init_source2();
   await init_build2();
   import_react51 = __toESM(require_react(), 1);
-  cursor = source_default.inverse(" ");
+  cursor = source_default2.inverse(" ");
 });
 
 // node_modules/@inkjs/ui/build/components/text-input/text-input.js
@@ -64156,10 +64645,10 @@ var init_use_password_input_state = __esm(() => {
 // node_modules/@inkjs/ui/build/components/password-input/use-password-input.js
 var import_react58, cursor2;
 var init_use_password_input = __esm(async () => {
-  init_source();
+  init_source2();
   await init_build2();
   import_react58 = __toESM(require_react(), 1);
-  cursor2 = source_default.inverse(" ");
+  cursor2 = source_default2.inverse(" ");
 });
 
 // node_modules/@inkjs/ui/build/components/password-input/password-input.js
@@ -64214,10 +64703,10 @@ var init_use_email_input_state = __esm(() => {
 // node_modules/@inkjs/ui/build/components/email-input/use-email-input.js
 var import_react63, cursor3;
 var init_use_email_input = __esm(async () => {
-  init_source();
+  init_source2();
   await init_build2();
   import_react63 = __toESM(require_react(), 1);
-  cursor3 = source_default.inverse(" ");
+  cursor3 = source_default2.inverse(" ");
 });
 
 // node_modules/@inkjs/ui/build/components/email-input/email-input.js
@@ -65062,6 +65551,21 @@ var MODEL_ROLES, MODEL_TIERS, HOST_KEYS, BUILT_IN_CLAUDE_CODE, isObject9 = (valu
     }
   }
   return issues;
+}, roleForAgentType = (agentType, prompt) => {
+  switch (agentType) {
+    case "workit:implementer": {
+      const tier = typeof prompt === "string" ? /^[ \t]*TIER:[ \t]*(mundane|standard|hard)\b/im.exec(prompt)?.[1] : undefined;
+      return { role: "implementer", tier: tier?.toLowerCase() ?? "standard" };
+    }
+    case "workit:verifier":
+      return { role: "verifier" };
+    case "workit:reviewer":
+      return { role: "reviewer" };
+    case "Explore":
+      return { role: "explore" };
+    default:
+      return null;
+  }
 };
 var init_role_models = __esm(() => {
   init_workspaces();
@@ -65108,7 +65612,7 @@ import {
   realpathSync as realpathSync6,
   statSync as statSync2
 } from "node:fs";
-import os8 from "node:os";
+import os9 from "node:os";
 import path33 from "node:path";
 function hostCommand(name, args, options = {}) {
   const executable = findHostExecutable(name, options);
@@ -65138,7 +65642,7 @@ function resolveWindowsShimEntry(contents, shim, exists = existsSync12) {
 }
 function findHostExecutable(name, options = {}) {
   const env = options.env ?? process.env;
-  const home = options.home ?? env.HOME ?? os8.homedir();
+  const home = options.home ?? env.HOME ?? os9.homedir();
   const suffixes = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
   const dirs = (env.PATH ?? "").split(path33.delimiter).filter(Boolean);
   dirs.push(path33.join(home, ".local", "bin"), path33.join(home, ".asdf", "shims"));
@@ -65188,7 +65692,7 @@ function installedHostApp(host, home, env = process.env, platform = process.plat
 }
 function planHostInstall(host, options = {}) {
   const env = options.env ?? process.env;
-  const home = options.home ?? env.HOME ?? os8.homedir();
+  const home = options.home ?? env.HOME ?? os9.homedir();
   const cwd = options.cwd ?? process.cwd();
   const version = options.packageVersion ?? "latest";
   if (!validPackageVersion(version))
@@ -65372,7 +65876,7 @@ function runHostCommand(step, context = {}) {
   const result = spawnSync14(step.command, step.args, {
     cwd: step.cwd,
     env: (() => {
-      const home = context.home ?? context.env?.HOME ?? os8.homedir();
+      const home = context.home ?? context.env?.HOME ?? os9.homedir();
       const env = { ...process.env, ...context.env, HOME: home };
       env.CODEX_HOME = context.env?.CODEX_HOME ?? path33.join(home, ".codex");
       env.PI_CODING_AGENT_DIR = context.env?.PI_CODING_AGENT_DIR ?? path33.join(home, ".pi", "agent");
@@ -65964,14 +66468,14 @@ ${manualTrailerLine()}
 });
 
 // packages/workit-core/src/core/heavy-words.ts
-import os9 from "node:os";
+import os10 from "node:os";
 import path36 from "node:path";
 var HEAVY_WORDS, stateDir = (env) => {
   if (env.WORKFLOW_TOOLKIT_STATE)
     return env.WORKFLOW_TOOLKIT_STATE;
   if (env.XDG_STATE_HOME)
     return path36.join(env.XDG_STATE_HOME, "workit");
-  const home = env.HOME || os9.homedir();
+  const home = env.HOME || os10.homedir();
   if (process.platform === "darwin")
     return path36.join(home, "Library", "Application Support", "workit");
   if (process.platform === "win32")
@@ -66017,7 +66521,7 @@ import {
   rmSync as rmSync3,
   statSync as statSync5
 } from "node:fs";
-import os10 from "node:os";
+import os11 from "node:os";
 import path37 from "node:path";
 function mergeClaudeSettings(settings, shell, skip = {}) {
   const config = clone4(settings);
@@ -66376,7 +66880,7 @@ ${[...rules, grant].join(`
   };
 }, resolvePaths = (options) => {
   const env = options.env ?? process.env;
-  const home = options.home ?? env.HOME ?? os10.homedir();
+  const home = options.home ?? env.HOME ?? os11.homedir();
   return { home, env, stateDir: options.stateDir ?? stateDir({ ...env, HOME: home }) };
 }, permissionTarget = (host, options = {}) => {
   const { home, env } = resolvePaths(options);
@@ -66524,7 +67028,7 @@ import {
   unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync7
 } from "node:fs";
-import os11 from "node:os";
+import os12 from "node:os";
 import path38 from "node:path";
 var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   let dir = path38.resolve(cwd);
@@ -66536,9 +67040,24 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
       return null;
     dir = parent;
   }
+}, listClaudeProcesses = () => {
+  const r = spawnSync16("ps", ["-eo", "pid=,lstart=,args="], { encoding: "utf8", timeout: 5000 });
+  if (r.status !== 0 || typeof r.stdout !== "string")
+    return null;
+  const found = [];
+  for (const row of r.stdout.split(`
+`)) {
+    const m = /^\s*(\d+)\s+(\w{3}\s+\w{3}\s+\d+\s+[\d:]+\s+\d{4})\s+(.*)$/.exec(row);
+    if (!m || !/^(\S*\/)?claude(\s|$)/.test(m[3]))
+      continue;
+    const startedMs = Date.parse(m[2]);
+    if (Number.isFinite(startedMs))
+      found.push({ pid: Number(m[1]), startedMs, args: m[3] });
+  }
+  return found;
 }, resolve = (options) => {
   const env = options.env ?? process.env;
-  const home = options.home ?? env.HOME ?? os11.homedir();
+  const home = options.home ?? env.HOME ?? os12.homedir();
   const configDir = options.configDir ?? env.WORKFLOW_TOOLKIT_CONFIG ?? env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path38.join(home, ".config", "workit");
   const stateDir = options.stateDir ?? env.WORKFLOW_TOOLKIT_STATE ?? path38.join(home, ".local", "state", "workit");
   const cwd = options.cwd ?? process.cwd();
@@ -66563,7 +67082,8 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     env,
     installer: options.installer ?? false,
     cliVersion: options.cliVersion ?? null,
-    scopeProbe: options.scopeProbe ?? probeScope
+    scopeProbe: options.scopeProbe ?? probeScope,
+    claudeProcesses: options.claudeProcesses ?? listClaudeProcesses
   };
 }, readJson = (p) => {
   try {
@@ -66618,7 +67138,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   if (env.BUN && existsSync16(env.BUN))
     return env.BUN;
   for (const candidate of [
-    path38.join(env.HOME || os11.homedir(), ".bun/bin/bun"),
+    path38.join(env.HOME || os12.homedir(), ".bun/bin/bun"),
     "/usr/local/bin/bun",
     "/usr/bin/bun"
   ]) {
@@ -66726,7 +67246,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
       status: "pass",
       detail: "opencode CLI not on PATH — skipping version check"
     };
-  const scratch = mkdtempSync(path38.join(os11.tmpdir(), "workit-doctor-opencode-"));
+  const scratch = mkdtempSync(path38.join(os12.tmpdir(), "workit-doctor-opencode-"));
   let raw;
   try {
     raw = versionOf("opencode", {
@@ -68403,6 +68923,68 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     fix: repair,
     registryProbed
   };
+}, checkClaudeSessionPlugin = (res) => {
+  const id = "claude_session_plugin";
+  if (process.platform === "win32")
+    return {
+      id,
+      status: "info",
+      detail: "running Claude Code sessions are not checked on Windows"
+    };
+  const installs = claudeWorkitInstalls(res.home, res.env, res.cwd).filter((install) => install.version);
+  if (installs.length === 0)
+    return {
+      id,
+      status: "info",
+      detail: "no Workit Claude Code plugin install recorded — skipping"
+    };
+  const registry = readJson(path38.join(claudeConfigDir(res.home, res.env), "plugins", "installed_plugins.json"));
+  const recorded = (install) => {
+    const entries = registry?.plugins?.[install.id];
+    const entry = Array.isArray(entries) ? entries.find((e) => e?.installPath === install.installPath) : null;
+    for (const stamp of [entry?.lastUpdated, entry?.installedAt]) {
+      const ms = typeof stamp === "string" ? Date.parse(stamp) : NaN;
+      if (Number.isFinite(ms))
+        return ms;
+    }
+    try {
+      return statSync6(install.installPath).mtimeMs;
+    } catch {
+      return null;
+    }
+  };
+  const latest = installs.map((install) => ({ install, at: recorded(install) })).filter((one) => one.at !== null).toSorted((a, b) => b.at - a.at)[0];
+  if (!latest)
+    return {
+      id,
+      status: "info",
+      detail: "no install time recorded for the Workit plugin — skipping"
+    };
+  const running = res.claudeProcesses();
+  if (running === null)
+    return {
+      id,
+      status: "info",
+      detail: "could not list running claude processes (ps) — skipping"
+    };
+  const stale = running.filter((proc) => proc.startedMs < latest.at);
+  if (stale.length === 0)
+    return {
+      id,
+      status: "info",
+      detail: `${running.length} running claude process(es), none started before Workit ${latest.install.version} was installed`
+    };
+  const sessionOf = (args) => /(?:--resume|--session-id|-r)[ =]([0-9a-f]{8}-[0-9a-f-]{27})/i.exec(args)?.[1] ?? null;
+  const rows = stale.map((proc) => {
+    const session = sessionOf(proc.args);
+    return `pid ${proc.pid} started ${new Date(proc.startedMs).toISOString()}${session ? ` (session ${session})` : ""}`;
+  });
+  const first = stale.map((proc) => sessionOf(proc.args)).find((one) => one);
+  return {
+    id,
+    status: "warn",
+    detail: `started before Workit ${latest.install.version} was installed: ${rows.join("; ")}; quit and start \`claude --resume ${first ?? "<session id>"}\` to load it (\`/resume\` keeps the old plugin)`
+  };
 }, HOOK_ISSUED_MARKER = "workit-issued-sessions/3", hookRecordsIssued = (root) => {
   let files;
   try {
@@ -68604,6 +69186,7 @@ var init_doctor = __esm(() => {
     checkPiExtension,
     checkOpencodeVersion,
     checkClaudePlugin,
+    checkClaudeSessionPlugin,
     checkHookIssuedSessions,
     checkWorkitOnPath,
     checkAssets,
@@ -68658,7 +69241,7 @@ import {
   writeFileSync as writeFileSync8
 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import os12 from "node:os";
+import os13 from "node:os";
 import path39 from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
 function parseList(raw) {
@@ -69483,7 +70066,7 @@ var TOKEN_PLACEHOLDER3 = "YOUR_TOKEN_HERE", YT_OVERRIDES, VCS_OVERRIDES, SETUP_O
   }
 }, claudeInstallRecord = (home, env) => path39.join(claudeConfigDir(home, env), "plugins", "installed_plugins.json"), resolveSetupPaths = (options, resolvedConfigDir) => {
   const env = options.env ?? process.env;
-  const home = options.home ?? env.HOME ?? os12.homedir();
+  const home = options.home ?? env.HOME ?? os13.homedir();
   return {
     home,
     configDir: resolvedConfigDir,
@@ -70601,7 +71184,7 @@ var init_wizard_state = __esm(() => {
 
 // packages/workit-cli/src/admin/uninstall.ts
 import { existsSync as existsSync19, readFileSync as readFileSync19, realpathSync as realpathSync9, rmSync as rmSync7, writeFileSync as writeFileSync10 } from "node:fs";
-import os13 from "node:os";
+import os14 from "node:os";
 import path42 from "node:path";
 function cleanCursorSettings(settings, pluginDir) {
   const next = { ...settings };
@@ -70749,7 +71332,7 @@ function planUninstall(paths = {}) {
       }
     ] : []
   };
-  const home = paths.home ?? paths.env?.HOME ?? os13.homedir();
+  const home = paths.home ?? paths.env?.HOME ?? os14.homedir();
   const claudeInstalls = claudeWorkitInstalls(home, paths.env ?? process.env, paths.cwd ?? process.cwd());
   const claude = {
     host: "claude-code",
@@ -70846,7 +71429,7 @@ function applyUninstall(plan, paths = {}) {
   return { ok: entries.every((e) => e.status !== "failed"), entries };
 }
 var resolveUninstallPaths = (options = {}) => {
-  const home = options.home ?? options.env?.HOME ?? os13.homedir();
+  const home = options.home ?? options.env?.HOME ?? os14.homedir();
   const permissionPaths = { home, env: options.env ?? process.env };
   return {
     claudeSettings: permissionTarget("claude-code", permissionPaths).file,
@@ -70880,7 +71463,7 @@ var resolveUninstallPaths = (options = {}) => {
 }, CURSOR_LEGACY_IDENTITIES, permissionPathsOf = (paths) => {
   const env = paths.env ?? process.env;
   return {
-    home: paths.home ?? env.HOME ?? os13.homedir(),
+    home: paths.home ?? env.HOME ?? os14.homedir(),
     env,
     ...paths.stateDir ? { stateDir: paths.stateDir } : {}
   };
@@ -70954,7 +71537,7 @@ var resolveUninstallPaths = (options = {}) => {
       status: "failed",
       detail: `refusing unreviewed host command: ${action.args.join(" ")}`
     };
-  const home = paths.home ?? paths.env?.HOME ?? os13.homedir();
+  const home = paths.home ?? paths.env?.HOME ?? os14.homedir();
   const env = paths.env ?? process.env;
   const recorded = claudeWorkitInstalls(home, env, action.cwd).some((install) => install.id === id && install.scope === scope && (install.projectPath === null ? action.cwd === null : path42.resolve(install.projectPath) === path42.resolve(action.cwd ?? "")));
   if (!recorded)
@@ -70980,7 +71563,7 @@ var init_uninstall = __esm(() => {
 });
 
 // packages/workit-cli/src/admin/detect-hosts.ts
-import os14 from "node:os";
+import os15 from "node:os";
 function preselectedPlatforms(detection) {
   return WIZARD_HOSTS.filter((host) => detection[host].detected);
 }
@@ -70995,7 +71578,7 @@ function emptyDetection() {
 }
 function detectHosts(options = {}) {
   const env = options.env ?? process.env;
-  const home = options.home ?? env.HOME ?? os14.homedir();
+  const home = options.home ?? env.HOME ?? os15.homedir();
   const plan = planUninstall({ ...options, home, env });
   const configuredByHost = new Map(plan.hosts.map((h) => [h.host, h.installed]));
   const found = emptyDetection();
@@ -73726,7 +74309,7 @@ import {
   lstatSync as lstatSync7
 } from "node:fs";
 import path43 from "node:path";
-import os15 from "node:os";
+import os16 from "node:os";
 import { createHash as createHash15 } from "node:crypto";
 function previewUpgrade(hosts = HOSTS2, deps = {}) {
   const paths = upgradePaths(deps);
@@ -73766,7 +74349,7 @@ function previewUpgrade(hosts = HOSTS2, deps = {}) {
       });
     const installedSources = sources(paths, run, hosts);
     if (installedSources.some((source) => source.host === "opencode")) {
-      const scratch = mkdtempSync3(path43.join(os15.tmpdir(), "workit-upgrade-opencode-"));
+      const scratch = mkdtempSync3(path43.join(os16.tmpdir(), "workit-upgrade-opencode-"));
       let probe;
       try {
         probe = runner({
@@ -74107,7 +74690,7 @@ async function runLaunchCommand(argv, deps = {}) {
   }).status ?? 1;
 }
 var HOSTS2, upgradePaths = (deps) => {
-  const home = deps.home ?? deps.env?.HOME ?? os15.homedir();
+  const home = deps.home ?? deps.env?.HOME ?? os16.homedir();
   const env = {
     ...process.env,
     ...deps.home || deps.env?.HOME ? {
@@ -74787,7 +75370,7 @@ var init_redact = __esm(() => {
 import { spawn, spawnSync as spawnSync19 } from "node:child_process";
 import { createHash as createHash16 } from "node:crypto";
 import fs21 from "node:fs";
-import os16 from "node:os";
+import os17 from "node:os";
 import path45 from "node:path";
 import { StringDecoder } from "node:string_decoder";
 function tailLines(text, lines = TAIL_LINES) {
@@ -74993,7 +75576,7 @@ function runCheckCommand(argv, options) {
 `);
       redactor.end();
       resolve({
-        exitCode: spawnError ? 127 : code !== null ? code : 128 + (signal ? os16.constants.signals[signal] ?? 1 : 1),
+        exitCode: spawnError ? 127 : code !== null ? code : 128 + (signal ? os17.constants.signals[signal] ?? 1 : 1),
         signal: signal ?? null,
         timedOut,
         durationMs: Date.now() - started,
@@ -75425,14 +76008,14 @@ var init_heavy_rules = () => {};
 
 // packages/workit-core/src/core/heavy.ts
 import fs23 from "node:fs";
-import os17 from "node:os";
+import os18 from "node:os";
 import path47 from "node:path";
 function stateDir2(env, platform = process.platform) {
   if (env.WORKFLOW_TOOLKIT_STATE)
     return env.WORKFLOW_TOOLKIT_STATE;
   if (env.XDG_STATE_HOME)
     return path47.join(env.XDG_STATE_HOME, "workit");
-  const home = env.HOME || os17.homedir();
+  const home = env.HOME || os18.homedir();
   if (platform === "darwin")
     return path47.join(home, "Library", "Application Support", "workit");
   if (platform === "win32")
@@ -75802,7 +76385,7 @@ var init_heavy = __esm(() => {
 // packages/workit-core/src/core/resources.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
 import fs24 from "node:fs";
-import os18 from "node:os";
+import os19 from "node:os";
 import path48 from "node:path";
 function memoryValue(value, host) {
   const text = typeof value === "number" ? String(value) : typeof value === "string" ? value : "";
@@ -76197,15 +76780,15 @@ function leaseSlots(dir, slots, probe = {}) {
   return states;
 }
 var DEFAULT_HEAVY_CHECKS, DEFAULT_SLOTS = 1, DEFAULT_WAIT_S = 600, DEFAULT_MEMORY_SHARE = 0.4, DEFAULT_CPU_SHARE = 0.7, MAX_SLOTS = 64, UNREADABLE_TTL_MS = 30000, GUARD_TTL_MS = 30000, hostShape = () => ({
-  totalMemBytes: os18.totalmem(),
-  cpus: Math.max(1, os18.availableParallelism?.() ?? os18.cpus().length)
+  totalMemBytes: os19.totalmem(),
+  cpus: Math.max(1, os19.availableParallelism?.() ?? os19.cpus().length)
 }), isRecord9 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), SIZE, PERCENT, UNITS, leaseDir = (env) => path48.join(stateDir2(env), "leases"), readText5 = (file) => {
   try {
     return fs24.readFileSync(file, "utf8");
   } catch {
     return null;
   }
-}, bootId = () => readText5("/proc/sys/kernel/random/boot_id")?.trim() || null, bootTime = () => Math.round((Date.now() - os18.uptime() * 1000) / 1000) * 1000, BOOT_SLACK_MS = 120000, statFields = (pid) => {
+}, bootId = () => readText5("/proc/sys/kernel/random/boot_id")?.trim() || null, bootTime = () => Math.round((Date.now() - os19.uptime() * 1000) / 1000) * 1000, BOOT_SLACK_MS = 120000, statFields = (pid) => {
   const stat = readText5(`/proc/${pid}/stat`);
   return stat ? stat.slice(stat.lastIndexOf(")") + 2).split(" ") : null;
 }, processStart = (pid) => statFields(pid)?.[19] ?? null, pidAlive2 = (pid) => {
@@ -76251,7 +76834,7 @@ __export(exports_check, {
   run: () => run11,
   workspaceResources: () => workspaceResources
 });
-import os19 from "node:os";
+import os20 from "node:os";
 import path49 from "node:path";
 function parse6(argv) {
   const split = argv.indexOf("--");
@@ -76435,7 +77018,7 @@ function hostToolWaitCapMs(env) {
 }
 async function workspaceResources(io) {
   const env = io.env;
-  const dir = env.WORKFLOW_TOOLKIT_CONFIG ?? env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path49.join(env.XDG_CONFIG_HOME || path49.join(env.HOME || os19.homedir(), ".config"), "workit");
+  const dir = env.WORKFLOW_TOOLKIT_CONFIG ?? env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path49.join(env.XDG_CONFIG_HOME || path49.join(env.HOME || os20.homedir(), ".config"), "workit");
   try {
     await Promise.resolve().then(() => init_workspaces());
     const workspace = resolveWorkspaceFrom(io.cwd, dir, env.WORKFLOW_WORKSPACE_NAME?.trim() || undefined);
@@ -76914,6 +77497,9 @@ var exports_models = {};
 __export(exports_models, {
   run: () => run13
 });
+import { existsSync as existsSync21, readdirSync as readdirSync10, readFileSync as readFileSync21, statSync as statSync9 } from "node:fs";
+import os21 from "node:os";
+import path51 from "node:path";
 async function run13(argv, io) {
   const [sub, ...args] = argv.filter((arg) => arg !== "--json");
   if (sub !== "show")
@@ -76921,13 +77507,27 @@ async function run13(argv, io) {
   const role = flag3(args, "--role");
   const tier = flag3(args, "--tier");
   const hostFlag = flag3(args, "--host");
-  for (const value of [role, tier, hostFlag])
+  const daysFlag = flag3(args, "--days");
+  for (const value of [role, tier, hostFlag, daysFlag])
     if (value instanceof Error)
       return emit(io, fail2("invalid_input", value.message));
   if (role && !MODEL_ROLES.includes(role))
     return emit(io, fail2("invalid_input", `unknown role ${role}: ${MODEL_ROLES.join(", ")}`));
   if (tier && !MODEL_TIERS.includes(tier))
     return emit(io, fail2("invalid_input", `unknown tier ${tier}: ${MODEL_TIERS.join(", ")}`));
+  const days = daysFlag === null ? 7 : Number(daysFlag);
+  if (!Number.isFinite(days) || days <= 0)
+    return emit(io, fail2("invalid_input", "--days needs a positive number"));
+  if (args.includes("--report")) {
+    const report = usageReport(io.cwd, io.env, days);
+    return emit(io, ok2(report), (data) => [
+      `subagent models over the last ${data.days} days (${data.agents} agents)`,
+      ...Object.entries(data.types).flatMap(([type, use]) => [
+        `  ${type}${use.role ? ` (role ${use.role}, default ${use.defaults.join("/") || "host default"})` : ""}: ${Object.entries(use.models).map(([model, count]) => `${model} x${count}`).join(", ")}`,
+        ...use.flagged.map((model) => `    flag: ran on ${model}, not the role default`)
+      ])
+    ]);
+  }
   const envHost = actorFromEnv(io.env).host;
   const host = hostFlag ?? (envHost === "cli" ? "claude_code" : envHost);
   const row = (selector) => resolveRoleModel(io.cwd, selector, host) ?? { model: null, effort: null, source: "none" };
@@ -76950,13 +77550,73 @@ async function run13(argv, io) {
     ...(data.issues ?? []).map((issue) => `note: ${issue}`)
   ]);
 }
-var USAGE6 = "workit models show [--role <role>] [--tier <tier>] [--host <host>] [--json]", flag3 = (argv, name) => {
+var USAGE6 = "workit models show [--role <role>] [--tier <tier>] [--host <host>] [--report [--days <n>]] [--json]", flag3 = (argv, name) => {
   const at = argv.findIndex((arg) => arg === name || arg.startsWith(`${name}=`));
   if (at < 0)
     return null;
   const value = argv[at].includes("=") ? argv[at].slice(name.length + 1) : argv[at + 1];
   return value && !value.startsWith("--") ? value : new Error(`${name} needs a value`);
-}, line2 = (label, entry) => `  ${label}: ${entry.model ? `${entry.model}${entry.effort ? ` (effort ${entry.effort})` : ""}  [${entry.source}]` : "host default (nothing configured)"}`;
+}, line2 = (label, entry) => `  ${label}: ${entry.model ? `${entry.model}${entry.effort ? ` (effort ${entry.effort})` : ""}  [${entry.source}]` : "host default (nothing configured)"}`, modelsOf = (file) => {
+  const found = new Set;
+  let text = "";
+  try {
+    text = readFileSync21(file, "utf8");
+  } catch {
+    return found;
+  }
+  for (const row of text.split(`
+`))
+    if (row.includes('"type":"assistant"'))
+      try {
+        const model = JSON.parse(row).message?.model;
+        if (typeof model === "string" && model && !model.startsWith("<"))
+          found.add(model);
+      } catch {}
+  return found;
+}, matches3 = (ran, configured) => ran.toLowerCase().includes(configured.toLowerCase()), usageReport = (cwd, env, days) => {
+  const projects = path51.join(env.CLAUDE_CONFIG_DIR || path51.join(env.HOME || os21.homedir(), ".claude"), "projects");
+  const since = Date.now() - days * 86400000;
+  const types = {};
+  let agents = 0;
+  const dirs = (dir) => {
+    try {
+      return readdirSync10(dir).map((name) => path51.join(dir, name));
+    } catch {
+      return [];
+    }
+  };
+  for (const project of dirs(projects))
+    for (const session of dirs(project))
+      for (const meta of dirs(path51.join(session, "subagents")).filter((f) => f.endsWith(".meta.json"))) {
+        try {
+          if (statSync9(meta).mtimeMs < since)
+            continue;
+          const agentType = JSON.parse(readFileSync21(meta, "utf8")).agentType;
+          const transcript = meta.replace(/\.meta\.json$/, ".jsonl");
+          if (typeof agentType !== "string" || !existsSync21(transcript))
+            continue;
+          const ran = modelsOf(transcript);
+          if (!ran.size)
+            continue;
+          agents += 1;
+          const selector = roleForAgentType(agentType);
+          const entry = types[agentType] ??= {
+            role: selector?.role ?? null,
+            defaults: selector ? [
+              ...new Set((selector.role === "implementer" ? MODEL_TIERS.map((tier) => ({ ...selector, tier })) : [selector]).flatMap((one) => resolveRoleModel(cwd, one, "claude_code")?.model ?? []))
+            ] : [],
+            models: {},
+            flagged: []
+          };
+          for (const model of ran) {
+            entry.models[model] = (entry.models[model] ?? 0) + 1;
+            if (entry.models[model] === 1 && entry.defaults.length && !entry.defaults.some((d) => matches3(model, d)))
+              entry.flagged.push(model);
+          }
+        } catch {}
+      }
+  return { days, agents, types };
+};
 var init_models = __esm(() => {
   init_role_models();
   init_ledger();
@@ -77072,8 +77732,8 @@ var success2 = (data) => ({ ok: true, data }), failure3 = (code, error, unblock)
 
 // packages/workit-core/src/git/ops.ts
 import { spawnSync as spawnSync20 } from "node:child_process";
-import { existsSync as existsSync21, readFileSync as readFileSync21 } from "node:fs";
-import path51 from "node:path";
+import { existsSync as existsSync22, readFileSync as readFileSync22 } from "node:fs";
+import path52 from "node:path";
 function operationInProgress(cwd) {
   const markers = [
     ["rebase-merge", "rebase"],
@@ -77086,18 +77746,18 @@ function operationInProgress(cwd) {
   if (!run.ok)
     return null;
   const found = run.stdout.split(`
-`).map((line) => path51.resolve(cwd, line.trim()));
+`).map((line) => path52.resolve(cwd, line.trim()));
   const conflicted = () => git5(cwd, ["ls-files", "-u"]).stdout.trim() !== "";
   for (const [index, [, operation]] of markers.entries()) {
     const marker = found[index];
-    if (!marker || !existsSync21(marker))
+    if (!marker || !existsSync22(marker))
       continue;
-    if (index === 1 && existsSync21(path51.join(marker, "applying")))
+    if (index === 1 && existsSync22(path52.join(marker, "applying")))
       return { operation: "am", commitAllowed: false, branch: null };
-    if (index === 0 && existsSync21(path51.join(marker, "amend")) && !conflicted()) {
+    if (index === 0 && existsSync22(path52.join(marker, "amend")) && !conflicted()) {
       let headName = "";
       try {
-        headName = readFileSync21(path51.join(marker, "head-name"), "utf8").trim();
+        headName = readFileSync22(path52.join(marker, "head-name"), "utf8").trim();
       } catch {}
       const branch = headName.startsWith("refs/heads/") ? headName.slice("refs/heads/".length) : null;
       return { operation, commitAllowed: branch !== null, branch };
@@ -77425,7 +78085,7 @@ function gitCommit(cwd, input) {
     if (paths.some((value) => value.startsWith("-") || !value.trim()))
       return failure3("invalid_input", "paths must not be empty or start with -");
     const tracked = new Set(nulList(git5(cwd, ["ls-files", "-z", "--", ...paths]).stdout));
-    const addable = paths.filter((value) => existsSync21(path51.resolve(cwd, value)) || [...tracked].some((file) => file === value || file.startsWith(`${value}/`)));
+    const addable = paths.filter((value) => existsSync22(path52.resolve(cwd, value)) || [...tracked].some((file) => file === value || file.startsWith(`${value}/`)));
     if (addable.length) {
       const added = git5(cwd, ["add", "-A", "--", ...addable]);
       if (!added.ok)
@@ -77952,12 +78612,12 @@ var init_ops = __esm(() => {
 
 // packages/workit-core/src/verdict-cover.ts
 import fs26 from "node:fs";
-import path52 from "node:path";
+import path53 from "node:path";
 function chainsAbove(cwd, branch) {
   const root = storeRoot(cwd);
   if (!root.ok)
     return [];
-  const dir = path52.join(root.value.root, "stacks");
+  const dir = path53.join(root.value.root, "stacks");
   let names = [];
   try {
     names = fs26.readdirSync(dir).filter((name) => name.endsWith(".json"));
@@ -77968,7 +78628,7 @@ function chainsAbove(cwd, branch) {
   for (const name of names.toSorted()) {
     let parsed;
     try {
-      parsed = JSON.parse(fs26.readFileSync(path52.join(dir, name), "utf8"));
+      parsed = JSON.parse(fs26.readFileSync(path53.join(dir, name), "utf8"));
     } catch {
       continue;
     }
@@ -78063,10 +78723,10 @@ var init_pr_lane = __esm(() => {
 
 // packages/workit-core/src/forge/reruns.ts
 import fs27 from "node:fs";
-import path53 from "node:path";
+import path54 from "node:path";
 function rerunLogPath(cwd) {
   const common = gitCommonDir(cwd);
-  return common ? path53.join(common, "workit", "ci-reruns.jsonl") : null;
+  return common ? path54.join(common, "workit", "ci-reruns.jsonl") : null;
 }
 function rerunCounts(cwd, key) {
   const counts = new Map;
@@ -78101,7 +78761,7 @@ function recordReruns(cwd, rows) {
   if (!file)
     return false;
   try {
-    fs27.mkdirSync(path53.dirname(file), { recursive: true });
+    fs27.mkdirSync(path54.dirname(file), { recursive: true });
     fs27.appendFileSync(file, rows.map((row) => `${JSON.stringify(row)}
 `).join(""));
     return true;
@@ -78114,7 +78774,7 @@ function withRerunLock(cwd, fn) {
   if (!file)
     return fn();
   const lock = `${file.slice(0, -".jsonl".length)}.lock`;
-  fs27.mkdirSync(path53.dirname(lock), { recursive: true });
+  fs27.mkdirSync(path54.dirname(lock), { recursive: true });
   const until = Date.now() + LOCK_WAIT_MS2;
   for (;; ) {
     try {
@@ -79029,7 +79689,7 @@ var init_pr_ops = __esm(() => {
 import { spawnSync as spawnSync22 } from "node:child_process";
 import { createHash as createHash17, randomBytes as randomBytes4 } from "node:crypto";
 import fs28 from "node:fs";
-import path54 from "node:path";
+import path55 from "node:path";
 function worktreeOf(cwd, branch) {
   const list = gitRun3(cwd, ["worktree", "list", "--porcelain"]);
   if (!list.ok)
@@ -79073,7 +79733,7 @@ function gitRestack(cwd, input) {
     if (!scratch)
       return { ok: false, conflict: false, worktree: cwd, error: "no store root" };
     fs28.mkdirSync(scratch, { recursive: true });
-    dir = path54.join(scratch, `${input.branch.replace(/[^A-Za-z0-9._-]+/gu, "_").slice(0, 40)}-${randomBytes4(4).toString("hex")}`);
+    dir = path55.join(scratch, `${input.branch.replace(/[^A-Za-z0-9._-]+/gu, "_").slice(0, 40)}-${randomBytes4(4).toString("hex")}`);
     const added = gitRun3(cwd, ["worktree", "add", "-q", dir, input.branch], GIT_TIMEOUTS.worktree);
     if (!added.ok)
       return { ok: false, conflict: false, worktree: cwd, error: firstLine(added) };
@@ -79114,7 +79774,7 @@ function pruneScratch(cwd) {
   if (!scratch || !fs28.existsSync(scratch))
     return;
   for (const name of fs28.readdirSync(scratch)) {
-    const dir = path54.join(scratch, name);
+    const dir = path55.join(scratch, name);
     if (!rebaseInProgress(dir) && !trackedDirt(dir))
       gitRun3(cwd, ["worktree", "remove", "--force", dir]);
   }
@@ -79124,7 +79784,7 @@ function stacksDir(cwd) {
   const root = storeRoot(cwd);
   if (!root.ok)
     return stackFail(root.code, root.error, root.unblock);
-  return { ok: true, data: path54.join(root.value.root, "stacks") };
+  return { ok: true, data: path55.join(root.value.root, "stacks") };
 }
 function parseStack(raw) {
   if (!isRecord12(raw) || !Array.isArray(raw.branches))
@@ -79176,7 +79836,7 @@ function readStack(cwd, name) {
   const dir = stacksDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path54.join(dir.data, fileFor(name));
+  const file = path55.join(dir.data, fileFor(name));
   let text;
   try {
     text = fs28.readFileSync(file, "utf8");
@@ -79197,7 +79857,7 @@ function writeStack(cwd, stack, now = new Date) {
   const dir = stacksDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path54.join(dir.data, fileFor(stack.name));
+  const file = path55.join(dir.data, fileFor(stack.name));
   const temp = `${file}.${process.pid}.tmp`;
   try {
     fs28.mkdirSync(dir.data, { recursive: true });
@@ -79225,7 +79885,7 @@ function listStacks(cwd) {
   for (const name of names) {
     let parsed = null;
     try {
-      parsed = parseStack(JSON.parse(fs28.readFileSync(path54.join(dir.data, name), "utf8")));
+      parsed = parseStack(JSON.parse(fs28.readFileSync(path55.join(dir.data, name), "utf8")));
     } catch {
       parsed = null;
     }
@@ -79284,7 +79944,7 @@ function takeLock(lock) {
     host: localLockHost(),
     nonce: randomBytes4(8).toString("hex")
   };
-  fs28.writeFileSync(path54.join(lock, OWNER), JSON.stringify(owner));
+  fs28.writeFileSync(path55.join(lock, OWNER), JSON.stringify(owner));
   return owner;
 }
 function reapLock(lock, observed) {
@@ -79321,7 +79981,7 @@ async function withStackLock(cwd, name, fn, waitMs = LOCK_WAIT_MS3) {
     return dir;
   if (!validName(name))
     return stackFail("invalid_input", "a stack name must be 1-200 printable characters");
-  const lock = path54.join(dir.data, `${fileFor(name)}.lock`);
+  const lock = path55.join(dir.data, `${fileFor(name)}.lock`);
   try {
     fs28.mkdirSync(dir.data, { recursive: true });
   } catch (error) {
@@ -79351,7 +80011,7 @@ async function withStackLock(cwd, name, fn, waitMs = LOCK_WAIT_MS3) {
   const touch = () => {
     try {
       const now = new Date;
-      fs28.utimesSync(path54.join(lock, OWNER), now, now);
+      fs28.utimesSync(path55.join(lock, OWNER), now, now);
     } catch {}
   };
   const beat = setInterval(touch, HEARTBEAT_MS);
@@ -80202,7 +80862,7 @@ var STACK_VERSION = 1, stackFail = (code, error, unblock, data) => ({
   return !status.ok || status.stdout.trim() !== "";
 }, scratchDir = (cwd) => {
   const dir = stacksDir(cwd);
-  return dir.ok ? path54.join(dir.data, "worktrees") : null;
+  return dir.ok ? path55.join(dir.data, "worktrees") : null;
 }, firstLine = (run) => (`${run.stderr}
 ${run.stdout}`.split(`
 `).find((line) => line.trim()) ?? "git failed").trim().slice(0, 300), stackFileName = (name) => `${name.replace(/[^A-Za-z0-9._-]+/gu, "_").replace(/^[._]+/u, "").slice(0, 48).toLowerCase()}-${createHash17("sha256").update(name).digest("hex").slice(0, 12)}.json`, fileFor, validName = (name) => {
@@ -80217,12 +80877,12 @@ ${run.stdout}`.split(`
 }, isRecord12 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), str3 = (value) => typeof value === "string" && value ? value : null, LOCK_WAIT_MS3 = 2000, HEARTBEAT_MS = 20000, HEARTBEAT_STALE_MS, OWNERLESS_STALE_MS = 30000, OWNER = "owner", readOwner = (lock) => {
   let raw = null;
   try {
-    raw = fs28.readFileSync(path54.join(lock, OWNER), "utf8");
+    raw = fs28.readFileSync(path55.join(lock, OWNER), "utf8");
   } catch {
     raw = null;
   }
   let age = null;
-  for (const target of [path54.join(lock, OWNER), lock])
+  for (const target of [path55.join(lock, OWNER), lock])
     try {
       age = Date.now() - fs28.statSync(target).mtimeMs;
       break;
@@ -80265,7 +80925,7 @@ var init_stack = __esm(() => {
 import { spawnSync as spawnSync23 } from "node:child_process";
 import { createHash as createHash18 } from "node:crypto";
 import fs29 from "node:fs";
-import path55 from "node:path";
+import path56 from "node:path";
 function expandBraces2(pattern, limit = 64) {
   for (let index = 0;index < pattern.length; index += 1) {
     if (pattern[index] === "\\") {
@@ -80511,7 +81171,7 @@ function parsePlan(raw, defaults, name) {
       id,
       branch,
       base: optional("base") ?? "",
-      worktree: path55.resolve(defaults.root, optional("worktree") ?? path55.join(defaults.worktreeRoot, id)),
+      worktree: path56.resolve(defaults.root, optional("worktree") ?? path56.join(defaults.worktreeRoot, id)),
       tier,
       reason,
       dependsOn: [...new Set(dependsOn ?? [])],
@@ -80742,11 +81402,11 @@ function defaultTrunk(cwd) {
 }
 function mainCheckout(cwd) {
   const common = gitCommonDir(cwd);
-  return common && path55.basename(common) === ".git" ? path55.dirname(common) : path55.resolve(cwd);
+  return common && path56.basename(common) === ".git" ? path56.dirname(common) : path56.resolve(cwd);
 }
 function worktreeRoot(cwd) {
   const main = mainCheckout(cwd);
-  return path55.join(path55.dirname(main), `${path55.basename(main)}-wt`);
+  return path56.join(path56.dirname(main), `${path56.basename(main)}-wt`);
 }
 function sliceHash(slice) {
   const {
@@ -80766,7 +81426,7 @@ function fanoutsDir(cwd) {
   const root = storeRoot(cwd);
   if (!root.ok)
     return fanoutFail(root.code, root.error, root.unblock);
-  return { ok: true, data: path55.join(root.value.root, "fanouts") };
+  return { ok: true, data: path56.join(root.value.root, "fanouts") };
 }
 function parseStored(raw) {
   if (!isRecord13(raw) || typeof raw.name !== "string" || typeof raw.trunk !== "string")
@@ -80834,7 +81494,7 @@ function readFanout(cwd, name) {
   const dir = fanoutsDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path55.join(dir.data, stackFileName(name));
+  const file = path56.join(dir.data, stackFileName(name));
   let parsed = null;
   try {
     parsed = parseStored(JSON.parse(fs29.readFileSync(file, "utf8")));
@@ -80859,7 +81519,7 @@ function listFanouts(cwd) {
   for (const entry of names) {
     let parsed = null;
     try {
-      parsed = parseStored(JSON.parse(fs29.readFileSync(path55.join(dir.data, entry), "utf8")));
+      parsed = parseStored(JSON.parse(fs29.readFileSync(path56.join(dir.data, entry), "utf8")));
     } catch {
       parsed = null;
     }
@@ -80898,7 +81558,7 @@ function writeFanout(cwd, plan) {
   const dir = fanoutsDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path55.join(dir.data, stackFileName(plan.name));
+  const file = path56.join(dir.data, stackFileName(plan.name));
   const temp = `${file}.${process.pid}.tmp`;
   try {
     fs29.mkdirSync(dir.data, { recursive: true });
@@ -81105,13 +81765,13 @@ var init_fanout = __esm(() => {
 // packages/workit-core/src/forge/exec.ts
 import { spawnSync as spawnSync24 } from "node:child_process";
 import fs30 from "node:fs";
-import path56 from "node:path";
+import path57 from "node:path";
 function findExecutable(bin, env) {
-  const dirs = (env.PATH ?? env.Path ?? "").split(path56.delimiter).filter(Boolean);
+  const dirs = (env.PATH ?? env.Path ?? "").split(path57.delimiter).filter(Boolean);
   const exts = process.platform === "win32" ? [".exe"] : [""];
   for (const dir of dirs)
     for (const ext of exts) {
-      const candidate = path56.join(dir, `${bin}${ext}`);
+      const candidate = path57.join(dir, `${bin}${ext}`);
       try {
         const stat = fs30.statSync(candidate);
         if (stat.isFile())
@@ -82855,7 +83515,7 @@ var init_duration = __esm(() => {
 });
 
 // packages/workit-cli/src/verbs/forge-common.ts
-import { readFileSync as readFileSync22 } from "node:fs";
+import { readFileSync as readFileSync23 } from "node:fs";
 function parseFlags(argv, spec) {
   const parsed = { values: {}, booleans: new Set, lists: {}, positionals: [] };
   for (let index = 0;index < argv.length; index += 1) {
@@ -82999,7 +83659,7 @@ var init_forge_common = __esm(() => {
   forgeDeps = {
     runner: undefined,
     npm: undefined,
-    readStdin: () => readFileSync22(0, "utf8"),
+    readStdin: () => readFileSync23(0, "utf8"),
     sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
     now: () => Date.now()
   };
@@ -83010,12 +83670,12 @@ var exports_pr = {};
 __export(exports_pr, {
   run: () => run14
 });
-import { readFileSync as readFileSync23 } from "node:fs";
-import path57 from "node:path";
+import { readFileSync as readFileSync24 } from "node:fs";
+import path58 from "node:path";
 function readBodyFile(io, file) {
   try {
     return {
-      body: file === "-" ? forgeDeps.readStdin() : readFileSync23(path57.resolve(io.cwd, file), "utf8")
+      body: file === "-" ? forgeDeps.readStdin() : readFileSync24(path58.resolve(io.cwd, file), "utf8")
     };
   } catch {
     return `cannot read --body-file ${file}`;
@@ -83720,8 +84380,8 @@ var exports_git = {};
 __export(exports_git, {
   run: () => run16
 });
-import { readFileSync as readFileSync24 } from "node:fs";
-import path58 from "node:path";
+import { readFileSync as readFileSync25 } from "node:fs";
+import path59 from "node:path";
 function kindHint(cwd, kind) {
   let kinds = [...BRANCH_KINDS];
   try {
@@ -83825,7 +84485,7 @@ function commitMessage(parsed, io) {
 
 `);
   try {
-    return file === "-" ? readFileSync24(0, "utf8") : readFileSync24(path58.resolve(io.cwd, file), "utf8");
+    return file === "-" ? readFileSync25(0, "utf8") : readFileSync25(path59.resolve(io.cwd, file), "utf8");
   } catch (error) {
     return {
       error: `cannot read -F ${file}: ${error instanceof Error ? error.message : String(error)}`
@@ -85246,7 +85906,7 @@ var init_live_session = __esm(() => {
 });
 
 // packages/workit-core/src/hooks/write-gate.ts
-import path59 from "node:path";
+import path60 from "node:path";
 var CASE_INSENSITIVE, PREFIXES2, SCRIPT_SHELLS, cache3, MUTATING_GIT, DRY_N, MUTATING_WORKIT_GIT, CD2, PUSHD2, POPD2, UNKNOWN_DIR;
 var init_write_gate = __esm(() => {
   init_task_store();
@@ -85286,7 +85946,7 @@ var init_write_gate = __esm(() => {
   CD2 = new Set(["cd", "chdir", "set-location", "sl"]);
   PUSHD2 = new Set(["pushd", "push-location"]);
   POPD2 = new Set(["popd", "pop-location"]);
-  UNKNOWN_DIR = path59.resolve(path59.parse(process.cwd()).root, ".workit-unknown-dir");
+  UNKNOWN_DIR = path60.resolve(path60.parse(process.cwd()).root, ".workit-unknown-dir");
 });
 
 // packages/workit-core/src/hooks/worktree-confine.ts
@@ -85311,20 +85971,20 @@ var init_worktree_confine = __esm(() => {
 
 // packages/workit-core/src/worktree-deps.ts
 import fs32 from "node:fs";
-import path60 from "node:path";
+import path61 from "node:path";
 function moduleDirs(main) {
   const out = [];
   const walk = (relative, depth) => {
     let entries;
     try {
-      entries = fs32.readdirSync(path60.join(main, relative), { withFileTypes: true });
+      entries = fs32.readdirSync(path61.join(main, relative), { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const child = path60.join(relative, entry.name);
+      const child = path61.join(relative, entry.name);
       if (entry.name === MODULES)
         out.push(child);
       else if (depth < MAX_DEPTH2 && !entry.name.startsWith("."))
@@ -85338,8 +85998,8 @@ function linkEntry(main, worktree, source, target) {
   const stat = fs32.lstatSync(source);
   if (stat.isSymbolicLink()) {
     const link = fs32.readlinkSync(source);
-    const outside = path60.isAbsolute(link) && within(link, main) && !path60.relative(main, link).split(path60.sep).includes(MODULES);
-    const to = outside ? path60.join(worktree, path60.relative(main, link)) : link;
+    const outside = path61.isAbsolute(link) && within(link, main) && !path61.relative(main, link).split(path61.sep).includes(MODULES);
+    const to = outside ? path61.join(worktree, path61.relative(main, link)) : link;
     fs32.symlinkSync(to, target, process.platform === "win32" ? "junction" : undefined);
     return;
   }
@@ -85349,8 +86009,8 @@ function mirror(main, worktree, source, target, top) {
   fs32.mkdirSync(target);
   let count = 0;
   for (const entry of fs32.readdirSync(source, { withFileTypes: true })) {
-    const from = path60.join(source, entry.name);
-    const to = path60.join(target, entry.name);
+    const from = path61.join(source, entry.name);
+    const to = path61.join(target, entry.name);
     if (top && entry.isDirectory() && (entry.name.startsWith("@") || entry.name === ".bin"))
       count += mirror(main, worktree, from, to, false);
     else {
@@ -85366,16 +86026,16 @@ function linkWorktreeDependencies(main, worktree) {
   const dirs = [];
   let entries = 0;
   for (const relative of moduleDirs(main)) {
-    const target = path60.join(worktree, relative);
-    if (!fs32.existsSync(path60.dirname(target)) || fs32.existsSync(target))
+    const target = path61.join(worktree, relative);
+    if (!fs32.existsSync(path61.dirname(target)) || fs32.existsSync(target))
       continue;
-    if (!gitRun4(worktree, ["check-ignore", "-q", `${relative.split(path60.sep).join("/")}/`]).ok) {
-      notes.push(`${relative.split(path60.sep).join("/")} is not ignored by git, so it was not linked from ${main}; install dependencies in the worktree yourself`);
+    if (!gitRun4(worktree, ["check-ignore", "-q", `${relative.split(path61.sep).join("/")}/`]).ok) {
+      notes.push(`${relative.split(path61.sep).join("/")} is not ignored by git, so it was not linked from ${main}; install dependencies in the worktree yourself`);
       continue;
     }
     try {
-      entries += mirror(main, worktree, path60.join(main, relative), target, true);
-      dirs.push(relative.split(path60.sep).join("/"));
+      entries += mirror(main, worktree, path61.join(main, relative), target, true);
+      dirs.push(relative.split(path61.sep).join("/"));
     } catch (error) {
       fs32.rmSync(target, { recursive: true, force: true });
       notes.push(`could not link ${relative} from ${main} (${error.message}); install dependencies in the worktree yourself`);
@@ -85388,8 +86048,8 @@ function linkWorktreeDependencies(main, worktree) {
   return { linked: { from: main, dirs, entries, ms }, notes };
 }
 var MODULES = "node_modules", MAX_DEPTH2 = 2, within = (child, parent) => {
-  const relative = path60.relative(parent, child);
-  return relative === "" || !relative.startsWith("..") && !path60.isAbsolute(relative);
+  const relative = path61.relative(parent, child);
+  return relative === "" || !relative.startsWith("..") && !path61.isAbsolute(relative);
 };
 var init_worktree_deps = __esm(() => {
   init_fanout();
@@ -85398,7 +86058,7 @@ var init_worktree_deps = __esm(() => {
 // packages/workit-core/src/fanout-worktree.ts
 import { randomBytes as randomBytes5 } from "node:crypto";
 import fs33 from "node:fs";
-import path61 from "node:path";
+import path62 from "node:path";
 function rowSample(lines) {
   const out = [];
   let bytes = 0;
@@ -85458,7 +86118,7 @@ function adminDir(worktree) {
   const file = dir.stdout.trim();
   let token = null;
   try {
-    token = fs33.readFileSync(path61.join(file, FANOUT_TOKEN_FILE), "utf8").trim() || null;
+    token = fs33.readFileSync(path62.join(file, FANOUT_TOKEN_FILE), "utf8").trim() || null;
   } catch {
     token = null;
   }
@@ -85466,7 +86126,7 @@ function adminDir(worktree) {
     const stat = worktreeDeps.stat(file);
     return {
       path: file,
-      id: path61.basename(file),
+      id: path62.basename(file),
       ino: stat.ino.toString(),
       token,
       birthMs: stat.birthtimeNs > 0n ? Number(stat.birthtimeMs) : null,
@@ -85482,7 +86142,7 @@ function markAdminDir(worktree) {
     return null;
   const token = randomBytes5(16).toString("hex");
   try {
-    fs33.writeFileSync(path61.join(admin.path, FANOUT_TOKEN_FILE), `${token}
+    fs33.writeFileSync(path62.join(admin.path, FANOUT_TOKEN_FILE), `${token}
 `);
   } catch {
     return null;
@@ -85497,7 +86157,7 @@ function excludeScratch(cwd) {
   const common = gitCommonDir(cwd);
   if (!common)
     return;
-  const file = path61.join(common, "info", "exclude");
+  const file = path62.join(common, "info", "exclude");
   let text = "";
   try {
     text = fs33.readFileSync(file, "utf8");
@@ -85506,7 +86166,7 @@ function excludeScratch(cwd) {
   }
   if (text.split(/\r?\n/u).includes(EXCLUDE_LINE))
     return;
-  fs33.mkdirSync(path61.dirname(file), { recursive: true });
+  fs33.mkdirSync(path62.dirname(file), { recursive: true });
   fs33.appendFileSync(file, `${text && !text.endsWith(`
 `) ? `
 ` : ""}# workit fanout: per-worker scratch dirs
@@ -85514,7 +86174,7 @@ ${EXCLUDE_LINE}
 `);
 }
 function ensureScratch(worktree) {
-  const scratch = path61.join(worktree, SCRATCH_DIR);
+  const scratch = path62.join(worktree, SCRATCH_DIR);
   fs33.mkdirSync(scratch, { recursive: true });
   return scratch;
 }
@@ -85742,7 +86402,7 @@ function unpushedCount(cwd, branch) {
   return count.ok ? Number(count.stdout.trim()) : null;
 }
 function removeScratch(worktree) {
-  const scratch = path61.join(worktree, SCRATCH_DIR);
+  const scratch = path62.join(worktree, SCRATCH_DIR);
   let stat;
   try {
     stat = fs33.lstatSync(scratch);
@@ -85758,16 +86418,16 @@ var SLOW, SCRATCH_DIR = ".workit-scratch", EXCLUDE_LINE, DIRTY_ROW_BYTES = 2000,
   try {
     return fs33.realpathSync.native(target);
   } catch {
-    return path61.resolve(target);
+    return path62.resolve(target);
   }
 }, samePath = (a, b) => {
   const left = canonical2(a);
   const right = canonical2(b);
   return process.platform === "win32" || process.platform === "darwin" ? left.toLowerCase() === right.toLowerCase() : left === right;
 }, inside3 = (child, parent) => {
-  const relative = path61.relative(canonical2(parent), canonical2(child));
-  return relative === "" || !relative.startsWith("..") && !path61.isAbsolute(relative);
-}, slicePath = (cwd, slice) => path61.isAbsolute(slice.worktree) ? slice.worktree : path61.resolve(mainCheckout(cwd), slice.worktree), CLOCK_SLACK_MS = 2000, worktreeDeps, worktreeFailed = (stderr) => fanoutFail("failed", `git worktree add failed: ${stderr.trim().split(`
+  const relative = path62.relative(canonical2(parent), canonical2(child));
+  return relative === "" || !relative.startsWith("..") && !path62.isAbsolute(relative);
+}, slicePath = (cwd, slice) => path62.isAbsolute(slice.worktree) ? slice.worktree : path62.resolve(mainCheckout(cwd), slice.worktree), CLOCK_SLACK_MS = 2000, worktreeDeps, worktreeFailed = (stderr) => fanoutFail("failed", `git worktree add failed: ${stderr.trim().split(`
 `)[0] || "unknown error"}`);
 var init_fanout_worktree = __esm(() => {
   init_ops();
@@ -86603,7 +87263,7 @@ __export(exports_fanout, {
   run: () => run20
 });
 import fs34 from "node:fs";
-import path62 from "node:path";
+import path63 from "node:path";
 function forgeFor(io, offline) {
   if (offline)
     return { forge: null, error: "--offline" };
@@ -86664,7 +87324,7 @@ function plan2(argv, io) {
     return usage3(io, "pass --trunk or --track, not both (--track picks the trunk)", PLAN_USAGE2);
   if (flags.positionals.length !== 1)
     return usage3(io, flags.positionals.length ? `unexpected argument ${flags.positionals[1]}` : "missing <plan.json>", PLAN_USAGE2);
-  const file = path62.resolve(io.cwd, flags.positionals[0]);
+  const file = path63.resolve(io.cwd, flags.positionals[0]);
   let raw;
   try {
     raw = JSON.parse(fs34.readFileSync(file, "utf8"));
@@ -102203,7 +102863,7 @@ var init_ast = __esm(() => {
 
 // packages/workit-cli/src/test-audit/rules.ts
 import { builtinModules } from "node:module";
-import path63 from "node:path";
+import path64 from "node:path";
 function testCallee(call) {
   let callee = call.callee;
   if (callee.type === "CallExpression")
@@ -102696,12 +103356,12 @@ function checkConstantsOnly(ctx, emit) {
 }
 function checkOverMocking(ctx, emit) {
   const { program } = ctx.parsed;
-  const unit = path63.basename(ctx.file).replace(/\.(?:[cm]?[jt]sx?)$/, "").replace(/\.(?:test|spec)$/, "");
+  const unit = path64.basename(ctx.file).replace(/\.(?:[cm]?[jt]sx?)$/, "").replace(/\.(?:test|spec)$/, "");
   const mocked = find2(program, (node) => node.type === "CallExpression" && MODULE_MOCK.test(calleeName(node.callee) ?? "") && node.arguments[0]?.type === "StringLiteral");
   const internal = mocked.filter((call) => /^(?:\.|@\/|~\/)/.test(call.arguments[0].value));
   for (const call of mocked) {
     const spec = call.arguments[0].value;
-    const base = path63.basename(spec.replace(/\/index(?:\.[cm]?[jt]sx?)?$/, "")).replace(/\.(?:[cm]?[jt]sx?)$/, "");
+    const base = path64.basename(spec.replace(/\/index(?:\.[cm]?[jt]sx?)?$/, "")).replace(/\.(?:[cm]?[jt]sx?)$/, "");
     if (base === unit)
       emit({
         rule: "over-mocking",
@@ -103090,8 +103750,8 @@ var init_rules = __esm(() => {
 
 // packages/workit-cli/src/test-audit/audit.ts
 import { spawnSync as spawnSync29 } from "node:child_process";
-import { existsSync as existsSync22, readdirSync as readdirSync10, readFileSync as readFileSync25, statSync as statSync9 } from "node:fs";
-import path64 from "node:path";
+import { existsSync as existsSync23, readdirSync as readdirSync11, readFileSync as readFileSync26, statSync as statSync10 } from "node:fs";
+import path65 from "node:path";
 function git7(cwd, args) {
   const run = spawnSync29("git", ["-c", "core.quotepath=off", ...args], {
     cwd,
@@ -103101,10 +103761,10 @@ function git7(cwd, args) {
   return { ok: run.status === 0, stdout: run.stdout ?? "" };
 }
 function walkTests(dir, out) {
-  for (const entry of readdirSync10(dir, { withFileTypes: true })) {
+  for (const entry of readdirSync11(dir, { withFileTypes: true })) {
     if (entry.name.startsWith(".") && entry.name !== "." && entry.isDirectory())
       continue;
-    const full = path64.join(dir, entry.name);
+    const full = path65.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (!SKIP_DIRS.has(entry.name))
         walkTests(full, out);
@@ -103116,10 +103776,10 @@ function expandPaths(cwd, inputs) {
   const files = [];
   const missing = [];
   for (const input of inputs.length > 0 ? inputs : ["."]) {
-    const full = path64.resolve(cwd, input);
-    if (!existsSync22(full))
+    const full = path65.resolve(cwd, input);
+    if (!existsSync23(full))
       missing.push(input);
-    else if (statSync9(full).isDirectory())
+    else if (statSync10(full).isDirectory())
       walkTests(full, files);
     else
       files.push(full);
@@ -103153,11 +103813,11 @@ function changedLines(cwd, base) {
       for (let offset = 0;offset < count; offset += 1)
         lines.add(start + offset);
     }
-    changed.set(path64.join(root, file), lines);
+    changed.set(path65.join(root, file), lines);
   }
   const untracked = git7(root, ["ls-files", "--others", "--exclude-standard", "-z"]);
   for (const file of untracked.stdout.split("\x00").filter(Boolean))
-    changed.set(path64.join(root, file), "all");
+    changed.set(path65.join(root, file), "all");
   return changed;
 }
 function auditFiles(files, display) {
@@ -103170,7 +103830,7 @@ function auditFiles(files, display) {
     const shown = display(file);
     let parsed;
     try {
-      parsed = parseSource(readFileSync25(file, "utf8"), file);
+      parsed = parseSource(readFileSync26(file, "utf8"), file);
     } catch (error) {
       parseErrors.push({
         file: shown,
@@ -103219,7 +103879,7 @@ function auditFiles(files, display) {
     durationMs: Math.round(performance.now() - started)
   };
 }
-var TEST_FILE, CODE_FILE, SKIP_DIRS, toPosix = (file) => file.split(path64.sep).join("/"), SEVERITY_ORDER, ruleIds;
+var TEST_FILE, CODE_FILE, SKIP_DIRS, toPosix = (file) => file.split(path65.sep).join("/"), SEVERITY_ORDER, ruleIds;
 var init_audit = __esm(() => {
   init_ast();
   init_rules();
@@ -103233,23 +103893,23 @@ var init_audit = __esm(() => {
 // packages/workit-cli/src/test-audit/mutate.ts
 import { spawn as spawn2 } from "node:child_process";
 import {
-  existsSync as existsSync23,
+  existsSync as existsSync24,
   lstatSync as lstatSync8,
   mkdirSync as mkdirSync11,
   mkdtempSync as mkdtempSync4,
-  readdirSync as readdirSync11,
-  readFileSync as readFileSync26,
+  readdirSync as readdirSync12,
+  readFileSync as readFileSync27,
   readlinkSync as readlinkSync3,
   realpathSync as realpathSync10,
   renameSync as renameSync7,
   rmSync as rmSync9,
-  statSync as statSync10,
+  statSync as statSync11,
   symlinkSync,
   writeFileSync as writeFileSync11,
   copyFileSync as copyFileSync7
 } from "node:fs";
-import os20 from "node:os";
-import path65 from "node:path";
+import os22 from "node:os";
+import path66 from "node:path";
 function mutantsFor(source, file, lines) {
   const parsed = parseSource(source, file);
   const out = [];
@@ -103322,7 +103982,7 @@ function relatedTests(source, testFiles) {
     for (const match of text.matchAll(SPECIFIER)) {
       const spec = match[1];
       if (spec.startsWith(".")) {
-        if (stripExt(path65.posix.join(path65.posix.dirname(file), spec)) === target)
+        if (stripExt(path66.posix.join(path66.posix.dirname(file), spec)) === target)
           return true;
       } else if (spec.includes("/") && stripExt(spec).split("/").slice(-2).join("/") === tail)
         return true;
@@ -103330,11 +103990,11 @@ function relatedTests(source, testFiles) {
     return false;
   }).map((entry) => entry.file);
 }
-function removeStaleCopies(tmp = os20.tmpdir()) {
+function removeStaleCopies(tmp = os22.tmpdir()) {
   let removed = 0;
   let names = [];
   try {
-    names = readdirSync11(tmp);
+    names = readdirSync12(tmp);
   } catch {
     return 0;
   }
@@ -103342,12 +104002,12 @@ function removeStaleCopies(tmp = os20.tmpdir()) {
   for (const name of names) {
     if (!name.startsWith(TEMP_PREFIX))
       continue;
-    const dir = path65.join(tmp, name);
+    const dir = path66.join(tmp, name);
     try {
       const stat = lstatSync8(dir);
       if (!stat.isDirectory() || uid !== undefined && stat.uid !== uid)
         continue;
-      const pid = Number(readFileSync26(path65.join(dir, PID_FILE), "utf8"));
+      const pid = Number(readFileSync27(path66.join(dir, PID_FILE), "utf8"));
       if (Number.isInteger(pid) && pid > 0 && alive(pid))
         continue;
     } catch (error) {
@@ -103363,9 +104023,9 @@ function removeStaleCopies(tmp = os20.tmpdir()) {
 }
 function linkNodeModules(origin, target, repo, copy) {
   mkdirSync11(target, { recursive: true });
-  for (const entry of readdirSync11(origin, { withFileTypes: true })) {
-    const from = path65.join(origin, entry.name);
-    const to = path65.join(target, entry.name);
+  for (const entry of readdirSync12(origin, { withFileTypes: true })) {
+    const from = path66.join(origin, entry.name);
+    const to = path66.join(target, entry.name);
     if (entry.name.startsWith("@") && entry.isDirectory()) {
       linkNodeModules(from, to, repo, copy);
       continue;
@@ -103381,9 +104041,9 @@ function linkNodeModules(origin, target, repo, copy) {
       } catch {
         continue;
       }
-      const relative = path65.relative(repo, real);
-      if (!relative.startsWith("..") && !path65.isAbsolute(relative) && !relative.split(path65.sep).includes("node_modules")) {
-        symlinkSync(path65.join(copy, relative), to, "junction");
+      const relative = path66.relative(repo, real);
+      if (!relative.startsWith("..") && !path66.isAbsolute(relative) && !relative.split(path66.sep).includes("node_modules")) {
+        symlinkSync(path66.join(copy, relative), to, "junction");
         continue;
       }
     }
@@ -103399,19 +104059,19 @@ function copySymlink(repo, tree, from, to) {
   }
   const realRepo = realpathSync10(repo);
   if (real && inside4(realRepo, real)) {
-    symlinkSync(path65.relative(path65.dirname(to), path65.join(tree, path65.relative(realRepo, real))), to);
+    symlinkSync(path66.relative(path66.dirname(to), path66.join(tree, path66.relative(realRepo, real))), to);
     return;
   }
-  if (real && statSync10(real).isFile())
+  if (real && statSync11(real).isFile())
     copyFileSync7(real, to);
   else
     symlinkSync(readlinkSync3(from), to);
 }
 function writeInside(copy, file, content) {
-  const target = path65.join(copy, file);
+  const target = path66.join(copy, file);
   try {
     const stat = lstatSync8(target);
-    if (!stat.isFile() || !inside4(realpathSync10(copy), realpathSync10(path65.dirname(target))))
+    if (!stat.isFile() || !inside4(realpathSync10(copy), realpathSync10(path66.dirname(target))))
       return false;
   } catch {
     return false;
@@ -103422,9 +104082,9 @@ function writeInside(copy, file, content) {
   return true;
 }
 function copyWorkingTree(repo) {
-  const dir = mkdtempSync4(path65.join(os20.tmpdir(), TEMP_PREFIX));
-  writeFileSync11(path65.join(dir, PID_FILE), String(process.pid));
-  const tree = path65.join(dir, "tree");
+  const dir = mkdtempSync4(path66.join(os22.tmpdir(), TEMP_PREFIX));
+  writeFileSync11(path66.join(dir, PID_FILE), String(process.pid));
+  const tree = path66.join(dir, "tree");
   const head = git7(repo, ["rev-parse", "--verify", "--quiet", "HEAD"]).stdout.trim();
   if (head && git7(dir, ["clone", "-q", "--shared", "--no-checkout", repo, tree]).ok) {
     const branch = git7(repo, ["symbolic-ref", "--quiet", "--short", "HEAD"]).stdout.trim();
@@ -103441,29 +104101,29 @@ function copyWorkingTree(repo) {
   for (const relative of listed) {
     if (!relative)
       continue;
-    const from = path65.join(repo, relative);
+    const from = path66.join(repo, relative);
     let stat;
     try {
       stat = lstatSync8(from);
     } catch {
       continue;
     }
-    const to = path65.join(tree, relative);
-    mkdirSync11(path65.dirname(to), { recursive: true });
+    const to = path66.join(tree, relative);
+    mkdirSync11(path66.dirname(to), { recursive: true });
     if (stat.isSymbolicLink())
       copySymlink(repo, tree, from, to);
     else if (stat.isFile())
       copyFileSync7(from, to);
-    let parent = path65.dirname(relative);
+    let parent = path66.dirname(relative);
     while (parent !== "." && !dirs.has(parent)) {
       dirs.add(parent);
-      parent = path65.dirname(parent);
+      parent = path66.dirname(parent);
     }
   }
   for (const parent of dirs) {
-    const modules = path65.join(repo, parent, "node_modules");
-    if (existsSync23(modules) && !existsSync23(path65.join(tree, parent, "node_modules")))
-      linkNodeModules(modules, path65.join(tree, parent, "node_modules"), repo, tree);
+    const modules = path66.join(repo, parent, "node_modules");
+    if (existsSync24(modules) && !existsSync24(path66.join(tree, parent, "node_modules")))
+      linkNodeModules(modules, path66.join(tree, parent, "node_modules"), repo, tree);
   }
   return { dir, tree };
 }
@@ -103502,20 +104162,20 @@ async function runMutation(options) {
   const tracked = git7(repo, ["ls-files", "-co", "--exclude-standard", "-z"]).stdout.split("\x00").filter(Boolean);
   const testFiles = tracked.filter((file) => TEST_FILE.test(file)).map((file) => {
     try {
-      return { file, text: readFileSync26(path65.join(repo, file), "utf8") };
+      return { file, text: readFileSync27(path66.join(repo, file), "utf8") };
     } catch {
       return { file, text: "" };
     }
   });
   const candidates = [];
   for (const [absolute, lines] of [...options.changed].toSorted(([a], [b]) => a.localeCompare(b))) {
-    const relative = toPosix(path65.relative(repo, absolute));
+    const relative = toPosix(path66.relative(repo, absolute));
     if (!CODE_FILE.test(relative) || TEST_FILE.test(relative) || relative.endsWith(".d.ts"))
       continue;
-    if (NOT_SOURCE.test(relative) || !existsSync23(absolute))
+    if (NOT_SOURCE.test(relative) || !existsSync24(absolute))
       continue;
     try {
-      candidates.push(...mutantsFor(readFileSync26(absolute, "utf8"), relative, lines));
+      candidates.push(...mutantsFor(readFileSync27(absolute, "utf8"), relative, lines));
     } catch {}
   }
   const mutants = candidates.map((mutant, index) => ({ ...mutant, id: index + 1 }));
@@ -103523,9 +104183,9 @@ async function runMutation(options) {
   for (const mutant of mutants)
     if (!related.has(mutant.file))
       related.set(mutant.file, relatedTests(mutant.file, testFiles));
-  const cwdRelative = path65.relative(repo, options.cwd);
+  const cwdRelative = path66.relative(repo, options.cwd);
   const asArg = (file) => {
-    const relative = toPosix(path65.relative(cwdRelative, file));
+    const relative = toPosix(path66.relative(cwdRelative, file));
     return shellQuote(relative.startsWith(".") ? relative : `./${relative}`);
   };
   const commandFor = (tests) => options.command.replaceAll("{files}", () => tests.map(asArg).join(" "));
@@ -103561,7 +104221,7 @@ async function runMutation(options) {
     return finish3(options, 0, results, counts, started);
   removeStaleCopies();
   const { dir: copyDir, tree: copy } = copyWorkingTree(repo);
-  const copyCwd = path65.join(copy, cwdRelative);
+  const copyCwd = path66.join(copy, cwdRelative);
   let current = null;
   const restore = () => {
     if (current)
@@ -103596,7 +104256,7 @@ async function runMutation(options) {
         record({ ...mutant, status: "skipped", durationMs: 0, tests, reason: "budget" });
         continue;
       }
-      const original = readFileSync26(path65.join(copy, mutant.file), "utf8");
+      const original = readFileSync27(path66.join(copy, mutant.file), "utf8");
       const mutated = original.slice(0, mutant.start) + mutant.replacement + original.slice(mutant.end);
       current = { file: mutant.file, original };
       if (!writeInside(copy, mutant.file, mutated)) {
@@ -103653,8 +104313,8 @@ var NOT_SOURCE, FLIPS, isStringy = (node) => node.type === "StringLiteral" || no
     return error.code === "EPERM";
   }
 }, inside4 = (root, file) => {
-  const relative = path65.relative(root, file);
-  return relative === "" || !relative.startsWith("..") && !path65.isAbsolute(relative);
+  const relative = path66.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path66.isAbsolute(relative);
 }, active, killTree = (child) => {
   try {
     if (child.pid && process.platform !== "win32")
@@ -103702,8 +104362,8 @@ var exports_test_audit = {};
 __export(exports_test_audit, {
   run: () => run22
 });
-import { existsSync as existsSync24 } from "node:fs";
-import path66 from "node:path";
+import { existsSync as existsSync25 } from "node:fs";
+import path67 from "node:path";
 function parse8(argv) {
   const options = {
     paths: [],
@@ -103808,8 +104468,8 @@ async function run22(argv, io) {
     return emit(io, fail2("invalid_input", `${options}
 usage: ${USAGE14}`));
   const top = git7(io.cwd, ["rev-parse", "--show-toplevel"]);
-  const repo = top.ok ? path66.resolve(top.stdout.trim()) : null;
-  const display = (file) => toPosix(path66.relative(io.cwd, file) || file);
+  const repo = top.ok ? path67.resolve(top.stdout.trim()) : null;
+  const display = (file) => toPosix(path67.relative(io.cwd, file) || file);
   let base = null;
   let changed = null;
   if (options.diff || options.mutate) {
@@ -103826,7 +104486,7 @@ usage: ${USAGE14}`));
   }
   let files;
   if (options.diff && changed)
-    files = [...changed.keys()].filter((file) => TEST_FILE.test(toPosix(file)) && existsSync24(file)).toSorted();
+    files = [...changed.keys()].filter((file) => TEST_FILE.test(toPosix(file)) && existsSync25(file)).toSorted();
   else {
     const expanded = expandPaths(io.cwd, options.paths);
     if (expanded.missing.length > 0)
@@ -103947,8 +104607,8 @@ var exports_youtrack = {};
 __export(exports_youtrack, {
   run: () => run24
 });
-import { readFileSync as readFileSync27 } from "node:fs";
-import path67 from "node:path";
+import { readFileSync as readFileSync28 } from "node:fs";
+import path68 from "node:path";
 async function run24(argv, io) {
   const [sub, ...rest] = argv;
   if (sub !== "note" && sub !== "time" && sub !== "meeting")
@@ -103994,7 +104654,7 @@ async function run24(argv, io) {
     let markdown = flags.values.markdown ?? "";
     if (flags.values.file)
       try {
-        markdown = readFileSync27(path67.resolve(io.cwd, flags.values.file), "utf8");
+        markdown = readFileSync28(path68.resolve(io.cwd, flags.values.file), "utf8");
       } catch (error) {
         return usage3(io, `cannot read ${flags.values.file}: ${String(error)}`, USAGE16);
       }
@@ -104062,8 +104722,8 @@ var exports_changelog = {};
 __export(exports_changelog, {
   run: () => run25
 });
-import { readFileSync as readFileSync28 } from "node:fs";
-import path68 from "node:path";
+import { readFileSync as readFileSync29 } from "node:fs";
+import path69 from "node:path";
 async function run25(argv, io) {
   const [sub, ...rest] = argv;
   if (sub !== "apply")
@@ -104109,7 +104769,7 @@ async function run25(argv, io) {
   ]);
 }
 var USAGE17 = "workit changelog apply (--entries <JSON|@file|-> | --normalize-only) [--path CHANGELOG.md] [--preview]", readEntries = (raw, cwd) => {
-  const text = raw === "-" ? readFileSync28(0, "utf8") : raw.startsWith("@") ? readFileSync28(path68.resolve(cwd, raw.slice(1)), "utf8") : raw;
+  const text = raw === "-" ? readFileSync29(0, "utf8") : raw.startsWith("@") ? readFileSync29(path69.resolve(cwd, raw.slice(1)), "utf8") : raw;
   return JSON.parse(text);
 };
 var init_changelog2 = __esm(() => {
@@ -104206,7 +104866,7 @@ var init_handoff = __esm(() => {
 // packages/workit-cli/src/main.ts
 init_host_session();
 init_package();
-import path69 from "node:path";
+import path70 from "node:path";
 
 // packages/workit-cli/src/verbs/registry.ts
 var TASK_FAMILY_NAMES = [
@@ -104451,7 +105111,7 @@ var VERBS = [
     subcommands: [
       {
         name: "show",
-        usage: "workit models show [--role <role>] [--tier <mundane|standard|hard>] [--host <host>] [--json]",
+        usage: "workit models show [--role <role>] [--tier <mundane|standard|hard>] [--host <host>] [--report [--days <n>]] [--json]",
         summary: "Print the resolved model and effort per role for a host (default: the lead's host, else claude_code) and where each came from"
       }
     ],
@@ -105068,7 +105728,7 @@ var defaultIo = (json) => ({
 });
 async function main(argv, overrides = {}, options = {}) {
   const parsed = parseGlobals(argv);
-  const cwd = path69.resolve(overrides.cwd ?? process.cwd(), parsed.cwd ?? ".");
+  const cwd = path70.resolve(overrides.cwd ?? process.cwd(), parsed.cwd ?? ".");
   const io = { ...defaultIo(parsed.json), ...overrides, json: parsed.json, cwd };
   if (parsed.error)
     return emit(io, fail2("invalid_input", parsed.error));