@reportforge/playwright-pdf 0.19.0 → 0.20.0

package/dist/cli/index.js

@@ -1588,13 +1588,13 @@ var require_ast = __commonJS({
         helperExpression: function helperExpression(node) {
           return node.type === "SubExpression" || (node.type === "MustacheStatement" || node.type === "BlockStatement") && !!(node.params && node.params.length || node.hash);
         },
-        scopedId: function scopedId(path12) {
-          return /^\.|this\b/.test(path12.original);
+        scopedId: function scopedId(path14) {
+          return /^\.|this\b/.test(path14.original);
         },
         // an ID is simple if it only has one part, and that part is not
         // `..` or `this`.
-        simpleId: function simpleId(path12) {
-          return path12.parts.length === 1 && !AST.helpers.scopedId(path12) && !path12.depth;
+        simpleId: function simpleId(path14) {
+          return path14.parts.length === 1 && !AST.helpers.scopedId(path14) && !path14.depth;
         }
       }
     };
@@ -2668,12 +2668,12 @@ var require_helpers2 = __commonJS({
         loc
       };
     }
-    function prepareMustache(path12, params, hash, open, strip, locInfo) {
+    function prepareMustache(path14, params, hash, open, strip, locInfo) {
       var escapeFlag = open.charAt(3) || open.charAt(2), escaped = escapeFlag !== "{" && escapeFlag !== "&";
       var decorator = /\*/.test(open);
       return {
         type: decorator ? "Decorator" : "MustacheStatement",
-        path: path12,
+        path: path14,
         params,
         hash,
         escaped,
@@ -2993,9 +2993,9 @@ var require_compiler = __commonJS({
       },
       DecoratorBlock: function DecoratorBlock(decorator) {
         var program = decorator.program && this.compileProgram(decorator.program);
-        var params = this.setupFullMustacheParams(decorator, program, void 0), path12 = decorator.path;
+        var params = this.setupFullMustacheParams(decorator, program, void 0), path14 = decorator.path;
         this.useDecorators = true;
-        this.opcode("registerDecorator", params.length, path12.original);
+        this.opcode("registerDecorator", params.length, path14.original);
       },
       PartialStatement: function PartialStatement(partial) {
         this.usePartial = true;
@@ -3059,46 +3059,46 @@ var require_compiler = __commonJS({
         }
       },
       ambiguousSexpr: function ambiguousSexpr(sexpr, program, inverse) {
-        var path12 = sexpr.path, name = path12.parts[0], isBlock = program != null || inverse != null;
-        this.opcode("getContext", path12.depth);
+        var path14 = sexpr.path, name = path14.parts[0], isBlock = program != null || inverse != null;
+        this.opcode("getContext", path14.depth);
         this.opcode("pushProgram", program);
         this.opcode("pushProgram", inverse);
-        path12.strict = true;
-        this.accept(path12);
+        path14.strict = true;
+        this.accept(path14);
         this.opcode("invokeAmbiguous", name, isBlock);
       },
       simpleSexpr: function simpleSexpr(sexpr) {
-        var path12 = sexpr.path;
-        path12.strict = true;
-        this.accept(path12);
+        var path14 = sexpr.path;
+        path14.strict = true;
+        this.accept(path14);
         this.opcode("resolvePossibleLambda");
       },
       helperSexpr: function helperSexpr(sexpr, program, inverse) {
-        var params = this.setupFullMustacheParams(sexpr, program, inverse), path12 = sexpr.path, name = path12.parts[0];
+        var params = this.setupFullMustacheParams(sexpr, program, inverse), path14 = sexpr.path, name = path14.parts[0];
         if (this.options.knownHelpers[name]) {
           this.opcode("invokeKnownHelper", params.length, name);
         } else if (this.options.knownHelpersOnly) {
           throw new _exception2["default"]("You specified knownHelpersOnly, but used the unknown helper " + name, sexpr);
         } else {
-          path12.strict = true;
-          path12.falsy = true;
-          this.accept(path12);
-          this.opcode("invokeHelper", params.length, path12.original, _ast2["default"].helpers.simpleId(path12));
+          path14.strict = true;
+          path14.falsy = true;
+          this.accept(path14);
+          this.opcode("invokeHelper", params.length, path14.original, _ast2["default"].helpers.simpleId(path14));
         }
       },
-      PathExpression: function PathExpression(path12) {
-        this.addDepth(path12.depth);
-        this.opcode("getContext", path12.depth);
-        var name = path12.parts[0], scoped = _ast2["default"].helpers.scopedId(path12), blockParamId = !path12.depth && !scoped && this.blockParamIndex(name);
+      PathExpression: function PathExpression(path14) {
+        this.addDepth(path14.depth);
+        this.opcode("getContext", path14.depth);
+        var name = path14.parts[0], scoped = _ast2["default"].helpers.scopedId(path14), blockParamId = !path14.depth && !scoped && this.blockParamIndex(name);
         if (blockParamId) {
-          this.opcode("lookupBlockParam", blockParamId, path12.parts);
+          this.opcode("lookupBlockParam", blockParamId, path14.parts);
         } else if (!name) {
           this.opcode("pushContext");
-        } else if (path12.data) {
+        } else if (path14.data) {
           this.options.data = true;
-          this.opcode("lookupData", path12.depth, path12.parts, path12.strict);
+          this.opcode("lookupData", path14.depth, path14.parts, path14.strict);
         } else {
-          this.opcode("lookupOnContext", path12.parts, path12.falsy, path12.strict, scoped);
+          this.opcode("lookupOnContext", path14.parts, path14.falsy, path14.strict, scoped);
         }
       },
       StringLiteral: function StringLiteral(string) {
@@ -3454,16 +3454,16 @@ var require_util = __commonJS({
     }
     exports2.urlGenerate = urlGenerate;
     function normalize(aPath) {
-      var path12 = aPath;
+      var path14 = aPath;
       var url = urlParse(aPath);
       if (url) {
         if (!url.path) {
           return aPath;
         }
-        path12 = url.path;
+        path14 = url.path;
       }
-      var isAbsolute = exports2.isAbsolute(path12);
-      var parts = path12.split(/\/+/);
+      var isAbsolute = exports2.isAbsolute(path14);
+      var parts = path14.split(/\/+/);
       for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
         part = parts[i];
         if (part === ".") {
@@ -3480,15 +3480,15 @@ var require_util = __commonJS({
           }
         }
       }
-      path12 = parts.join("/");
-      if (path12 === "") {
-        path12 = isAbsolute ? "/" : ".";
+      path14 = parts.join("/");
+      if (path14 === "") {
+        path14 = isAbsolute ? "/" : ".";
       }
       if (url) {
-        url.path = path12;
+        url.path = path14;
         return urlGenerate(url);
       }
-      return path12;
+      return path14;
     }
     exports2.normalize = normalize;
     function join(aRoot, aPath) {
@@ -6291,8 +6291,8 @@ var require_printer = __commonJS({
       return this.accept(sexpr.path) + " " + params + hash;
     };
     PrintVisitor.prototype.PathExpression = function(id) {
-      var path12 = id.parts.join("/");
-      return (id.data ? "@" : "") + "PATH:" + path12;
+      var path14 = id.parts.join("/");
+      return (id.data ? "@" : "") + "PATH:" + path14;
     };
     PrintVisitor.prototype.StringLiteral = function(string) {
       return '"' + string.value + '"';
@@ -6333,8 +6333,8 @@ var require_lib = __commonJS({
     handlebars.print = printer.print;
     module2.exports = handlebars;
     function extension(module3, filename) {
-      var fs12 = require("fs");
-      var templateString = fs12.readFileSync(filename, "utf8");
+      var fs14 = require("fs");
+      var templateString = fs14.readFileSync(filename, "utf8");
       module3.exports = handlebars.compile(templateString);
     }
     if (typeof require !== "undefined" && require.extensions) {
@@ -6854,8 +6854,8 @@ var init_engine = __esm({
           };
           return map[v] ?? (typeof v === "string" ? v.toUpperCase() : v);
         });
-        this.handlebars.registerHelper("coverageBand", (pct) => {
-          const n = Number(pct);
+        this.handlebars.registerHelper("coverageBand", (pct2) => {
+          const n = Number(pct2);
           return n >= 80 ? "high" : n >= 50 ? "mid" : "low";
         });
         this.handlebars.registerHelper("addOne", (n) => (n ?? 0) + 1);
@@ -7005,7 +7005,7 @@ var require_util2 = __commonJS({
   "node_modules/chrome-finder/lib/util.js"(exports2, module2) {
     "use strict";
     init_cjs_shims();
-    var fs12 = require("fs");
+    var fs14 = require("fs");
     var newLineRegex = /\r?\n/;
     function sort(installations, priorities) {
       const defaultPriority = 10;
@@ -7023,7 +7023,7 @@ var require_util2 = __commonJS({
         return false;
       }
       try {
-        fs12.accessSync(file);
+        fs14.accessSync(file);
         return true;
       } catch (e) {
         return false;
@@ -7034,7 +7034,7 @@ var require_util2 = __commonJS({
         return false;
       }
       try {
-        var stat = fs12.statSync(file);
+        var stat = fs14.statSync(file);
         return stat && typeof stat.isFile === "function" && stat.isFile();
       } catch (e) {
         return false;
@@ -7054,7 +7054,7 @@ var require_win32 = __commonJS({
   "node_modules/chrome-finder/lib/win32.js"(exports2, module2) {
     "use strict";
     init_cjs_shims();
-    var path12 = require("path");
+    var path14 = require("path");
     var { canAccess } = require_util2();
     function win32() {
       const installations = [];
@@ -7068,7 +7068,7 @@ var require_win32 = __commonJS({
       const prefixes = [process.env.LOCALAPPDATA, process.env.PROGRAMFILES, process.env["PROGRAMFILES(X86)"]];
       prefixes.forEach((prefix) => suffixes.forEach((suffix) => {
         if (prefix) {
-          const chromePath = path12.join(prefix, suffix);
+          const chromePath = path14.join(prefix, suffix);
           if (canAccess(chromePath)) {
             installations.push(chromePath);
           }
@@ -7086,7 +7086,7 @@ var require_darwin = __commonJS({
     "use strict";
     init_cjs_shims();
     var { execSync: execSync2 } = require("child_process");
-    var path12 = require("path");
+    var path14 = require("path");
     var { canAccess, newLineRegex, sort } = require_util2();
     function darwin() {
       const suffixes = ["/Contents/MacOS/Google Chrome Canary", "/Contents/MacOS/Google Chrome", "/Contents/MacOS/Chromium"];
@@ -7096,7 +7096,7 @@ var require_darwin = __commonJS({
     ${LSREGISTER} -dump | grep -E -i -o '/.+(google chrome( canary)?|chromium)\\.app(\\s|$)' | grep -E -v 'Caches|TimeMachine|Temporary|/Volumes|\\.Trash'
   `).toString().split(newLineRegex).forEach((inst) => {
         suffixes.forEach((suffix) => {
-          const execPath = path12.join(inst.trim(), suffix);
+          const execPath = path14.join(inst.trim(), suffix);
           if (canAccess(execPath)) {
             installations.push(execPath);
           }
@@ -7125,8 +7125,8 @@ var require_linux = __commonJS({
     "use strict";
     init_cjs_shims();
     var { execSync: execSync2, execFileSync: execFileSync2 } = require("child_process");
-    var path12 = require("path");
-    var fs12 = require("fs");
+    var path14 = require("path");
+    var fs14 = require("fs");
     var { canAccess, sort, isExecutable, newLineRegex } = require_util2();
     function findChromeExecutablesForLinuxDesktop(folder) {
       const argumentsRegex = /(^[^ ]+).*/;
@@ -7143,7 +7143,7 @@ var require_linux = __commonJS({
     function linux() {
       let installations = [];
       const desktopInstallationFolders = [
-        path12.join(require("os").homedir(), ".local/share/applications/"),
+        path14.join(require("os").homedir(), ".local/share/applications/"),
         "/usr/share/applications/"
       ];
       desktopInstallationFolders.forEach((folder) => {
@@ -7169,7 +7169,7 @@ var require_linux = __commonJS({
         ].map((possiblePath) => {
           try {
             const chromePathToTest = possiblePath + "/" + executable;
-            if (fs12.existsSync(chromePathToTest) && canAccess(chromePathToTest) && isExecutable(chromePathToTest)) {
+            if (fs14.existsSync(chromePathToTest) && canAccess(chromePathToTest) && isExecutable(chromePathToTest)) {
               installations.push(chromePathToTest);
               return chromePathToTest;
             }
@@ -7236,7 +7236,7 @@ var require_lib2 = __commonJS({
 });
 
 // src/pdf/BrowserManager.ts
-var import_child_process, import_fs3, BrowserManager;
+var import_child_process, import_fs3, LAUNCH_ARGS, BrowserManager;
 var init_BrowserManager = __esm({
   "src/pdf/BrowserManager.ts"() {
     "use strict";
@@ -7244,21 +7244,26 @@ var init_BrowserManager = __esm({
     import_child_process = require("child_process");
     import_fs3 = __toESM(require("fs"));
     init_logger();
+    LAUNCH_ARGS = [
+      "--no-sandbox",
+      "--disable-setuid-sandbox",
+      "--disable-dev-shm-usage",
+      "--disable-gpu",
+      // Chrome's new headless mode (--headless=new, the only mode left in
+      // Chrome 132+) briefly uncloaks a blank window on some Windows/GPU
+      // combinations. Parking the window far off-screen makes that transient
+      // invisible; harmless everywhere else and does not affect PDF output.
+      "--window-position=-32000,-32000"
+    ];
     BrowserManager = class {
       async launch(executablePath) {
         const puppeteer = require("puppeteer-core");
         const chromePath = this.resolveChromePath(executablePath, puppeteer);
         logger.info(`Launching browser: ${chromePath ?? "puppeteer default"}`);
-        const launchArgs = [
-          "--no-sandbox",
-          "--disable-setuid-sandbox",
-          "--disable-dev-shm-usage",
-          "--disable-gpu"
-        ];
         this.browser = await puppeteer.launch({
           executablePath: chromePath,
           headless: true,
-          args: launchArgs
+          args: LAUNCH_ARGS
         });
         const page = await this.browser.newPage();
         return { browser: this.browser, page };
@@ -8297,8 +8302,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path12, errorMaps, issueData } = params;
-      const fullPath = [...path12, ...issueData.path || []];
+      const { data, path: path14, errorMaps, issueData } = params;
+      const fullPath = [...path14, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -8612,11 +8617,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path12, key) {
+      constructor(parent, value, path14, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path12;
+        this._path = path14;
         this._key = key;
       }
       get path() {
@@ -12049,9 +12054,17 @@ var init_schema = __esm({
       // Qualitative floor (not a numeric % — consistent with the match-strength design).
       minStrength: external_exports.enum(["weak", "moderate", "strong"]).default("weak"),
       maxFailuresToAnalyse: external_exports.number().int().min(1).default(500),
-      // Consumed by the Plan 3 feedback collector; inert until then.
       collectUnclassified: external_exports.boolean().default(true),
-      autoUpdateModel: external_exports.boolean().default(true)
+      // What the feedback collector stores (while collectUnclassified is on):
+      // 'blind-spots' = unknown/low-confidence only; 'all' = every model-scored
+      // failure, so wrong-but-confident verdicts can be corrected by labeling.
+      collectScope: external_exports.enum(["blind-spots", "all"]).default("blind-spots"),
+      autoUpdateModel: external_exports.boolean().default(true),
+      // Use the on-device trained model (when present and its evaluation gate passed).
+      localModel: external_exports.boolean().default(true),
+      // Override the local model file location (default ~/.reportforge/model-local.json).
+      // Point at a repo-committed file to share a team-trained model with ephemeral CI.
+      localModelPath: external_exports.string().optional()
     }).default({});
     captureConfigSchema = external_exports.object({
       steps: external_exports.boolean().default(false),
@@ -12152,6 +12165,56 @@ var init_model_bundle = __esm({
   }
 });
 
+// src/analysis/tokenize.ts
+function tokenize(text) {
+  return text.toLowerCase().replace(/https?:\/\/\S+/gi, " URL ").replace(/[^a-zA-Z0-9\s]/g, " ").replace(/\b\d{3,}[a-z]*\b/g, " NUM ").split(/\s+/).filter((t) => t.length > 1);
+}
+var init_tokenize = __esm({
+  "src/analysis/tokenize.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/analysis/NaiveBayesClassifier.ts
+function classify(model, text) {
+  return classifyTokens(model, tokenize(text));
+}
+function classifyTokens(model, tokens) {
+  const vocabTokens = tokens.filter(
+    (tok) => tok.length > 0 && model.labels.some((l) => model.logLikelihoods[l]?.[tok] !== void 0)
+  );
+  if (vocabTokens.length === 0) {
+    return { label: "unknown", margin: 0 };
+  }
+  const scores = {};
+  for (const label of model.labels) {
+    let s = model.priors[label];
+    const oov = Math.log(model.alpha / (model.totals[label] + model.alpha * model.vocabSize));
+    const ll = model.logLikelihoods[label];
+    for (const tok of vocabTokens) {
+      s += ll[tok] ?? oov;
+    }
+    scores[label] = s;
+  }
+  const ranked = Object.entries(scores).sort((a, b) => b[1] - a[1]);
+  const topLog = ranked[0][1];
+  const secondLog = ranked[1]?.[1] ?? topLog;
+  const margin = (topLog - secondLog) / vocabTokens.length;
+  return { label: ranked[0][0], margin };
+}
+function isValidNaiveBayesModel(m) {
+  const x = m;
+  return !!x && Array.isArray(x.labels) && x.labels.length > 0 && typeof x.version === "number" && !!x.priors && !!x.totals && !!x.logLikelihoods && typeof x.vocabSize === "number" && typeof x.alpha === "number";
+}
+var init_NaiveBayesClassifier = __esm({
+  "src/analysis/NaiveBayesClassifier.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_tokenize();
+  }
+});
+
 // src/analysis/ModelStore.ts
 function cacheFile() {
   return testDeps?.cacheFile ?? import_node_path.default.join(import_node_os.default.homedir(), ".reportforge", "model.json");
@@ -12173,10 +12236,6 @@ function verifyModelSignature(modelJson, signatureB64url) {
     return false;
   }
 }
-function schemaValid(m) {
-  const x = m;
-  return !!x && Array.isArray(x.labels) && x.labels.length > 0 && typeof x.version === "number" && !!x.priors && !!x.totals && !!x.logLikelihoods && typeof x.vocabSize === "number" && typeof x.alpha === "number";
-}
 function readCache() {
   try {
     const raw = import_node_fs.default.readFileSync(cacheFile(), "utf8");
@@ -12205,7 +12264,7 @@ function loadModel(autoUpdate) {
   }
   return MODEL;
 }
-var import_node_fs, import_node_os, import_node_path, import_node_crypto, MODEL_SIG_DOMAIN, testDeps;
+var import_node_fs, import_node_os, import_node_path, import_node_crypto, MODEL_SIG_DOMAIN, testDeps, schemaValid;
 var init_ModelStore = __esm({
   "src/analysis/ModelStore.ts"() {
     "use strict";
@@ -12216,62 +12275,114 @@ var init_ModelStore = __esm({
     import_node_crypto = require("crypto");
     init_pubkey_bundle();
     init_model_bundle();
+    init_NaiveBayesClassifier();
     init_logger();
     MODEL_SIG_DOMAIN = "reportforge-model-sig:v1\n";
     testDeps = null;
+    schemaValid = isValidNaiveBayesModel;
   }
 });
 
-// src/analysis/tokenize.ts
-function tokenize(text) {
-  return text.toLowerCase().replace(/https?:\/\/\S+/gi, " URL ").replace(/[^a-zA-Z0-9\s]/g, " ").replace(/\b\d{3,}[a-z]*\b/g, " NUM ").split(/\s+/).filter((t) => t.length > 1);
+// src/analysis/LocalModelStore.ts
+function defaultLocalModelPath() {
+  return testDeps2?.file ?? import_node_path2.default.join(import_node_os2.default.homedir(), ".reportforge", "model-local.json");
 }
-var init_tokenize = __esm({
-  "src/analysis/tokenize.ts"() {
+function loadLocalModel(overridePath) {
+  const file = overridePath ?? defaultLocalModelPath();
+  const explicit = overridePath !== void 0;
+  const reject = (why) => {
+    const msg = `local model at ${file} not used: ${why}`;
+    if (explicit) logger.warn(msg);
+    else logger.debug(msg);
+    return null;
+  };
+  let parsed;
+  try {
+    parsed = JSON.parse(import_node_fs2.default.readFileSync(file, "utf8"));
+  } catch (e) {
+    return explicit ? reject(`unreadable (${e.message})`) : null;
+  }
+  if (parsed.formatVersion !== 1) return reject(`unsupported formatVersion ${String(parsed.formatVersion)}`);
+  if (!isValidNaiveBayesModel(parsed.model)) return reject("embedded model failed schema validation");
+  const meta = parsed.meta;
+  if (!meta || typeof meta.gatePassed !== "boolean") return reject("missing meta");
+  if (!meta.gatePassed) return reject("its evaluation gate did not pass - run train-model after labeling more feedback");
+  if (typeof meta.acceptThreshold !== "number") return reject("gate passed but no calibrated threshold (corrupt meta)");
+  return {
+    model: parsed.model,
+    acceptThreshold: meta.acceptThreshold,
+    strongThreshold: typeof meta.strongThreshold === "number" ? meta.strongThreshold : null,
+    meta
+  };
+}
+function saveLocalModel(fileContents, outPath) {
+  const file = outPath ?? defaultLocalModelPath();
+  import_node_fs2.default.mkdirSync(import_node_path2.default.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  import_node_fs2.default.writeFileSync(tmp, JSON.stringify(fileContents, null, 2), { mode: 384 });
+  import_node_fs2.default.renameSync(tmp, file);
+  return file;
+}
+function readLocalModelFile(overridePath) {
+  try {
+    const parsed = JSON.parse(import_node_fs2.default.readFileSync(overridePath ?? defaultLocalModelPath(), "utf8"));
+    return parsed.formatVersion === 1 && isValidNaiveBayesModel(parsed.model) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+var import_node_fs2, import_node_os2, import_node_path2, testDeps2;
+var init_LocalModelStore = __esm({
+  "src/analysis/LocalModelStore.ts"() {
     "use strict";
     init_cjs_shims();
+    import_node_fs2 = __toESM(require("fs"));
+    import_node_os2 = __toESM(require("os"));
+    import_node_path2 = __toESM(require("path"));
+    init_NaiveBayesClassifier();
+    init_logger();
+    testDeps2 = null;
   }
 });
 
-// src/analysis/NaiveBayesClassifier.ts
-function classify(model, text) {
-  const tokens = tokenize(text);
-  const vocabTokens = tokens.filter(
-    (tok) => model.labels.some((l) => model.logLikelihoods[l]?.[tok] !== void 0)
-  );
-  if (vocabTokens.length === 0) {
-    return { label: "unknown", margin: 0 };
-  }
-  const scores = {};
-  for (const label of model.labels) {
-    let s = model.priors[label];
-    const oov = Math.log(model.alpha / (model.totals[label] + model.alpha * model.vocabSize));
-    const ll = model.logLikelihoods[label];
-    for (const tok of vocabTokens) {
-      s += ll[tok] ?? oov;
-    }
-    scores[label] = s;
-  }
-  const ranked = Object.entries(scores).sort((a, b) => b[1] - a[1]);
-  const topLog = ranked[0][1];
-  const secondLog = ranked[1]?.[1] ?? topLog;
-  const margin = (topLog - secondLog) / vocabTokens.length;
-  return { label: ranked[0][0], margin };
+// src/analysis/redact.ts
+function redactForStorage(raw) {
+  const redacted = raw.replace(URI_RE, " URL ").replace(EMAIL_RE, " EMAIL ").replace(SECRET_RE, " SECRET ").replace(IP_RE, " IP ").replace(WIN_PATH_RE, " PATH ").replace(UNIX_PATH_RE, " PATH ");
+  return tokenize(redacted).join(" ");
 }
-var init_NaiveBayesClassifier = __esm({
-  "src/analysis/NaiveBayesClassifier.ts"() {
+function localInferenceTokens(message) {
+  return redactForStorage(message).split(" ").filter(Boolean);
+}
+var URI_RE, EMAIL_RE, SECRET_RE, IP_RE, WIN_PATH_RE, UNIX_PATH_RE;
+var init_redact = __esm({
+  "src/analysis/redact.ts"() {
     "use strict";
     init_cjs_shims();
     init_tokenize();
+    URI_RE = /[a-z][\w+.-]*:\/\/\S+/gi;
+    EMAIL_RE = /\b[\w.+-]+@[\w.-]+\.\w+\b/g;
+    SECRET_RE = /\b(?=[A-Za-z0-9_+/=-]*[0-9])(?=[A-Za-z0-9_+/=-]*[A-Za-z])[A-Za-z0-9_+/=-]{16,}\b/g;
+    IP_RE = /\b\d{1,3}(?:\.\d{1,3}){3}\b/g;
+    WIN_PATH_RE = /[A-Za-z]:\\[^\s'"]+/g;
+    UNIX_PATH_RE = /(?:\/[\w.-]+){2,}/g;
   }
 });
 
 // src/analysis/constants.ts
-var STRENGTH, STRENGTH_LEVELS, OVERRIDE_MARGIN;
+var CATEGORIES, STRENGTH, STRENGTH_LEVELS, OVERRIDE_MARGIN, LOCAL_TRAINING;
 var init_constants = __esm({
   "src/analysis/constants.ts"() {
     "use strict";
     init_cjs_shims();
+    CATEGORIES = [
+      "assertion",
+      "env-config",
+      "flaky-by-retry",
+      "locator-not-found",
+      "navigation",
+      "network",
+      "timeout"
+    ];
     STRENGTH = {
       unknownMaxMargin: 0.05,
       collectMaxMargin: 0.1,
@@ -12281,6 +12392,23 @@ var init_constants = __esm({
     };
     STRENGTH_LEVELS = ["weak", "moderate", "strong"];
     OVERRIDE_MARGIN = 999;
+    LOCAL_TRAINING = {
+      /** NB priors from fewer docs are noise, and LOOCV estimates below this are junk. */
+      minLabeled: 10,
+      /** A margin needs a runner-up label to exist at all. */
+      minClasses: 2,
+      /** Precision estimated on fewer accepted predictions is noise — refuse to calibrate. */
+      minAccepted: 5,
+      /** The local layer only ANSWERS when its held-out precision at the chosen threshold hits this. */
+      acceptPrecision: 0.9,
+      /** Bar for the local layer to render as 'strong' (else capped at 'moderate'). */
+      strongPrecision: 0.95,
+      /** Below this n, leave-one-out (5-fold folds would be too small to train on). */
+      cvSwitchoverN: 50,
+      folds: 5,
+      /** Fixed PRNG seed — evaluation must be reproducible run-to-run. */
+      seed: 1234
+    };
   }
 });
 
@@ -12301,7 +12429,7 @@ function errorHeader(message) {
   return beforeCallLog.split("\n").filter((line) => !/^\s*[-+]?\s*(?:Expected|Received)\b/i.test(line)).join("\n");
 }
 function isAssertionTimeout(message) {
-  return /Expect "[^"]+" with timeout/.test(message) && /resolved to [1-9]\d* element/.test(message);
+  return /(?:Expect "[^"]+"|expect\.\w+) with timeout/.test(message) && /resolved to [1-9]\d* element/.test(message);
 }
 function isNetwork(message) {
   return /net::ERR_(CONNECTION|NAME_NOT_RESOLVED|INTERNET_DISCONNECTED|SSL|TIMED_OUT|ADDRESS|NETWORK_CHANGED|EMPTY_RESPONSE)|\bECONN(?:REFUSED|RESET)\b|\bENOTFOUND\b|\bEAI_AGAIN\b|getaddrinfo|socket hang up|fetch failed/.test(errorHeader(message));
@@ -12332,26 +12460,37 @@ function topFrame(stack) {
 function representativeMessage(message) {
   return clampWithEllipsis(message.split("\n")[0], MAX_MESSAGE_CHARS);
 }
-function classifyOne(f, model) {
+function classifyOne(f, chain) {
   const frame = topFrame(f.error.stack);
   if (f.retryHistory.some((r) => r.status === "passed")) {
-    return { category: "flaky-by-retry", margin: OVERRIDE_MARGIN, failure: f, frame };
+    return { category: "flaky-by-retry", margin: OVERRIDE_MARGIN, strength: "strong", source: "retry", failure: f, frame };
   }
   for (const [match, category] of MESSAGE_RULES) {
-    if (match(f.error.message)) return { category, margin: OVERRIDE_MARGIN, failure: f, frame };
+    if (match(f.error.message)) {
+      return { category, margin: OVERRIDE_MARGIN, strength: "strong", source: "rule", failure: f, frame };
+    }
   }
-  const { label, margin } = classify(model, classifyInput(f));
-  return { category: label, margin, failure: f, frame };
+  if (chain.local) {
+    const { model, acceptThreshold, strongThreshold } = chain.local;
+    const r = classifyTokens(model, localInferenceTokens(f.error.message));
+    if (r.label !== "unknown" && r.margin >= acceptThreshold) {
+      const strength = strongThreshold !== null && r.margin >= strongThreshold ? "strong" : "moderate";
+      return { category: r.label, margin: r.margin, strength, source: "local", failure: f, frame };
+    }
+  }
+  const { label, margin } = classify(chain.base, classifyInput(f));
+  return { category: label, margin, strength: strengthOf(margin), source: "base", failure: f, frame };
 }
-function classifyAll(failures, model) {
-  return failures.map((f) => classifyOne(f, model));
+function classifyAll(failures, chain) {
+  return failures.map((f) => classifyOne(f, chain));
 }
 function perTestClassifications(classified) {
   return classified.map((c) => ({
     testId: c.failure.testId,
     category: c.category,
     message: representativeMessage(c.failure.error.message),
-    strength: strengthOf(c.margin)
+    strength: c.strength
+    // resolved at classification time, per producing source
   }));
 }
 function clusterClassified(classified) {
@@ -12362,13 +12501,16 @@ function clusterClassified(classified) {
     if (bucket) bucket.push(c);
     else groups.set(key, [c]);
   }
+  const rank = Object.fromEntries(
+    STRENGTH_LEVELS.map((level, i) => [level, i])
+  );
   const clusters = [];
   for (const members of groups.values()) {
-    const margin = Math.max(...members.map((m) => m.margin));
+    const strongest = members.reduce((a, b) => rank[b.strength] > rank[a.strength] ? b : a);
     clusters.push({
       category: members[0].category,
-      strength: strengthOf(margin),
-      margin,
+      strength: strongest.strength,
+      margin: Math.max(...members.map((m) => m.margin)),
       count: members.length,
       tests: members.slice(0, MAX_TESTS_PER_CLUSTER).map((m) => m.failure.testTitle),
       testsTotal: members.length,
@@ -12384,6 +12526,7 @@ var init_FailureClusterer = __esm({
     "use strict";
     init_cjs_shims();
     init_NaiveBayesClassifier();
+    init_redact();
     init_constants();
     init_truncate();
     MAX_TESTS_PER_CLUSTER = 20;
@@ -12399,100 +12542,209 @@ var init_FailureClusterer = __esm({
 
 // src/analysis/feedback-csv.ts
 function parseFeedbackRows(content) {
-  return content.trim().split("\n").slice(1).filter(Boolean).map((line) => {
+  const lines = content.trim().split("\n").filter(Boolean);
+  if (lines.length === 0) return [];
+  const header = lines[0].trim();
+  const isV2 = header === FEEDBACK_HEADER;
+  if (!isV2 && header !== LEGACY_FEEDBACK_HEADER) return [];
+  const minParts = isV2 ? 4 : 3;
+  const rows = [];
+  for (const line of lines.slice(1)) {
     const parts = line.split(",");
-    return { category: parts[0], margin: parts[1], text: parts.slice(2).join(","), raw: line };
-  });
+    if (parts.length < minParts) continue;
+    const row = isV2 ? { category: parts[0], margin: parts[1], label: parts[2], text: parts.slice(3).join(",") } : { category: parts[0], margin: parts[1], label: "", text: parts.slice(2).join(",") };
+    if (row.text.trim().length === 0) continue;
+    rows.push(row);
+  }
+  return rows;
+}
+function serializeFeedbackRow(r) {
+  const label = r.label.replace(/[,\r\n]/g, "").trim();
+  return `${r.category},${r.margin},${label},${r.text}`;
 }
 function feedbackIdentity(category, text) {
   return `${category} ${text}`;
 }
-var FEEDBACK_HEADER;
+function isTrainableLabel(label) {
+  return CATEGORIES.includes(label);
+}
+var FEEDBACK_HEADER, LEGACY_FEEDBACK_HEADER;
 var init_feedback_csv = __esm({
   "src/analysis/feedback-csv.ts"() {
     "use strict";
     init_cjs_shims();
-    FEEDBACK_HEADER = "category,margin,text";
+    init_constants();
+    FEEDBACK_HEADER = "category,margin,label,text";
+    LEGACY_FEEDBACK_HEADER = "category,margin,text";
   }
 });
 
-// src/analysis/UnclassifiedCollector.ts
-function redactForStorage(raw) {
-  const redacted = raw.replace(URI_RE, " URL ").replace(EMAIL_RE, " EMAIL ").replace(SECRET_RE, " SECRET ").replace(IP_RE, " IP ").replace(WIN_PATH_RE, " PATH ").replace(UNIX_PATH_RE, " PATH ");
-  return tokenize(redacted).join(" ");
+// src/analysis/FeedbackStore.ts
+function readAllFeedback(home = import_node_os3.default.homedir()) {
+  const root = import_node_path3.default.join(home, ".reportforge");
+  if (!import_node_fs3.default.existsSync(root)) return [];
+  const out = [];
+  for (const entry of import_node_fs3.default.readdirSync(root).sort()) {
+    const dir = import_node_path3.default.join(root, entry);
+    const file = import_node_path3.default.join(dir, FILENAME);
+    if (!import_node_fs3.default.existsSync(file)) continue;
+    out.push({
+      file,
+      rows: parseFeedbackRows(import_node_fs3.default.readFileSync(file, "utf8")),
+      project: readProjectMarker(dir)
+    });
+  }
+  return out;
+}
+function readProjectMarker(projectDir) {
+  try {
+    const parsed = JSON.parse(import_node_fs3.default.readFileSync(import_node_path3.default.join(projectDir, MARKER_FILENAME), "utf8"));
+    return typeof parsed?.cwd === "string" ? parsed : null;
+  } catch {
+    return null;
+  }
 }
-function shouldCollect(c) {
-  return c.category === "unknown" || c.margin <= STRENGTH.collectMaxMargin;
+function writeProjectMarker(projectDir, marker) {
+  try {
+    atomicWrite(import_node_path3.default.join(projectDir, MARKER_FILENAME), JSON.stringify(marker));
+  } catch {
+  }
+}
+function labeledSamples(files) {
+  const samples = [];
+  let invalidLabelCount = 0;
+  let unlabeledCount = 0;
+  for (const f of files) {
+    for (const r of f.rows) {
+      if (r.label === "") {
+        unlabeledCount++;
+        continue;
+      }
+      if (!isTrainableLabel(r.label)) {
+        invalidLabelCount++;
+        continue;
+      }
+      const tokens = r.text.split(" ").filter(Boolean);
+      if (tokens.length === 0) continue;
+      samples.push({ label: r.label, tokens });
+    }
+  }
+  return { samples, invalidLabelCount, unlabeledCount };
+}
+function rewriteFeedbackFile(file, rows) {
+  const body = rows.map(serializeFeedbackRow).join("\n");
+  atomicWrite(file, `${FEEDBACK_HEADER}
+${body}${body ? "\n" : ""}`);
+}
+function atomicWrite(file, content) {
+  import_node_fs3.default.mkdirSync(import_node_path3.default.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  import_node_fs3.default.writeFileSync(tmp, content, "utf8");
+  import_node_fs3.default.renameSync(tmp, file);
+}
+var import_node_fs3, import_node_os3, import_node_path3, FILENAME, MARKER_FILENAME;
+var init_FeedbackStore = __esm({
+  "src/analysis/FeedbackStore.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_fs3 = __toESM(require("fs"));
+    import_node_os3 = __toESM(require("os"));
+    import_node_path3 = __toESM(require("path"));
+    init_feedback_csv();
+    FILENAME = "unclassified.csv";
+    MARKER_FILENAME = "project.json";
+  }
+});
+
+// src/analysis/UnclassifiedCollector.ts
+function shouldCollect(c, scope) {
+  if (c.source !== "base") return false;
+  if (c.category === "unknown" || c.margin <= STRENGTH.collectMaxMargin) return true;
+  return scope === "all";
 }
 function tildeify(p) {
-  const home = import_node_os2.default.homedir();
+  const home = import_node_os4.default.homedir();
   return p.startsWith(home) ? `~${p.slice(home.length)}` : p;
 }
-function collectUnclassified(classified, projectDir) {
-  const rows = classified.filter(shouldCollect).map((c) => ({ text: redactForStorage(c.failure.error.message), category: c.category, margin: c.margin })).filter((r) => r.text.length > 0);
+function collectUnclassified(classified, projectDir, opts = {}) {
+  const scope = opts.scope ?? "blind-spots";
+  const rows = classified.filter((c) => shouldCollect(c, scope)).map((c) => ({ text: redactForStorage(c.failure.error.message), category: c.category, margin: c.margin })).filter((r) => r.text.length > 0);
   if (rows.length === 0) return;
-  const file = import_node_path2.default.join(projectDir, FILENAME);
-  const firstTime = !import_node_fs2.default.existsSync(file);
+  const file = import_node_path4.default.join(projectDir, FILENAME2);
+  const firstTime = !import_node_fs4.default.existsSync(file);
   const byIdentity = /* @__PURE__ */ new Map();
   if (!firstTime) {
-    for (const r of parseFeedbackRows(import_node_fs2.default.readFileSync(file, "utf8"))) {
-      byIdentity.set(feedbackIdentity(r.category, r.text), r.raw);
+    for (const r of parseFeedbackRows(import_node_fs4.default.readFileSync(file, "utf8"))) {
+      byIdentity.set(feedbackIdentity(r.category, r.text), r);
     }
   }
-  let added = false;
   for (const r of rows) {
     const id = feedbackIdentity(r.category, r.text);
+    const label = byIdentity.get(id)?.label ?? "";
     byIdentity.delete(id);
-    byIdentity.set(id, `${r.category},${r.margin},${r.text}`);
-    added = true;
-  }
-  if (!added) return;
-  const all = [...byIdentity.values()].slice(-MAX_ROWS);
-  import_node_fs2.default.mkdirSync(projectDir, { recursive: true });
-  import_node_fs2.default.writeFileSync(file, `${FEEDBACK_HEADER}
-${all.join("\n")}
-`, "utf8");
+    byIdentity.set(id, { category: r.category, margin: String(r.margin), label, text: r.text });
+  }
+  const all = evictOldestUnlabeledFirst([...byIdentity.values()], MAX_ROWS);
+  import_node_fs4.default.mkdirSync(projectDir, { recursive: true });
+  rewriteFeedbackFile(file, all);
+  if (opts.project) {
+    writeProjectMarker(projectDir, { cwd: opts.project.cwd, outputFile: opts.project.outputFile, updatedAt: Date.now() });
+  }
   if (firstTime) {
     logger.info(
       `Unrecognized failures collected locally at ${tildeify(file)} to improve offline classification. Local only - never sent anywhere. Disable: failureAnalysis.collectUnclassified=false`
     );
   }
 }
-var import_node_fs2, import_node_os2, import_node_path2, MAX_ROWS, FILENAME, URI_RE, EMAIL_RE, SECRET_RE, IP_RE, WIN_PATH_RE, UNIX_PATH_RE;
+function evictOldestUnlabeledFirst(rows, max) {
+  const excess = rows.length - max;
+  if (excess <= 0) return rows;
+  let unlabeledToDrop = Math.min(excess, rows.filter((r) => r.label === "").length);
+  let labeledToDrop = excess - unlabeledToDrop;
+  const out = [];
+  for (const r of rows) {
+    if (r.label === "" && unlabeledToDrop > 0) {
+      unlabeledToDrop--;
+      continue;
+    }
+    if (r.label !== "" && labeledToDrop > 0) {
+      labeledToDrop--;
+      continue;
+    }
+    out.push(r);
+  }
+  return out;
+}
+var import_node_fs4, import_node_os4, import_node_path4, MAX_ROWS, FILENAME2;
 var init_UnclassifiedCollector = __esm({
   "src/analysis/UnclassifiedCollector.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_fs2 = __toESM(require("fs"));
-    import_node_os2 = __toESM(require("os"));
-    import_node_path2 = __toESM(require("path"));
-    init_tokenize();
+    import_node_fs4 = __toESM(require("fs"));
+    import_node_os4 = __toESM(require("os"));
+    import_node_path4 = __toESM(require("path"));
     init_constants();
     init_feedback_csv();
+    init_redact();
+    init_FeedbackStore();
     init_logger();
     MAX_ROWS = 500;
-    FILENAME = "unclassified.csv";
-    URI_RE = /[a-z][\w+.-]*:\/\/\S+/gi;
-    EMAIL_RE = /\b[\w.+-]+@[\w.-]+\.\w+\b/g;
-    SECRET_RE = /\b(?=[A-Za-z0-9_+/=-]*[0-9])(?=[A-Za-z0-9_+/=-]*[A-Za-z])[A-Za-z0-9_+/=-]{16,}\b/g;
-    IP_RE = /\b\d{1,3}(?:\.\d{1,3}){3}\b/g;
-    WIN_PATH_RE = /[A-Za-z]:\\[^\s'"]+/g;
-    UNIX_PATH_RE = /(?:\/[\w.-]+){2,}/g;
+    FILENAME2 = "unclassified.csv";
   }
 });
 
 // src/utils/paths.ts
 function resolveProjectDir(options, cwd) {
   const projectKey = import_node_crypto2.default.createHash("sha256").update(cwd + (options.outputFile ?? "")).digest("hex").slice(0, 8);
-  return import_node_path3.default.join(import_node_os3.default.homedir(), ".reportforge", projectKey);
+  return import_node_path5.default.join(import_node_os5.default.homedir(), ".reportforge", projectKey);
 }
-var import_node_os3, import_node_path3, import_node_crypto2;
+var import_node_os5, import_node_path5, import_node_crypto2;
 var init_paths = __esm({
   "src/utils/paths.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_os3 = __toESM(require("os"));
-    import_node_path3 = __toESM(require("path"));
+    import_node_os5 = __toESM(require("os"));
+    import_node_path5 = __toESM(require("path"));
     import_node_crypto2 = __toESM(require("crypto"));
   }
 });
@@ -12525,27 +12777,49 @@ function runFailureAnalysis(reportData, options, cwd) {
   if (reportData.stats.failed === 0 || !fa.enabled) return;
   const cap = fa.maxFailuresToAnalyse;
   const analysed = reportData.failures.slice(0, cap);
-  const model = loadModel(fa.autoUpdateModel);
-  const classified = classifyAll(analysed, model);
+  const base = loadModel(fa.autoUpdateModel);
+  const local = fa.localModel ? loadLocalModel(fa.localModelPath) ?? void 0 : void 0;
+  if (local) {
+    logger.debug(
+      `local model active (trained ${local.meta.trainedAt}, ${local.meta.labeledCount} labeled rows, accept margin >= ${local.acceptThreshold})`
+    );
+    if (local.meta.baseVersionAtEval !== base.version) {
+      logger.debug(
+        `local model was gate-checked against base v${local.meta.baseVersionAtEval} but base v${base.version} is active - re-run train-model to re-validate against the current base`
+      );
+    }
+  }
+  const classified = classifyAll(analysed, { base, local });
+  logger.debug(`failure analysis: ${classified.length} classified - ${sourceTally(classified)}`);
   reportData.classifications = perTestClassifications(classified);
   if (templatesConsumeAnalysis(options)) {
     reportData.analysis = analyseClassified(classified, reportData.failures.length, fa);
   }
   if (fa.collectUnclassified) {
-    collectUnclassified(classified, resolveProjectDir(options, cwd));
+    collectUnclassified(classified, resolveProjectDir(options, cwd), {
+      scope: fa.collectScope,
+      project: { cwd, outputFile: options.outputFile }
+    });
   }
 }
+function sourceTally(classified) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const c of classified) counts.set(c.source, (counts.get(c.source) ?? 0) + 1);
+  return ["rule", "retry", "local", "base"].filter((s) => counts.has(s)).map((s) => `${counts.get(s)} ${s}`).join(" / ");
+}
 var DEFAULTS, STRENGTH_RANK;
 var init_analysis = __esm({
   "src/analysis/index.ts"() {
     "use strict";
     init_cjs_shims();
     init_ModelStore();
+    init_LocalModelStore();
     init_FailureClusterer();
     init_SummaryWriter();
     init_constants();
     init_UnclassifiedCollector();
     init_paths();
+    init_logger();
     DEFAULTS = { maxClusters: 10, minStrength: "weak", maxFailuresToAnalyse: 500 };
     STRENGTH_RANK = Object.fromEntries(
       STRENGTH_LEVELS.map((level, i) => [level, i])
@@ -12577,7 +12851,7 @@ async function run() {
   console.log(`  Template : ${template}`);
   console.log(`  Output   : ${outputFile}`);
   const reportData = buildDemoReportData(template);
-  const options = parseOptions({ template, outputFile, failureAnalysis: { collectUnclassified: false } });
+  const options = parseOptions({ template, outputFile, failureAnalysis: { collectUnclassified: false, localModel: false } });
   const generator = new PdfGenerator();
   runFailureAnalysis(reportData, options, process.cwd());
   reportData.briefSentence = buildBriefSentence(reportData.stats, reportData.analysis, reportData.charts.trend);
@@ -12641,22 +12915,12 @@ __export(export_feedback_exports, {
   exportFeedbackCli: () => exportFeedbackCli
 });
 function exportFeedback(deps = {}) {
-  const home = deps.home ?? import_node_os4.default.homedir();
+  const home = deps.home ?? import_node_os6.default.homedir();
   const cwd = deps.cwd ?? process.cwd();
-  const root = import_node_path4.default.join(home, ".reportforge");
-  const rows = [];
-  if (import_node_fs3.default.existsSync(root)) {
-    for (const entry of import_node_fs3.default.readdirSync(root)) {
-      const file = import_node_path4.default.join(root, entry, "unclassified.csv");
-      if (!import_node_fs3.default.existsSync(file)) continue;
-      for (const r of parseFeedbackRows(import_node_fs3.default.readFileSync(file, "utf8"))) {
-        rows.push(r.raw);
-      }
-    }
-  }
+  const rows = readAllFeedback(home).flatMap((f) => f.rows.map(serializeFeedbackRow));
   if (rows.length === 0) return { rowCount: 0, outFile: null };
-  const outFile = import_node_path4.default.join(cwd, "reportforge-feedback.csv");
-  import_node_fs3.default.writeFileSync(outFile, `${FEEDBACK_HEADER}
+  const outFile = import_node_path6.default.join(cwd, "reportforge-feedback.csv");
+  import_node_fs5.default.writeFileSync(outFile, `${FEEDBACK_HEADER}
 ${rows.join("\n")}
 `, "utf8");
   return { rowCount: rows.length, outFile };
@@ -12673,15 +12937,558 @@ Review it before sharing; there is no upload.
     );
   }
 }
-var import_node_fs3, import_node_os4, import_node_path4;
+var import_node_fs5, import_node_os6, import_node_path6;
 var init_export_feedback = __esm({
   "src/cli/export-feedback.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_fs3 = __toESM(require("fs"));
-    import_node_os4 = __toESM(require("os"));
-    import_node_path4 = __toESM(require("path"));
+    import_node_fs5 = __toESM(require("fs"));
+    import_node_os6 = __toESM(require("os"));
+    import_node_path6 = __toESM(require("path"));
     init_feedback_csv();
+    init_FeedbackStore();
+  }
+});
+
+// src/cli/label-feedback.ts
+var label_feedback_exports = {};
+__export(label_feedback_exports, {
+  labelFeedback: () => labelFeedback,
+  labelFeedbackCli: () => labelFeedbackCli
+});
+async function labelFeedback(deps) {
+  const { io } = deps;
+  if (!io.isTTY) {
+    io.write(`${nonInteractiveHelp()}
+`);
+    return { labeled: 0, skipped: 0, remaining: countUnlabeled(deps.home), nonInteractive: true };
+  }
+  const files = readAllFeedback(deps.home ?? import_node_os7.default.homedir());
+  const menu = CATEGORIES.map((c, i) => `  ${i + 1}) ${c}`).join("\n");
+  let labeled = 0;
+  let skipped = 0;
+  let quit = false;
+  io.write(`${CONVENTIONS}
+
+`);
+  for (const f of files) {
+    if (quit) break;
+    for (let i = 0; i < f.rows.length && !quit; i++) {
+      const row = f.rows[i];
+      if (row.label !== "") continue;
+      io.write(
+        `
+project: ${f.project?.cwd ?? "(unknown - marker written on next run)"}
+guess:   ${row.category} @ margin ${row.margin}
+tokens:  ${row.text}
+${menu}
+  s) skip   q) quit
+`
+      );
+      for (; ; ) {
+        const answer = (await io.question("label> ")).trim().toLowerCase();
+        if (answer === "q") {
+          quit = true;
+          break;
+        }
+        if (answer === "s") {
+          skipped++;
+          break;
+        }
+        const idx = Number.parseInt(answer, 10) - 1;
+        if (Number.isInteger(idx) && idx >= 0 && idx < CATEGORIES.length) {
+          row.label = CATEGORIES[idx];
+          rewriteFeedbackFile(f.file, f.rows);
+          labeled++;
+          break;
+        }
+        io.write(`  enter 1-${CATEGORIES.length}, s, or q
+`);
+      }
+    }
+  }
+  const remaining = files.flatMap((f) => f.rows).filter((r) => r.label === "").length;
+  io.write(
+    `
+labeled ${labeled}, skipped ${skipped}, ${remaining} still unlabeled.
+` + (labeled > 0 ? "next: npx @reportforge/playwright-pdf train-model\n" : "")
+  );
+  return { labeled, skipped, remaining, nonInteractive: false };
+}
+function countUnlabeled(home) {
+  return readAllFeedback(home ?? import_node_os7.default.homedir()).flatMap((f) => f.rows).filter((r) => r.label === "").length;
+}
+async function labelFeedbackCli() {
+  const { createInterface } = await import("readline/promises");
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const isTTY = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const io = {
+    question: (p) => rl.question(p),
+    // Interactive chatter → stdout; the non-interactive help is an ERROR message → stderr.
+    write: (s) => void (isTTY ? process.stdout : process.stderr).write(s),
+    isTTY
+  };
+  try {
+    const res = await labelFeedback({ io });
+    if (res.nonInteractive) process.exitCode = 1;
+  } finally {
+    rl.close();
+  }
+}
+var import_node_os7, CONVENTIONS, nonInteractiveHelp;
+var init_label_feedback = __esm({
+  "src/cli/label-feedback.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_os7 = __toESM(require("os"));
+    init_FeedbackStore();
+    init_constants();
+    CONVENTIONS = [
+      "Labeling conventions:",
+      '  - a timed-out page.goto / "Navigation timeout exceeded" is a TIMEOUT (navigation = aborted/interrupted/crashed, not slow)',
+      '  - "Test timeout ... waiting for locator" is a TIMEOUT when the element existed but the test clock ran out,',
+      "    and LOCATOR-NOT-FOUND when the element demonstrably never existed (resolved to 0 / no such element)",
+      "  - skip anything you are not sure about - a wrong label is worse than no label"
+    ].join("\n");
+    nonInteractiveHelp = () => [
+      "label-feedback needs an interactive terminal (TTY) - run it directly, not through a pipe or CI.",
+      `Hand-edit alternative: open ~/.reportforge/<project>/unclassified.csv and fill the empty 'label'`,
+      `column with one of: ${CATEGORIES.join(" | ")}`,
+      "Then run: npx @reportforge/playwright-pdf train-model"
+    ].join("\n");
+  }
+});
+
+// src/analysis/LocalTrainer.ts
+function trainNaiveBayes(samples, alpha = 1) {
+  if (samples.length === 0) throw new Error("trainNaiveBayes: no samples");
+  const labels = [...new Set(samples.map((s) => s.label))].sort();
+  const counts = new Map(labels.map((l) => [l, /* @__PURE__ */ new Map()]));
+  const totals = Object.fromEntries(labels.map((l) => [l, 0]));
+  const labelDocs = Object.fromEntries(labels.map((l) => [l, 0]));
+  const vocab = /* @__PURE__ */ new Set();
+  for (const { label, tokens } of samples) {
+    labelDocs[label]++;
+    const c = counts.get(label);
+    for (const tok of tokens) {
+      c.set(tok, (c.get(tok) ?? 0) + 1);
+      totals[label]++;
+      vocab.add(tok);
+    }
+  }
+  const n = samples.length;
+  const vocabSize = vocab.size;
+  const priors = {};
+  const logLikelihoods = {};
+  for (const l of labels) {
+    priors[l] = Math.log(labelDocs[l] / n);
+    const ll = {};
+    for (const [tok, c] of counts.get(l)) {
+      ll[tok] = Math.log((c + alpha) / (totals[l] + alpha * vocabSize));
+    }
+    logLikelihoods[l] = ll;
+  }
+  return {
+    labels,
+    priors,
+    logLikelihoods,
+    totals,
+    vocabSize,
+    alpha,
+    version: 0,
+    playwrightVersion: "local"
+  };
+}
+var init_LocalTrainer = __esm({
+  "src/analysis/LocalTrainer.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/analysis/LocalEvaluator.ts
+function evaluateChain(samples, base, opts = {}) {
+  const seed = opts.seed ?? LOCAL_TRAINING.seed;
+  const method = samples.length < LOCAL_TRAINING.cvSwitchoverN ? "loocv" : "stratified-5fold";
+  const folds = method === "loocv" ? samples.map((_, i) => i) : stratifiedFolds(samples, LOCAL_TRAINING.folds, seed);
+  const foldCount = method === "loocv" ? samples.length : LOCAL_TRAINING.folds;
+  const oof = samples.map((s) => ({
+    trueLabel: s.label,
+    base: pick(classifyTokens(base, s.tokens)),
+    local: { label: "unknown", margin: 0 }
+    // filled below
+  }));
+  for (let k = 0; k < foldCount; k++) {
+    const trainRows = samples.filter((_, i) => folds[i] !== k);
+    if (trainRows.length === 0) continue;
+    const foldModel = trainNaiveBayes(trainRows);
+    samples.forEach((s, i) => {
+      if (folds[i] === k) oof[i].local = pick(classifyTokens(foldModel, s.tokens));
+    });
+  }
+  const reasons = [];
+  const acceptThreshold = calibrate(oof, LOCAL_TRAINING.acceptPrecision);
+  const strongThreshold = acceptThreshold === null ? null : calibrate(oof, LOCAL_TRAINING.strongPrecision, acceptThreshold);
+  const classes = [...new Set(samples.map((s) => s.label))].sort();
+  const baseMetrics = computeMetrics(oof.map((p) => ({ trueLabel: p.trueLabel, pred: p.base.label })), classes);
+  const chainMetrics = computeMetrics(
+    oof.map((p) => ({
+      trueLabel: p.trueLabel,
+      pred: acceptThreshold !== null && p.local.label !== "unknown" && p.local.margin >= acceptThreshold ? p.local.label : p.base.label
+    })),
+    classes
+  );
+  let gatePassed = false;
+  if (acceptThreshold === null) {
+    reasons.push(
+      `gate FAILED: no margin threshold reaches ${LOCAL_TRAINING.acceptPrecision * 100}% precision with >= ${LOCAL_TRAINING.minAccepted} accepted held-out predictions - the local model is never confident enough to accept safely`
+    );
+  } else if (chainMetrics.macroF1 <= baseMetrics.macroF1) {
+    reasons.push(
+      `gate FAILED: chain macro-F1 ${fmt(chainMetrics.macroF1)} does not beat base ${fmt(baseMetrics.macroF1)} (tie keeps the champion)`
+    );
+  } else {
+    gatePassed = true;
+    reasons.push(
+      `gate passed: chain macro-F1 ${fmt(chainMetrics.macroF1)} > base ${fmt(baseMetrics.macroF1)}; the local layer answers only above its calibrated margin threshold` + (strongThreshold !== null ? "" : " and never renders 'strong'")
+    );
+  }
+  return {
+    method,
+    n: samples.length,
+    classes,
+    base: baseMetrics,
+    chain: chainMetrics,
+    acceptThreshold,
+    strongThreshold,
+    gatePassed,
+    reasons,
+    oofLocal: oof.map((p) => p.local)
+  };
+}
+function transferThresholds(result, samples, finalModel) {
+  const finalMarginsOver = (oofThreshold) => result.oofLocal.map((p, i) => ({ p, i })).filter(({ p }) => p.label !== "unknown" && p.margin >= oofThreshold).map(({ i }) => classifyTokens(finalModel, samples[i].tokens)).filter((r) => r.label !== "unknown").map((r) => r.margin);
+  if (result.acceptThreshold === null) return { acceptThreshold: null, strongThreshold: null };
+  const accept = finalMarginsOver(result.acceptThreshold);
+  if (accept.length === 0) return { acceptThreshold: null, strongThreshold: null };
+  const acceptThreshold = Math.min(...accept);
+  if (result.strongThreshold === null) return { acceptThreshold, strongThreshold: null };
+  const strong = finalMarginsOver(result.strongThreshold);
+  return {
+    acceptThreshold,
+    // 'strong' must never be easier to reach than acceptance itself.
+    strongThreshold: strong.length === 0 ? null : Math.max(Math.min(...strong), acceptThreshold)
+  };
+}
+function calibrate(oof, target, atLeast = -Infinity) {
+  const scored = oof.filter((p) => p.local.label !== "unknown");
+  const candidates = [...new Set(scored.map((p) => p.local.margin))].filter((t) => t >= atLeast).sort((a, b) => a - b);
+  for (const t of candidates) {
+    const accepted = scored.filter((p) => p.local.margin >= t);
+    if (accepted.length < LOCAL_TRAINING.minAccepted) break;
+    const correct = accepted.filter((p) => p.local.label === p.trueLabel).length;
+    if (correct / accepted.length >= target) return t;
+  }
+  return null;
+}
+function computeMetrics(preds, classes) {
+  var _a;
+  const confusion = {};
+  for (const p of preds) {
+    (confusion[_a = p.trueLabel] ?? (confusion[_a] = {}))[p.pred] = (confusion[p.trueLabel][p.pred] ?? 0) + 1;
+  }
+  const perClass = {};
+  let f1Sum = 0;
+  for (const c of classes) {
+    const tp = preds.filter((p) => p.trueLabel === c && p.pred === c).length;
+    const fp = preds.filter((p) => p.trueLabel !== c && p.pred === c).length;
+    const fn = preds.filter((p) => p.trueLabel === c && p.pred !== c).length;
+    const precision = tp + fp === 0 ? 0 : tp / (tp + fp);
+    const recall = tp + fn === 0 ? 0 : tp / (tp + fn);
+    const f1 = precision + recall === 0 ? 0 : 2 * precision * recall / (precision + recall);
+    perClass[c] = { precision, recall, f1, support: tp + fn };
+    f1Sum += f1;
+  }
+  return {
+    accuracy: preds.length === 0 ? 0 : preds.filter((p) => p.pred === p.trueLabel).length / preds.length,
+    macroF1: classes.length === 0 ? 0 : f1Sum / classes.length,
+    perClass,
+    confusion
+  };
+}
+function stratifiedFolds(samples, folds, seed) {
+  const rng = mulberry32(seed);
+  const byLabel = /* @__PURE__ */ new Map();
+  samples.forEach((s, i) => {
+    const arr = byLabel.get(s.label);
+    if (arr) arr.push(i);
+    else byLabel.set(s.label, [i]);
+  });
+  const assignment = new Array(samples.length);
+  for (const label of [...byLabel.keys()].sort()) {
+    const indices = shuffle(byLabel.get(label), rng);
+    indices.forEach((rowIdx, j) => {
+      assignment[rowIdx] = j % folds;
+    });
+  }
+  return assignment;
+}
+function shuffle(arr, rng) {
+  const a = [...arr];
+  for (let i = a.length - 1; i > 0; i--) {
+    const j = Math.floor(rng() * (i + 1));
+    [a[i], a[j]] = [a[j], a[i]];
+  }
+  return a;
+}
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a |= 0;
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+var pick, fmt;
+var init_LocalEvaluator = __esm({
+  "src/analysis/LocalEvaluator.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_NaiveBayesClassifier();
+    init_LocalTrainer();
+    init_constants();
+    pick = (r) => ({ label: r.label, margin: r.margin });
+    fmt = (x) => x.toFixed(3);
+  }
+});
+
+// src/cli/model-cli-shared.ts
+function gatherSamples(deps = {}) {
+  const home = deps.home ?? import_node_os8.default.homedir();
+  const cwd = deps.cwd ?? process.cwd();
+  let files = readAllFeedback(home);
+  const warnings = [];
+  if (deps.projectOnly) {
+    const unmarked = files.filter((f) => f.project === null).length;
+    files = files.filter((f) => f.project?.cwd === cwd);
+    if (unmarked > 0) {
+      warnings.push(
+        `${unmarked} feedback dir(s) have no project marker yet (written on the next reporter run) - --project cannot match them`
+      );
+    }
+  }
+  const { samples, invalidLabelCount, unlabeledCount } = labeledSamples(files);
+  if (invalidLabelCount > 0) {
+    warnings.push(
+      `${invalidLabelCount} row(s) have unrecognized labels and were skipped (valid: ${CATEGORIES.join(", ")})`
+    );
+  }
+  if (unlabeledCount > 0) {
+    warnings.push(`${unlabeledCount} collected row(s) are still unlabeled - label them via label-feedback`);
+  }
+  const classes = new Set(samples.map((s) => s.label));
+  let refusal = null;
+  if (samples.length < LOCAL_TRAINING.minLabeled || classes.size < LOCAL_TRAINING.minClasses) {
+    const tally = [...classes].sort().map((c) => `${c}: ${samples.filter((s) => s.label === c).length}`).join(", ") || "none";
+    refusal = `not enough labeled feedback to train safely: ${samples.length} labeled row(s) across ${classes.size} class(es) (${tally}). Need >= ${LOCAL_TRAINING.minLabeled} rows across >= ${LOCAL_TRAINING.minClasses} classes - run your tests, then label collected failures via: npx @reportforge/playwright-pdf label-feedback`;
+  }
+  return { samples, files, warnings, refusal };
+}
+function formatEvalReport(r, baseVersion) {
+  const lines = [];
+  lines.push(`Evaluation: ${r.method} over ${r.n} labeled row(s), ${r.classes.length} class(es) [base model v${baseVersion}]`);
+  lines.push("");
+  lines.push(pad(["arm", "accuracy", "macro-F1"], [10, 10, 10]));
+  lines.push(pad(["base", pct(r.base.accuracy), num(r.base.macroF1)], [10, 10, 10]));
+  lines.push(pad(["chain", pct(r.chain.accuracy), num(r.chain.macroF1)], [10, 10, 10]));
+  lines.push("");
+  lines.push(pad(["class", "support", "base F1", "chain F1", "chain P", "chain R"], [20, 8, 9, 9, 8, 8]));
+  for (const c of r.classes) {
+    const b = r.base.perClass[c];
+    const ch = r.chain.perClass[c];
+    lines.push(pad([c, String(ch.support), num(b.f1), num(ch.f1), num(ch.precision), num(ch.recall)], [20, 8, 9, 9, 8, 8]));
+  }
+  lines.push("");
+  lines.push(formatConfusion(r.chain, "chain confusion (true -> predicted)"));
+  lines.push("");
+  lines.push(
+    `accept threshold: ${r.acceptThreshold === null ? "none reachable" : num(r.acceptThreshold)}   strong threshold: ${r.strongThreshold === null ? "n/a" : num(r.strongThreshold)}`
+  );
+  for (const reason of r.reasons) lines.push(reason);
+  return lines.join("\n");
+}
+function formatConfusion(m, title) {
+  const predicted = [...new Set(Object.values(m.confusion).flatMap((row) => Object.keys(row)))].sort();
+  const lines = [title, pad(["true \\ pred", ...predicted], [20, ...predicted.map(() => 12)])];
+  for (const t of Object.keys(m.confusion).sort()) {
+    lines.push(pad([t, ...predicted.map((p) => String(m.confusion[t][p] ?? 0))], [20, ...predicted.map(() => 12)]));
+  }
+  return lines.join("\n");
+}
+function pad(cells, widths) {
+  return cells.map((c, i) => c.padEnd(widths[i])).join(" ").trimEnd();
+}
+function flagValue(argv, flag) {
+  const hit = argv.find((a) => a.startsWith(`${flag}=`));
+  return hit?.slice(flag.length + 1);
+}
+function hasFlag(argv, flag) {
+  return argv.includes(flag);
+}
+var import_node_os8, pct, num;
+var init_model_cli_shared = __esm({
+  "src/cli/model-cli-shared.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_os8 = __toESM(require("os"));
+    init_FeedbackStore();
+    init_constants();
+    pct = (x) => `${(x * 100).toFixed(1)}%`;
+    num = (x) => x.toFixed(3);
+  }
+});
+
+// src/cli/train-model.ts
+var train_model_exports = {};
+__export(train_model_exports, {
+  trainModel: () => trainModel,
+  trainModelCli: () => trainModelCli
+});
+function trainModel(deps = {}) {
+  const gathered = gatherSamples(deps);
+  if (gathered.refusal) {
+    return { outcome: "insufficient-data", warnings: gathered.warnings, detail: gathered.refusal };
+  }
+  const base = loadModel(true);
+  const evalResult = evaluateChain(gathered.samples, base);
+  const classes = new Set(gathered.samples.map((s) => s.label));
+  const finalModel = trainNaiveBayes(gathered.samples);
+  const transferred = transferThresholds(evalResult, gathered.samples, finalModel);
+  let gatePassed = evalResult.gatePassed;
+  if (gatePassed && transferred.acceptThreshold === null) {
+    gatePassed = false;
+    evalResult.reasons.push(
+      "gate FAILED after threshold transfer: the OOF-accepted rows are not confidently classified by the full-data model"
+    );
+  }
+  const file = {
+    formatVersion: 1,
+    model: finalModel,
+    meta: {
+      trainedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      labeledCount: gathered.samples.length,
+      classCount: classes.size,
+      baseVersionAtEval: base.version,
+      gatePassed,
+      acceptThreshold: transferred.acceptThreshold,
+      strongThreshold: transferred.strongThreshold,
+      metrics: { method: evalResult.method, base: evalResult.base, chain: evalResult.chain }
+    }
+  };
+  const outFile = saveLocalModel(file, deps.outFile);
+  evalResult.acceptThreshold = transferred.acceptThreshold ?? evalResult.acceptThreshold;
+  evalResult.strongThreshold = transferred.strongThreshold;
+  return {
+    outcome: gatePassed ? "trained" : "gate-failed",
+    evalResult,
+    baseVersion: base.version,
+    outFile,
+    warnings: gathered.warnings,
+    detail: gatePassed ? `local model ACTIVE - saved to ${outFile}` : `local model saved to ${outFile} but INACTIVE (gate failed) - the reporter stays on the base model`
+  };
+}
+function trainModelCli(argv) {
+  const out = (s) => process.stdout.write(`${s}
+`);
+  const outFile = flagValue(argv, "--out");
+  const projectOnly = hasFlag(argv, "--project");
+  if (outFile !== void 0 && !projectOnly) {
+    out(
+      "[reportforge] note: --out without --project trains on feedback from ALL local projects. If this file will be committed to one repo, consider adding --project so other projects\u2019 token statistics do not ride along."
+    );
+  }
+  const res = trainModel({ outFile, projectOnly });
+  for (const w of res.warnings) out(`[reportforge] warn: ${w}`);
+  if (res.outcome === "insufficient-data") {
+    out(`[reportforge] ${res.detail}`);
+    process.exitCode = 1;
+    return;
+  }
+  out("");
+  out(formatEvalReport(res.evalResult, res.baseVersion));
+  out("");
+  out(`[reportforge] ${res.detail}`);
+  if (res.outcome === "trained" && res.outFile === defaultLocalModelPath()) {
+    out("[reportforge] the reporter picks it up automatically on the next run (failureAnalysis.localModel).");
+  }
+  process.exitCode = res.outcome === "trained" ? 0 : 1;
+}
+var init_train_model = __esm({
+  "src/cli/train-model.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_LocalTrainer();
+    init_LocalEvaluator();
+    init_ModelStore();
+    init_LocalModelStore();
+    init_model_cli_shared();
+  }
+});
+
+// src/cli/evaluate-model.ts
+var evaluate_model_exports = {};
+__export(evaluate_model_exports, {
+  evaluateModel: () => evaluateModel,
+  evaluateModelCli: () => evaluateModelCli
+});
+function evaluateModel(deps = {}) {
+  const lines = [];
+  const base = loadModel(true);
+  if (deps.modelPath !== void 0) {
+    const stored = readLocalModelFile(deps.modelPath);
+    if (!stored) {
+      lines.push(`stored model at ${deps.modelPath}: unreadable or invalid`);
+    } else {
+      const m = stored.meta;
+      lines.push(
+        `stored model at ${deps.modelPath}: trained ${m.trainedAt}, ${m.labeledCount} rows / ${m.classCount} classes, gate ${m.gatePassed ? "PASSED" : "FAILED"}, recorded chain macro-F1 ${m.metrics.chain.macroF1.toFixed(3)} vs base ${m.metrics.base.macroF1.toFixed(3)}`
+      );
+      if (m.baseVersionAtEval !== base.version) {
+        lines.push(
+          `warn: that gate was checked against base v${m.baseVersionAtEval}; base v${base.version} is active now - re-run train-model to re-validate`
+        );
+      }
+    }
+    lines.push("");
+  }
+  const gathered = gatherSamples(deps);
+  for (const w of gathered.warnings) lines.push(`warn: ${w}`);
+  if (gathered.refusal) {
+    lines.push(gathered.refusal);
+    return { ok: false, lines };
+  }
+  lines.push(formatEvalReport(evaluateChain(gathered.samples, base), base.version));
+  lines.push("(nothing was written - run train-model to produce/update the artifact)");
+  return { ok: true, lines };
+}
+function evaluateModelCli(argv) {
+  const res = evaluateModel({
+    modelPath: flagValue(argv, "--model"),
+    projectOnly: hasFlag(argv, "--project")
+  });
+  process.stdout.write(res.lines.map((l) => `[reportforge] ${l}`).join("\n") + "\n");
+  process.exitCode = res.ok ? 0 : 1;
+}
+var init_evaluate_model = __esm({
+  "src/cli/evaluate-model.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_LocalEvaluator();
+    init_ModelStore();
+    init_LocalModelStore();
+    init_model_cli_shared();
   }
 });
 
@@ -12699,6 +13506,12 @@ Commands:
                      --template=minimal|detailed|executive   (default: detailed)
                      --output=<path>                          (default: playwright-report/demo-report.pdf)
   export-feedback  Export locally-collected unrecognized failures (tokenized, local-only).
+  label-feedback   Interactively label locally-collected failures for on-device training (local-only).
+  train-model      Train + evaluate a personal classifier layer from your labeled feedback (local-only).
+                     --out=<path>   write the model file elsewhere (default: ~/.reportforge/model-local.json)
+                     --project      train only on feedback from the current directory's project
+  evaluate-model   Compare base vs. base+local on your labeled feedback without writing anything.
+                     --model=<path> also print a stored model file's metadata and metrics
 
 Run "npx @reportforge/playwright-pdf demo" to see the report ReportForge produces.`;
 function pickCommand(arg) {
@@ -12707,6 +13520,12 @@ function pickCommand(arg) {
       return "demo";
     case "export-feedback":
       return "export-feedback";
+    case "label-feedback":
+      return "label-feedback";
+    case "train-model":
+      return "train-model";
+    case "evaluate-model":
+      return "evaluate-model";
     default:
       return "help";
   }
@@ -12740,6 +13559,21 @@ async function main() {
       exportFeedbackCli2();
       return;
     }
+    case "label-feedback": {
+      const { labelFeedbackCli: labelFeedbackCli2 } = await Promise.resolve().then(() => (init_label_feedback(), label_feedback_exports));
+      await labelFeedbackCli2();
+      return;
+    }
+    case "train-model": {
+      const { trainModelCli: trainModelCli2 } = await Promise.resolve().then(() => (init_train_model(), train_model_exports));
+      trainModelCli2(process.argv.slice(3));
+      return;
+    }
+    case "evaluate-model": {
+      const { evaluateModelCli: evaluateModelCli2 } = await Promise.resolve().then(() => (init_evaluate_model(), evaluate_model_exports));
+      evaluateModelCli2(process.argv.slice(3));
+      return;
+    }
     case "help": {
       const { text, stream, code } = helpOutput(arg);
       (stream === "stdout" ? process.stdout : process.stderr).write(text);