@event4u/agent-config 16.1.0 → 16.3.0

package/dist/cli-delegate/{chunk-YUM5KURG.js → chunk-KR6EM23A.js}

@@ -1,8 +1,15 @@
 import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
 import {
-  DeadScopeError,
-  assertScanned
-} from "./chunk-I3EIN2YG.js";
+  LexicalIndex,
+  loadSqliteSync,
+  probeFts5Sync,
+  readUserVersion,
+  stampUserVersion,
+  tokenize
+} from "./chunk-ZBZV2G5R.js";
+import {
+  _classify
+} from "./chunk-JQOM7TTM.js";
 import {
   require_dist
 } from "./chunk-OY53J6II.js";
@@ -12,1102 +19,11 @@ import {
 
 // src/scripts/memory_lookup.ts
 var import_yaml2 = __toESM(require_dist(), 1);
-import * as fs7 from "node:fs";
-import * as path7 from "node:path";
+import * as fs5 from "node:fs";
+import * as path5 from "node:path";
 import process5 from "node:process";
-import { fileURLToPath as fileURLToPath6, pathToFileURL as pathToFileURL4 } from "node:url";
-import { createRequire as createRequire2 } from "node:module";
-
-// src/scripts/lint_hidden_unicode.ts
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
-import { spawnSync } from "node:child_process";
-import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
-
-// src/scripts/_lib/security_lint.ts
-import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-var _HERE = path.dirname(fileURLToPath(import.meta.url));
-var ROOT = path.resolve(_HERE, "..", "..", "..");
-var EXAMPLE_FENCE_LANG = "security-example";
-var GUIDELINE = "docs/guidelines/agent-infra/security-lint-containment.md";
-var GUIDELINE_EPILOG = `False-positive containment (fenced security-example block, confidence weighting, per-file \`security-lint: allow\` pragma \u2014 no global allowlist): see ${GUIDELINE}.`;
-var DEFAULT_SCAN_ROOTS = [
-  "src/skills",
-  "src/rules",
-  "src/agent-src",
-  "src/domains",
-  "dist/agent-src"
-];
-var _EXAMPLE_PATH = /(^|\/)(docs|evals|tests?|fixtures?)(\/|$)|example|template|sample|\/_template/i;
-var _PRAGMA = /<!--\s*security-lint:\s*allow\s+([A-Za-z0-9_-]+)\s+"([^"]+)"((?:\s+sha256:[0-9a-f]{64})*)\s*-->/g;
-var _FENCE = /^(\s*)(`{3,}|~{3,})\s*([A-Za-z0-9_-]*)\s*$/;
-var SEVERITY_RANK = { LOW: 1, MED: 2, HIGH: 3 };
-var Finding = class {
-  path;
-  // repo-relative
-  line;
-  // 1-based; 0 = file-level
-  check;
-  // stable check id, also the pragma key
-  severity;
-  // HIGH | MED | LOW
-  message;
-  weight;
-  // 1.0 or 0.25
-  constructor(pathArg, line, check, severity, message, weight = 1) {
-    this.path = pathArg;
-    this.line = line;
-    this.check = check;
-    this.severity = severity;
-    this.message = message;
-    this.weight = weight;
-  }
-  /** A HIGH-severity, full-weight finding fails the build. */
-  get is_fail() {
-    return this.severity === "HIGH" && this.weight >= 1;
-  }
-  /** Mirror Python dataclass `__dict__` key order for `--json` parity. */
-  toDict() {
-    return {
-      path: this.path,
-      line: this.line,
-      check: this.check,
-      severity: this.severity,
-      message: this.message,
-      // float in Python → render integer-valued (1.0) as `1.0`.
-      weight: new PyFloat(this.weight)
-    };
-  }
-};
-function is_example_path(rel_path) {
-  return _EXAMPLE_PATH.test(rel_path);
-}
-function path_weight(rel_path) {
-  return is_example_path(rel_path) ? 0.25 : 1;
-}
-var PROJECTION_PREFIX = "dist/agent-src/";
-var PROJECTION_SOURCE_LANES = [
-  // The guidelines lane copies `docs/guidelines/` (`_lib/guidelines_lane.ts`),
-  // not `src/guidelines/`, which does not exist. Without this row a projected
-  // guideline gets a DIFFERENT identity from its own source, so a bound
-  // pragma written in the source cannot suppress the projection's copy of the
-  // very same line — measured on
-  // `untrusted-input-spotlighting.md`, a defense guideline that quotes
-  // role-takeover phrases to teach refusal and carries three accepted
-  // fingerprints for exactly that.
-  ["guidelines/", "docs/guidelines/"]
-];
-function source_identity(rel) {
-  if (!rel.startsWith(PROJECTION_PREFIX)) return rel;
-  const tail = rel.slice(PROJECTION_PREFIX.length);
-  for (const [lane, sourceRoot] of PROJECTION_SOURCE_LANES) {
-    if (tail.startsWith(lane)) return sourceRoot + tail.slice(lane.length);
-  }
-  return `src/${tail}`;
-}
-var ScannedFile = class {
-  path;
-  // absolute or as-given path
-  rel;
-  lines;
-  // per-line flags (1-based index → flag); index 0 unused
-  in_example_fence;
-  in_any_fence;
-  pragmas;
-  // check id → reason
-  /** check id → the sha256 fingerprints that pragma accepts. Empty = unbound. */
-  pragma_hashes;
-  weight;
-  constructor(pathArg, rel, lines, in_example_fence, in_any_fence, pragmas, weight, pragma_hashes = {}) {
-    this.path = pathArg;
-    this.rel = rel;
-    this.lines = lines;
-    this.in_example_fence = in_example_fence;
-    this.in_any_fence = in_any_fence;
-    this.pragmas = pragmas;
-    this.weight = weight;
-    this.pragma_hashes = pragma_hashes;
-  }
-  pragma_allows(check) {
-    return Object.prototype.hasOwnProperty.call(this.pragmas, check);
-  }
-  /**
-   * Which form of pragma this file carries for `check`.
-   *
-   * `absent`  — no pragma; scan normally.
-   * `legacy`  — a pragma with no fingerprint. Suppresses the whole file, as it
-   *             always did, and says so: a key lookup accepts whatever the
-   *             line is later changed to say, which is the defect being paid
-   *             down, not a mode anybody should choose.
-   * `bound`   — a pragma listing fingerprints. Suppresses exactly the matches
-   *             whose evidence hashes to one of them; anything else survives.
-   */
-  pragma_form(check) {
-    if (!this.pragma_allows(check)) return "absent";
-    return (this.pragma_hashes[check] ?? []).length > 0 ? "bound" : "legacy";
-  }
-  /**
-   * The fingerprint one finding's evidence hashes to.
-   *
-   * WHAT IS HASHED, and each part earns its place:
-   *   check id      — the same line may legitimately be accepted for one check
-   *                   and not another.
-   *   rel path      — the location IDENTITY. Not the line NUMBER: an unrelated
-   *                   insert above would otherwise break every pragma in the
-   *                   file, and a suppression that breaks on unrelated edits
-   *                   gets deleted rather than re-derived. A `dist/agent-src/`
-   *                   path folds to its `src/` original first, because the
-   *                   projection is byte-exact by contract (ADR-201) and
-   *                   carries the pragma verbatim — without the fold, every
-   *                   migrated pragma would suppress the source and leave its
-   *                   own copy flagged, which is a gate that reds on a file
-   *                   nobody may edit.
-   *   matched line, — the evidence. ASCII whitespace runs collapse so a reflow
-   *   normalized      does not invalidate the binding, `sha256:<hex>` tokens are
-   *                   removed, and NOTHING else is stripped: the zero-width
-   *                   characters this suite hunts are exactly what a wider
-   *                   normalizer would erase.
-   *
-   * WHY THE HASH TOKENS COME OUT. A pragma's own reason string can be the
-   * matched evidence — two in this tree are, because they quote the very
-   * phrases their check detects in order to explain themselves. Without this
-   * the fingerprint would have to be computed over a line that already
-   * contains it, which has no fixed point: writing the hash changes the line,
-   * which changes the hash. Stripping the tokens makes the fingerprint stable
-   * under the act of recording it, and costs nothing elsewhere — a `sha256:`
-   * token in ordinary prose is not evidence of anything a linter here checks.
-   *
-   * Deliberately NOT the whole file: incidental content elsewhere would make
-   * every unrelated edit re-fire the pragma, which is the noise that produces
-   * blanket suppressions.
-   */
-  evidence_fingerprint(finding) {
-    const text = finding.line > 0 ? this.lines[finding.line - 1] ?? "" : "";
-    const normalized = text.replace(/\s*sha256:[0-9a-f]{64}/g, "").replace(/[ \t]+/g, " ").trim();
-    return createHash("sha256").update(`${finding.check}
-${source_identity(this.rel)}
-${normalized}`, "utf-8").digest("hex");
-  }
-  /** Drop the findings this file's BOUND pragma for `check` accepts. */
-  filter_bound_pragma(check, findings) {
-    const accepted = new Set(this.pragma_hashes[check] ?? []);
-    if (accepted.size === 0) return [...findings];
-    return findings.filter((f) => !accepted.has(this.evidence_fingerprint(f)));
-  }
-  /** Yield [lineno, text] honouring the fence masks (mirrors iter_lines). */
-  *iter_lines(opts = {}) {
-    const skip_example_fence = opts.skip_example_fence ?? true;
-    const skip_any_fence = opts.skip_any_fence ?? false;
-    for (let i = 1; i <= this.lines.length; i++) {
-      if (skip_example_fence && this.in_example_fence[i]) {
-        continue;
-      }
-      if (skip_any_fence && this.in_any_fence[i]) {
-        continue;
-      }
-      yield [i, this.lines[i - 1]];
-    }
-  }
-};
-function _splitlines(text) {
-  const out = [];
-  let buf = "";
-  const n = text.length;
-  let i = 0;
-  while (i < n) {
-    const ch = text[i];
-    const code = text.charCodeAt(i);
-    if (code === 13) {
-      out.push(buf);
-      buf = "";
-      if (i + 1 < n && text.charCodeAt(i + 1) === 10) {
-        i += 2;
-      } else {
-        i += 1;
-      }
-      continue;
-    }
-    if (code === 10 || code === 11 || code === 12 || code === 28 || code === 29 || code === 30 || code === 133 || code === 8232 || code === 8233) {
-      out.push(buf);
-      buf = "";
-      i += 1;
-      continue;
-    }
-    buf += ch;
-    i += 1;
-  }
-  if (buf !== "") {
-    out.push(buf);
-  }
-  return out;
-}
-function scan_file(filePath) {
-  let rel;
-  if (path.isAbsolute(filePath)) {
-    const root = path.resolve(ROOT);
-    const resolved = path.resolve(filePath);
-    if (resolved === root || resolved.startsWith(root + path.sep)) {
-      rel = path.relative(root, resolved).split(path.sep).join("/");
-    } else {
-      rel = path.basename(filePath);
-    }
-  } else {
-    rel = filePath.split(path.sep).join("/");
-  }
-  const raw = fs.readFileSync(filePath, "utf-8");
-  const lines = _splitlines(raw);
-  const n = lines.length;
-  const in_example = new Array(n + 1).fill(false);
-  const in_any = new Array(n + 1).fill(false);
-  let fence_open = false;
-  let fence_marker = "";
-  let fence_is_example = false;
-  for (let idx = 1; idx <= n; idx++) {
-    const text = lines[idx - 1];
-    const m = _FENCE.exec(text);
-    if (m && !fence_open) {
-      fence_open = true;
-      fence_marker = m[2][0];
-      fence_is_example = m[3] === EXAMPLE_FENCE_LANG;
-      in_any[idx] = true;
-      in_example[idx] = fence_is_example;
-      continue;
-    }
-    if (fence_open) {
-      in_any[idx] = true;
-      in_example[idx] = fence_is_example;
-      const cm = _FENCE.exec(text);
-      if (cm && cm[2][0] === fence_marker && cm[3] === "") {
-        fence_open = false;
-        fence_is_example = false;
-      }
-    }
-  }
-  const pragmas = {};
-  const pragmaHashes = {};
-  for (const text of lines) {
-    _PRAGMA.lastIndex = 0;
-    let m;
-    while ((m = _PRAGMA.exec(text)) !== null) {
-      const check = m[1];
-      pragmas[check] = m[2];
-      const hashes = (m[3] ?? "").match(/sha256:([0-9a-f]{64})/g) ?? [];
-      pragmaHashes[check] = [
-        ...pragmaHashes[check] ?? [],
-        ...hashes.map((h) => h.slice("sha256:".length))
-      ];
-      if (m.index === _PRAGMA.lastIndex) {
-        _PRAGMA.lastIndex += 1;
-      }
-    }
-  }
-  return new ScannedFile(
-    filePath,
-    rel,
-    lines,
-    in_example,
-    in_any,
-    pragmas,
-    path_weight(rel),
-    pragmaHashes
-  );
-}
-function scan_path(filePath, base) {
-  const sf = scan_file(filePath);
-  let rel;
-  const baseResolved = path.resolve(base);
-  const fileResolved = path.resolve(filePath);
-  if (fileResolved === baseResolved || fileResolved.startsWith(baseResolved + path.sep)) {
-    rel = path.relative(baseResolved, fileResolved).split(path.sep).join("/");
-  } else {
-    rel = path.basename(filePath);
-  }
-  return new ScannedFile(
-    sf.path,
-    rel,
-    sf.lines,
-    sf.in_example_fence,
-    sf.in_any_fence,
-    sf.pragmas,
-    path_weight(rel),
-    sf.pragma_hashes
-  );
-}
-function _rglobSorted(base) {
-  const found = [];
-  const walk = (dir) => {
-    let entries;
-    try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const e of entries) {
-      const full = path.join(dir, e.name);
-      found.push(full);
-      if (e.isDirectory()) {
-        walk(full);
-      }
-    }
-  };
-  walk(base);
-  found.sort((a, b) => _pathCmp(a, b));
-  return found;
-}
-function _pathCmp(a, b) {
-  const pa = a.split(path.sep);
-  const pb = b.split(path.sep);
-  const len = Math.min(pa.length, pb.length);
-  for (let i = 0; i < len; i++) {
-    if (pa[i] < pb[i]) return -1;
-    if (pa[i] > pb[i]) return 1;
-  }
-  if (pa.length < pb.length) return -1;
-  if (pa.length > pb.length) return 1;
-  return 0;
-}
-function* iter_corpus(roots = DEFAULT_SCAN_ROOTS, exts = [".md"], scanBase = ROOT) {
-  for (const root of roots) {
-    const base = path.join(scanBase, root);
-    if (!fs.existsSync(base)) {
-      continue;
-    }
-    for (const p of _rglobSorted(base)) {
-      let st;
-      try {
-        st = fs.statSync(p);
-      } catch {
-        continue;
-      }
-      if (st.isFile() && exts.includes(path.extname(p))) {
-        yield scan_path(p, scanBase);
-      }
-    }
-  }
-}
-var LEGACY_PRAGMA_CHECK = "legacy-pragma";
-function legacy_pragma_finding(sf, check) {
-  return new Finding(
-    sf.rel,
-    0,
-    LEGACY_PRAGMA_CHECK,
-    "LOW",
-    `unbound \`security-lint: allow ${check}\` pragma suppresses this whole file \u2014 it accepts whatever the matched text is later changed to say. Bind it with \`sha256:<hex>\` per accepted match.`,
-    sf.weight
-  );
-}
-var CHILD_SCANNED_PREFIX = "scanned: ";
-function report_child_scanned(count) {
-  process.stderr.write(`${CHILD_SCANNED_PREFIX}${String(count)}
-`);
-}
-function report(findings, opts) {
-  const check_label = opts.check_label;
-  if (findings.length === 0) {
-    process.stdout.write(`\u2705  ${check_label}: clean (${_corpus_note(opts.scanned_roots)}).
-`);
-    return 0;
-  }
-  const fails = findings.filter((f) => f.is_fail);
-  const warns = findings.filter((f) => !f.is_fail);
-  const sorted = [...findings].sort((a, b) => {
-    const ra = -(SEVERITY_RANK[a.severity] ?? 0);
-    const rb = -(SEVERITY_RANK[b.severity] ?? 0);
-    if (ra !== rb) return ra - rb;
-    if (a.path < b.path) return -1;
-    if (a.path > b.path) return 1;
-    return a.line - b.line;
-  });
-  for (const f of sorted) {
-    const glyph = f.is_fail ? "\u{1F534}" : "\u26A0\uFE0F";
-    const loc = f.line ? `${f.path}:${f.line}` : f.path;
-    const wnote = f.weight >= 1 ? "" : ` (weight ${_pyG(f.weight)})`;
-    process.stdout.write(`  ${glyph} [${f.severity}] ${f.check} \u2014 ${loc}${wnote}: ${f.message}
-`);
-  }
-  process.stdout.write("\n");
-  if (fails.length > 0) {
-    process.stdout.write(
-      `\u274C  ${check_label}: ${fails.length} blocking finding(s), ${warns.length} warning(s). Fix, or mark a true teaching example with a \`\`\`${EXAMPLE_FENCE_LANG} fence or a \`security-lint: allow\` pragma.
-`
-    );
-    return 1;
-  }
-  process.stdout.write(`\u26A0\uFE0F  ${check_label}: ${warns.length} warning(s), 0 blocking.
-`);
-  return 0;
-}
-function _pyG(n) {
-  let s = n.toPrecision(6);
-  if (s.includes(".")) {
-    s = s.replace(/0+$/, "").replace(/\.$/, "");
-  }
-  return s;
-}
-function _corpus_note(scanned_roots) {
-  const roots = scanned_roots && scanned_roots.length > 0 ? scanned_roots : DEFAULT_SCAN_ROOTS;
-  return "scanned " + roots.join(", ");
-}
-var PyFloat = class {
-  constructor(value) {
-    this.value = value;
-  }
-  value;
-};
-function _isPlainObject(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v) && !(v instanceof PyFloat);
-}
-function _pyJsonStr(s) {
-  let out = '"';
-  for (const ch of s) {
-    const code = ch.codePointAt(0);
-    switch (ch) {
-      case '"':
-        out += '\\"';
-        break;
-      case "\\":
-        out += "\\\\";
-        break;
-      case "\n":
-        out += "\\n";
-        break;
-      case "\r":
-        out += "\\r";
-        break;
-      case "	":
-        out += "\\t";
-        break;
-      case "\b":
-        out += "\\b";
-        break;
-      case "\f":
-        out += "\\f";
-        break;
-      default:
-        if (code < 32) {
-          out += `\\u${code.toString(16).padStart(4, "0")}`;
-        } else {
-          out += ch;
-        }
-    }
-  }
-  return out + '"';
-}
-function _pyJsonFloat(n) {
-  if (!Number.isFinite(n)) {
-    if (Number.isNaN(n)) return "NaN";
-    return n > 0 ? "Infinity" : "-Infinity";
-  }
-  return Number.isInteger(n) ? `${n}.0` : String(n);
-}
-function _pyJsonScalar(value) {
-  if (value === null || value === void 0) return "null";
-  if (typeof value === "boolean") return value ? "true" : "false";
-  if (value instanceof PyFloat) return _pyJsonFloat(value.value);
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) {
-      if (Number.isNaN(value)) return "NaN";
-      return value > 0 ? "Infinity" : "-Infinity";
-    }
-    return String(value);
-  }
-  if (typeof value === "string") return _pyJsonStr(value);
-  return null;
-}
-function py_json_dumps_indent2(value, depth = 0) {
-  return _dumpIndent2(value, depth, true);
-}
-function _dumpIndent2(value, depth, ensureAscii) {
-  const scalar = ensureAscii ? _pyJsonScalarAscii(value) : _pyJsonScalar(value);
-  if (scalar !== null) {
-    return scalar;
-  }
-  const pad = " ".repeat(2 * (depth + 1));
-  const closePad = " ".repeat(2 * depth);
-  if (Array.isArray(value)) {
-    if (value.length === 0) return "[]";
-    const items = value.map((v) => pad + _dumpIndent2(v, depth + 1, ensureAscii));
-    return `[
-${items.join(",\n")}
-${closePad}]`;
-  }
-  if (_isPlainObject(value)) {
-    const keys = Object.keys(value);
-    if (keys.length === 0) return "{}";
-    const items = keys.map(
-      (k) => `${pad}${ensureAscii ? _pyJsonStrAscii(k) : _pyJsonStr(k)}: ${_dumpIndent2(value[k], depth + 1, ensureAscii)}`
-    );
-    return `{
-${items.join(",\n")}
-${closePad}}`;
-  }
-  return ensureAscii ? _pyJsonStrAscii(String(value)) : _pyJsonStr(String(value));
-}
-function _pyJsonStrAscii(s) {
-  let out = '"';
-  for (const ch of s) {
-    const code = ch.codePointAt(0);
-    switch (ch) {
-      case '"':
-        out += '\\"';
-        break;
-      case "\\":
-        out += "\\\\";
-        break;
-      case "\n":
-        out += "\\n";
-        break;
-      case "\r":
-        out += "\\r";
-        break;
-      case "	":
-        out += "\\t";
-        break;
-      case "\b":
-        out += "\\b";
-        break;
-      case "\f":
-        out += "\\f";
-        break;
-      default:
-        if (code < 32) {
-          out += `\\u${code.toString(16).padStart(4, "0")}`;
-        } else if (code < 127) {
-          out += ch;
-        } else if (code <= 65535) {
-          out += `\\u${code.toString(16).padStart(4, "0")}`;
-        } else {
-          const cp = code - 65536;
-          const hi = 55296 + (cp >> 10);
-          const lo = 56320 + (cp & 1023);
-          out += `\\u${hi.toString(16).padStart(4, "0")}\\u${lo.toString(16).padStart(4, "0")}`;
-        }
-    }
-  }
-  return out + '"';
-}
-function _pyJsonScalarAscii(value) {
-  if (typeof value === "string") return _pyJsonStrAscii(value);
-  return _pyJsonScalar(value);
-}
-
-// src/scripts/lint_hidden_unicode.ts
-var CHECK = "hidden-unicode";
-var _BIDI = /* @__PURE__ */ new Set([
-  8234,
-  8235,
-  8236,
-  8237,
-  8238,
-  8294,
-  8295,
-  8296,
-  8297,
-  8206,
-  8207,
-  1564
-]);
-var _ZERO_WIDTH = /* @__PURE__ */ new Set([8203, 8204, 8205, 8288, 65279, 173]);
-var _DEPRECATED = /* @__PURE__ */ new Set([
-  8298,
-  8299,
-  8300,
-  8301,
-  8302,
-  8303,
-  65529,
-  65530,
-  65531
-]);
-function _classify(cp) {
-  if (_BIDI.has(cp)) {
-    return "bidi-control";
-  }
-  if (_ZERO_WIDTH.has(cp)) {
-    return "zero-width";
-  }
-  if (cp >= 917504 && cp <= 917631) {
-    return "unicode-tag";
-  }
-  if (_DEPRECATED.has(cp)) {
-    return "deprecated-format";
-  }
-  if (cp >= 57344 && cp <= 63743 || cp >= 983040 && cp <= 1048573 || cp >= 1048576 && cp <= 1114109) {
-    return "private-use-area";
-  }
-  if ((cp >= 0 && cp <= 31 || cp >= 127 && cp <= 159) && cp !== 9 && cp !== 10 && cp !== 13) {
-    return "control-char";
-  }
-  return null;
-}
-var _VS_LO = 917760;
-var _VS_HI = 917999;
-function _isVS(cp) {
-  return cp >= _VS_LO && cp <= _VS_HI;
-}
-var _CP_NAME = {
-  173: "SOFT HYPHEN",
-  1564: "ARABIC LETTER MARK",
-  8203: "ZERO WIDTH SPACE",
-  8204: "ZERO WIDTH NON-JOINER",
-  8205: "ZERO WIDTH JOINER",
-  8206: "LEFT-TO-RIGHT MARK",
-  8207: "RIGHT-TO-LEFT MARK",
-  8234: "LEFT-TO-RIGHT EMBEDDING",
-  8235: "RIGHT-TO-LEFT EMBEDDING",
-  8236: "POP DIRECTIONAL FORMATTING",
-  8237: "LEFT-TO-RIGHT OVERRIDE",
-  8238: "RIGHT-TO-LEFT OVERRIDE",
-  8288: "WORD JOINER",
-  8294: "LEFT-TO-RIGHT ISOLATE",
-  8295: "RIGHT-TO-LEFT ISOLATE",
-  8296: "FIRST STRONG ISOLATE",
-  8297: "POP DIRECTIONAL ISOLATE",
-  8298: "INHIBIT SYMMETRIC SWAPPING",
-  8299: "ACTIVATE SYMMETRIC SWAPPING",
-  8300: "INHIBIT ARABIC FORM SHAPING",
-  8301: "ACTIVATE ARABIC FORM SHAPING",
-  8302: "NATIONAL DIGIT SHAPES",
-  8303: "NOMINAL DIGIT SHAPES",
-  65279: "ZERO WIDTH NO-BREAK SPACE",
-  65529: "INTERLINEAR ANNOTATION ANCHOR",
-  65530: "INTERLINEAR ANNOTATION SEPARATOR",
-  65531: "INTERLINEAR ANNOTATION TERMINATOR",
-  917505: "LANGUAGE TAG",
-  917536: "TAG SPACE",
-  917537: "TAG EXCLAMATION MARK",
-  917538: "TAG QUOTATION MARK",
-  917539: "TAG NUMBER SIGN",
-  917540: "TAG DOLLAR SIGN",
-  917541: "TAG PERCENT SIGN",
-  917542: "TAG AMPERSAND",
-  917543: "TAG APOSTROPHE",
-  917544: "TAG LEFT PARENTHESIS",
-  917545: "TAG RIGHT PARENTHESIS",
-  917546: "TAG ASTERISK",
-  917547: "TAG PLUS SIGN",
-  917548: "TAG COMMA",
-  917549: "TAG HYPHEN-MINUS",
-  917550: "TAG FULL STOP",
-  917551: "TAG SOLIDUS",
-  917552: "TAG DIGIT ZERO",
-  917553: "TAG DIGIT ONE",
-  917554: "TAG DIGIT TWO",
-  917555: "TAG DIGIT THREE",
-  917556: "TAG DIGIT FOUR",
-  917557: "TAG DIGIT FIVE",
-  917558: "TAG DIGIT SIX",
-  917559: "TAG DIGIT SEVEN",
-  917560: "TAG DIGIT EIGHT",
-  917561: "TAG DIGIT NINE",
-  917562: "TAG COLON",
-  917563: "TAG SEMICOLON",
-  917564: "TAG LESS-THAN SIGN",
-  917565: "TAG EQUALS SIGN",
-  917566: "TAG GREATER-THAN SIGN",
-  917567: "TAG QUESTION MARK",
-  917568: "TAG COMMERCIAL AT",
-  917569: "TAG LATIN CAPITAL LETTER A",
-  917570: "TAG LATIN CAPITAL LETTER B",
-  917571: "TAG LATIN CAPITAL LETTER C",
-  917572: "TAG LATIN CAPITAL LETTER D",
-  917573: "TAG LATIN CAPITAL LETTER E",
-  917574: "TAG LATIN CAPITAL LETTER F",
-  917575: "TAG LATIN CAPITAL LETTER G",
-  917576: "TAG LATIN CAPITAL LETTER H",
-  917577: "TAG LATIN CAPITAL LETTER I",
-  917578: "TAG LATIN CAPITAL LETTER J",
-  917579: "TAG LATIN CAPITAL LETTER K",
-  917580: "TAG LATIN CAPITAL LETTER L",
-  917581: "TAG LATIN CAPITAL LETTER M",
-  917582: "TAG LATIN CAPITAL LETTER N",
-  917583: "TAG LATIN CAPITAL LETTER O",
-  917584: "TAG LATIN CAPITAL LETTER P",
-  917585: "TAG LATIN CAPITAL LETTER Q",
-  917586: "TAG LATIN CAPITAL LETTER R",
-  917587: "TAG LATIN CAPITAL LETTER S",
-  917588: "TAG LATIN CAPITAL LETTER T",
-  917589: "TAG LATIN CAPITAL LETTER U",
-  917590: "TAG LATIN CAPITAL LETTER V",
-  917591: "TAG LATIN CAPITAL LETTER W",
-  917592: "TAG LATIN CAPITAL LETTER X",
-  917593: "TAG LATIN CAPITAL LETTER Y",
-  917594: "TAG LATIN CAPITAL LETTER Z",
-  917595: "TAG LEFT SQUARE BRACKET",
-  917596: "TAG REVERSE SOLIDUS",
-  917597: "TAG RIGHT SQUARE BRACKET",
-  917598: "TAG CIRCUMFLEX ACCENT",
-  917599: "TAG LOW LINE",
-  917600: "TAG GRAVE ACCENT",
-  917601: "TAG LATIN SMALL LETTER A",
-  917602: "TAG LATIN SMALL LETTER B",
-  917603: "TAG LATIN SMALL LETTER C",
-  917604: "TAG LATIN SMALL LETTER D",
-  917605: "TAG LATIN SMALL LETTER E",
-  917606: "TAG LATIN SMALL LETTER F",
-  917607: "TAG LATIN SMALL LETTER G",
-  917608: "TAG LATIN SMALL LETTER H",
-  917609: "TAG LATIN SMALL LETTER I",
-  917610: "TAG LATIN SMALL LETTER J",
-  917611: "TAG LATIN SMALL LETTER K",
-  917612: "TAG LATIN SMALL LETTER L",
-  917613: "TAG LATIN SMALL LETTER M",
-  917614: "TAG LATIN SMALL LETTER N",
-  917615: "TAG LATIN SMALL LETTER O",
-  917616: "TAG LATIN SMALL LETTER P",
-  917617: "TAG LATIN SMALL LETTER Q",
-  917618: "TAG LATIN SMALL LETTER R",
-  917619: "TAG LATIN SMALL LETTER S",
-  917620: "TAG LATIN SMALL LETTER T",
-  917621: "TAG LATIN SMALL LETTER U",
-  917622: "TAG LATIN SMALL LETTER V",
-  917623: "TAG LATIN SMALL LETTER W",
-  917624: "TAG LATIN SMALL LETTER X",
-  917625: "TAG LATIN SMALL LETTER Y",
-  917626: "TAG LATIN SMALL LETTER Z",
-  917627: "TAG LEFT CURLY BRACKET",
-  917628: "TAG VERTICAL LINE",
-  917629: "TAG RIGHT CURLY BRACKET",
-  917630: "TAG TILDE",
-  917631: "CANCEL TAG"
-};
-function _cpName(cp) {
-  const n = _CP_NAME[cp];
-  return n !== void 0 ? n : "<unnamed>";
-}
-function _scan(sf) {
-  const pragmaForm = sf.pragma_form(CHECK);
-  if (pragmaForm === "legacy") {
-    return [legacy_pragma_finding(sf, CHECK)];
-  }
-  const finish = (hits) => pragmaForm === "bound" ? sf.filter_bound_pragma(CHECK, hits) : hits;
-  const out = [];
-  for (const [lineno, text] of sf.iter_lines({ skip_example_fence: true })) {
-    let vs_run = 0;
-    for (const ch of text) {
-      const cp = ch.codePointAt(0);
-      if (_isVS(cp)) {
-        vs_run += 1;
-        continue;
-      }
-      const kind = _classify(cp);
-      if (kind) {
-        const name = _cpName(cp);
-        out.push(
-          new Finding(
-            sf.rel,
-            lineno,
-            CHECK,
-            "HIGH",
-            `${kind} U+${cp.toString(16).toUpperCase().padStart(4, "0")} (${name})`,
-            sf.weight
-          )
-        );
-      }
-    }
-    if (vs_run >= 3) {
-      out.push(
-        new Finding(
-          sf.rel,
-          lineno,
-          CHECK,
-          "HIGH",
-          `variation-selector run x${vs_run} (steganography signature)`,
-          sf.weight
-        )
-      );
-    }
-  }
-  return finish(out);
-}
-var _BINARY_EXT = /* @__PURE__ */ new Set([
-  "png",
-  "jpg",
-  "jpeg",
-  "gif",
-  "ico",
-  "webp",
-  "avif",
-  "bmp",
-  "tiff",
-  "pdf",
-  "woff",
-  "woff2",
-  "ttf",
-  "otf",
-  "eot",
-  "zip",
-  "gz",
-  "tgz",
-  "bz2",
-  "xz",
-  "zst",
-  "7z",
-  "rar",
-  "wasm",
-  "mp3",
-  "mp4",
-  "wav",
-  "ogg",
-  "webm",
-  "mov",
-  "avi",
-  "so",
-  "dylib",
-  "dll",
-  "node",
-  "a",
-  "o",
-  "exe",
-  "jar",
-  "class",
-  "pyc",
-  "pyo",
-  "db",
-  "sqlite",
-  "sqlite3",
-  "bin",
-  "dat",
-  "docx",
-  "xlsx",
-  "pptx",
-  "doc",
-  "xls",
-  "ppt",
-  "odt",
-  "ods",
-  "odp"
-]);
-var _GENERATED_PREFIXES = [
-  "dist/",
-  ".augment/",
-  ".claude/",
-  ".cursor/",
-  ".clinerules/",
-  // Verbatim captured tool output, not authored text. These are RECORDINGS:
-  // escaping a control byte inside one would falsify the record it exists to
-  // preserve. If a capture needs to stay grep-readable, the fix is to escape
-  // at capture time — never to edit the artifact afterwards.
-  "agents/evidence/analysis/",
-  // The frozen hostile-encoding corpus. Its positives ARE raw control
-  // characters — that is the thing under test, so flagging them would demand
-  // escaping the fixtures and thereby delete the test. The corpus has its own,
-  // stronger integrity controls: a sha256 freeze plus a scope-guard test that
-  // is itself falsified by an out-of-scope fixture. Excluded here because it
-  // is DATA, on the same principle as the captures above.
-  "internal/bench/corpora/encoding-channels/"
-];
-function _isGenerated(rel) {
-  return _GENERATED_PREFIXES.some((p) => rel.startsWith(p));
-}
-function _isRawControlCodepoint(cp) {
-  if (cp === 9 || cp === 10 || cp === 13) return false;
-  return cp <= 31 || cp >= 127 && cp <= 159;
-}
-function _extensionOf(rel) {
-  const base = rel.slice(rel.lastIndexOf("/") + 1);
-  const dot = base.lastIndexOf(".");
-  return dot <= 0 ? "" : base.slice(dot + 1).toLowerCase();
-}
-function _trackedFiles() {
-  const res = spawnSync("git", ["ls-files", "-z"], {
-    cwd: ROOT,
-    maxBuffer: 64 * 1024 * 1024
-  });
-  if (res.status !== 0 || res.stdout === null) return null;
-  return res.stdout.toString("utf-8").split("\0").filter((p) => p !== "");
-}
-function _eligibleSourceFiles() {
-  const tracked = _trackedFiles();
-  if (tracked === null) return null;
-  return tracked.filter((rel) => !_isGenerated(rel) && !_BINARY_EXT.has(_extensionOf(rel)));
-}
-function _scanSourceControlBytes(files = null) {
-  const tracked = files ?? _eligibleSourceFiles();
-  if (tracked === null) return [];
-  const out = [];
-  for (const rel of tracked) {
-    if (_isGenerated(rel)) continue;
-    if (_BINARY_EXT.has(_extensionOf(rel))) continue;
-    let data;
-    try {
-      data = fs2.readFileSync(path2.join(ROOT, rel));
-    } catch {
-      continue;
-    }
-    try {
-      new TextDecoder("utf-8", { fatal: true }).decode(data);
-    } catch {
-      continue;
-    }
-    let line = 1;
-    for (const ch of data.toString("utf-8")) {
-      const cp = ch.codePointAt(0);
-      if (cp === void 0) continue;
-      if (cp === 10) {
-        line += 1;
-        continue;
-      }
-      if (!_isRawControlCodepoint(cp)) continue;
-      const hex = cp.toString(16).toUpperCase().padStart(2, "0");
-      out.push(
-        new Finding(
-          rel,
-          line,
-          CHECK,
-          "HIGH",
-          `raw control character U+${hex} in a text source \u2014 makes grep/file(1)/git treat this file as binary and skip it silently; use the language escape (e.g. \\0, \\x7F) instead`,
-          1
-        )
-      );
-    }
-  }
-  return out;
-}
-function _sanitize(filePath) {
-  const raw = fs2.readFileSync(filePath, "utf-8");
-  let cleaned = "";
-  for (const ch of raw) {
-    const cp = ch.codePointAt(0);
-    if (_classify(cp) === null && !_isVS(cp)) {
-      cleaned += ch;
-    }
-  }
-  cleaned = cleaned.normalize("NFKC");
-  const out = filePath + ".sanitized";
-  fs2.writeFileSync(out, cleaned, "utf-8");
-  return out;
-}
-function _argError(msg) {
-  process.stderr.write("usage: lint_hidden_unicode [-h] [--json] [--fix] [--root DIR]\n");
-  process.stderr.write(`lint_hidden_unicode: error: ${msg}
-`);
-  process.exit(2);
-}
-function parse_args(argv) {
-  const out = { json: false, fix: false };
-  const extra = [];
-  let rootPending = false;
-  for (const a of argv) {
-    if (rootPending) {
-      out.root = a;
-      rootPending = false;
-      continue;
-    }
-    if (a === "-h" || a === "--help") {
-      process.stdout.write("usage: lint_hidden_unicode [-h] [--json] [--fix] [--root DIR]\n");
-      process.exit(0);
-    } else if (a === "--json") {
-      out.json = true;
-    } else if (a === "--fix") {
-      out.fix = true;
-    } else if (a === "--root" || a.startsWith("--root=")) {
-      const eq = a.indexOf("=");
-      if (eq !== -1) {
-        out.root = a.slice(eq + 1);
-      } else {
-        rootPending = true;
-      }
-    } else {
-      extra.push(a);
-    }
-  }
-  if (extra.length > 0) {
-    _argError(`unrecognized arguments: ${extra.join(" ")}`);
-  }
-  return out;
-}
-function main(argv = null) {
-  const args = parse_args(argv ?? process.argv.slice(2));
-  const scanBase = args.root === void 0 ? ROOT : path2.resolve(args.root);
-  const findings = [];
-  const flagged = /* @__PURE__ */ new Set();
-  let corpusFiles = 0;
-  for (const sf of iter_corpus(DEFAULT_SCAN_ROOTS, [".md"], scanBase)) {
-    corpusFiles += 1;
-    const hits = _scan(sf);
-    for (const h of hits) {
-      findings.push(h);
-    }
-    if (hits.length > 0) {
-      flagged.add(sf.path);
-    }
-  }
-  try {
-    assertScanned({
-      gate: "lint_hidden_unicode",
-      scanned: corpusFiles,
-      units: "corpus file(s)",
-      roots: DEFAULT_SCAN_ROOTS
-    });
-  } catch (exc) {
-    if (exc instanceof DeadScopeError) {
-      process.stderr.write(`\u274C  ${exc.message}
-`);
-      return 1;
-    }
-    throw exc;
-  }
-  const sourceFiles = args.root === void 0 ? _eligibleSourceFiles() : [];
-  for (const h of _scanSourceControlBytes(sourceFiles)) {
-    findings.push(h);
-  }
-  if (!args.json) {
-    const n = sourceFiles === null ? 0 : sourceFiles.length;
-    process.stdout.write(
-      sourceFiles === null ? "  source pass: SKIPPED \u2014 `git ls-files` unavailable, 0 files read for raw control bytes\n" : `  source pass: ${n} tracked text file(s) read for raw C0 control bytes (generated trees + verbatim captures excluded)
-`
-    );
-  }
-  if (args.fix) {
-    for (const p of [...flagged].sort()) {
-      const sanitized = _sanitize(p);
-      const rel = path2.relative(path2.resolve(ROOT), path2.resolve(sanitized));
-      process.stdout.write(`  fixed \u2192 ${rel.split(path2.sep).join("/")}
-`);
-    }
-  }
-  if (args.json) {
-    report_child_scanned(corpusFiles + (sourceFiles === null ? 0 : sourceFiles.length));
-  }
-  if (args.json) {
-    const payload = py_json_dumps_indent2(findings.map((f) => f.toDict()));
-    process.stdout.write(payload + "\n");
-    return findings.some((f) => f.is_fail) ? 1 : 0;
-  }
-  return report(findings, { check_label: "hidden-unicode" });
-}
-function _isCliEntry() {
-  if (true) {
-    return false;
-  }
-  if (process.argv[1] === void 0) {
-    return false;
-  }
-  const argvUrl = pathToFileURL(path2.resolve(process.argv[1])).href;
-  if (import.meta.url === argvUrl) {
-    return true;
-  }
-  try {
-    const here = fs2.realpathSync(fileURLToPath2(import.meta.url));
-    const argv = fs2.realpathSync(path2.resolve(process.argv[1]));
-    return here === argv;
-  } catch {
-    return false;
-  }
-}
-if (_isCliEntry()) {
-  process.exitCode = main();
-}
-
-// src/scripts/_lib/confusables.ts
-var _LATIN = new RegExp("\\p{Script=Latin}", "u");
-var _CYRILLIC = new RegExp("\\p{Script=Cyrillic}", "u");
-var _GREEK = new RegExp("\\p{Script=Greek}", "u");
-var _LETTER = new RegExp("\\p{L}", "u");
+import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL3 } from "node:url";
+import { createRequire } from "node:module";
 
 // src/scripts/_lib/retrieval_sanitize.ts
 var MAX_FIELD_CHARS = 8192;
@@ -1154,212 +70,22 @@ function _sanitize_value(v) {
   return v;
 }
 
-// src/scripts/_lib/lexical_index.ts
-var BM25_K1 = 1.5;
-var BM25_B = 0.75;
-var MIN_TOKEN_LEN = 2;
-function tokenize(s) {
-  const out = [];
-  for (const raw of s.toLowerCase().split(/[^a-z0-9]+/)) {
-    if (raw.length >= MIN_TOKEN_LEN) out.push(raw);
-  }
-  return out;
-}
-function trigrams(s) {
-  const norm = s.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
-  const out = /* @__PURE__ */ new Set();
-  if (norm.length < 3) {
-    if (norm.length > 0) out.add(norm);
-    return out;
-  }
-  for (let i = 0; i + 3 <= norm.length; i++) {
-    out.add(norm.slice(i, i + 3));
-  }
-  return out;
-}
-var LexicalIndex = class {
-  docs = /* @__PURE__ */ new Map();
-  df = /* @__PURE__ */ new Map();
-  n;
-  avgdl;
-  constructor(documents) {
-    let totalLen = 0;
-    for (const d of documents) {
-      const tokens = tokenize(d.text);
-      const tf = /* @__PURE__ */ new Map();
-      for (const t of tokens) tf.set(t, (tf.get(t) ?? 0) + 1);
-      for (const t of tf.keys()) this.df.set(t, (this.df.get(t) ?? 0) + 1);
-      this.docs.set(d.id, { id: d.id, len: tokens.length, tf, trigrams: trigrams(d.text) });
-      totalLen += tokens.length;
-    }
-    this.n = documents.length;
-    this.avgdl = this.n > 0 ? totalLen / this.n : 0;
-  }
-  /** Robertson–Spärck-Jones IDF, floored at 0 so common terms never subtract. */
-  idf(term) {
-    const df = this.df.get(term) ?? 0;
-    if (df === 0) return 0;
-    return Math.max(0, Math.log(1 + (this.n - df + 0.5) / (df + 0.5)));
-  }
-  /**
-   * BM25 score of one document against the tokenised query terms, weighted by
-   * **term coverage**: the raw BM25 sum is multiplied by `coverage²`, where
-   * `coverage = distinct-query-terms-matched / distinct-query-terms`. This
-   * stops a single generic, high-TF term match from outranking a document that
-   * matches several rarer query terms once each (Phase 1 refinement). A
-   * single-term query has `coverage == 1`, so its score is unchanged — the
-   * weighting only re-orders genuinely multi-term queries.
-   */
-  score(queryTerms, docId) {
-    const doc = this.docs.get(docId);
-    if (doc === void 0 || doc.len === 0) return 0;
-    let s = 0;
-    const matched = /* @__PURE__ */ new Set();
-    for (const term of queryTerms) {
-      const tf = doc.tf.get(term);
-      if (tf === void 0) continue;
-      const idf = this.idf(term);
-      if (idf === 0) continue;
-      const denom = tf + BM25_K1 * (1 - BM25_B + BM25_B * doc.len / (this.avgdl || 1));
-      s += idf * (tf * (BM25_K1 + 1)) / denom;
-      matched.add(term);
-    }
-    if (s === 0) return 0;
-    const distinctQuery = new Set(queryTerms).size;
-    const coverage = distinctQuery > 0 ? matched.size / distinctQuery : 1;
-    return s * coverage * coverage;
-  }
-  /**
-   * Rank documents for a set of query keys (phrases are tokenised). A
-   * character-trigram prefilter selects candidates cheaply; the guard keeps
-   * any doc sharing a query TOKEN even when no trigram overlaps, so the
-   * prefilter never drops a genuine lexical match. Ties break by id for a
-   * stable, deterministic order.
-   */
-  rank(queryKeys) {
-    const queryText = queryKeys.join(" ");
-    const qTerms = tokenize(queryText);
-    const qTermSet = new Set(qTerms);
-    const qTrigrams = trigrams(queryText);
-    const candidates = [];
-    for (const [id, doc] of this.docs) {
-      let hit = false;
-      for (const t of qTrigrams) {
-        if (doc.trigrams.has(t)) {
-          hit = true;
-          break;
-        }
-      }
-      if (!hit) {
-        for (const t of qTermSet) {
-          if (doc.tf.has(t)) {
-            hit = true;
-            break;
-          }
-        }
-      }
-      if (hit) candidates.push(id);
-    }
-    const scored = candidates.map((id) => ({ id, score: this.score(qTerms, id) })).filter((r) => r.score > 0);
-    scored.sort((a, b) => b.score - a.score || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
-    return scored;
-  }
-  /** Document count — for the caller's tripwire / diagnostics. */
-  get size() {
-    return this.n;
-  }
-};
-
 // src/scripts/_lib/memory_fts_index.ts
-import * as fs5 from "node:fs";
-import * as path5 from "node:path";
-
-// src/scripts/_lib/sqlite_guard.ts
-import { createRequire } from "node:module";
-var SqliteUnavailableError = class extends Error {
-  constructor(callerName, cause) {
-    super(
-      `node:sqlite is unavailable in this runtime (${cause}). ${callerName} requires Node with the built-in SQLite module.`
-    );
-    this.name = "SqliteUnavailableError";
-  }
-};
-var _sqliteWarningSilenced = false;
-function _silenceSqliteExperimentalWarning() {
-  if (_sqliteWarningSilenced) return;
-  _sqliteWarningSilenced = true;
-  const orig = process.emitWarning.bind(process);
-  process.emitWarning = ((warning, ...rest) => {
-    const text = typeof warning === "string" ? warning : warning?.message ?? "";
-    if (/SQLite is an experimental/i.test(text)) return;
-    orig(warning, ...rest);
-  });
-}
-var _require;
-function _syncRequire() {
-  if (_require === void 0) {
-    _require = createRequire(import.meta.url);
-  }
-  return _require;
-}
-function loadSqliteSync(callerName) {
-  _silenceSqliteExperimentalWarning();
-  try {
-    return _syncRequire()("node:sqlite");
-  } catch (exc) {
-    const message = exc instanceof Error ? exc.message : String(exc);
-    throw new SqliteUnavailableError(callerName, message);
-  }
-}
-function probeFts5Sync() {
-  let sqlite;
-  try {
-    sqlite = loadSqliteSync("sqlite_guard.probeFts5Sync");
-  } catch {
-    return false;
-  }
-  let conn = null;
-  try {
-    conn = new sqlite.DatabaseSync(":memory:");
-    conn.exec("CREATE VIRTUAL TABLE _fts5_probe USING fts5(body)");
-    conn.exec("INSERT INTO _fts5_probe(body) VALUES ('probe')");
-    const row = conn.prepare("SELECT body FROM _fts5_probe WHERE _fts5_probe MATCH 'probe'").get();
-    return row !== void 0;
-  } catch {
-    return false;
-  } finally {
-    try {
-      conn?.close();
-    } catch {
-    }
-  }
-}
-function readUserVersion(conn) {
-  const row = conn.prepare("PRAGMA user_version").get();
-  const v = row?.["user_version"];
-  if (typeof v === "bigint") return Number(v);
-  if (typeof v === "number") return v;
-  return 0;
-}
-function stampUserVersion(conn, version) {
-  if (!Number.isInteger(version) || version < 0 || version > 2 ** 31 - 1) {
-    throw new RangeError(`stampUserVersion: version out of range: ${version}`);
-  }
-  conn.exec(`PRAGMA user_version = ${version}`);
-}
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
 
 // src/scripts/memory_report.ts
 var import_yaml = __toESM(require_dist(), 1);
-import * as fs4 from "node:fs";
-import * as path4 from "node:path";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
 import process3 from "node:process";
-import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL3 } from "node:url";
+import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "node:url";
 
 // src/scripts/memory_status.ts
 import process2 from "node:process";
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
-import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "node:url";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 var CONTRACT_VERSION = 1;
 var _FILE_BACKEND_VERSION = "0.0.0-file";
 var _FILE_BACKEND_FEATURES = ["file-fallback"];
@@ -1471,7 +197,7 @@ function _parseArgs(argv) {
   }
   return args;
 }
-function main2() {
+function main() {
   const args = _parseArgs(process2.argv.slice(2));
   if (args.health) {
     process2.stdout.write(`${_pyJsonDumps(health())}
@@ -1488,29 +214,29 @@ function main2() {
   }
   return 0;
 }
-function _isCliEntry2() {
+function _isCliEntry() {
   if (true) {
     return false;
   }
   if (process2.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL2(path3.resolve(process2.argv[1])).href;
+  const argvUrl = pathToFileURL(path.resolve(process2.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs3.realpathSync(fileURLToPath3(import.meta.url));
-    const argv = fs3.realpathSync(path3.resolve(process2.argv[1]));
+    const here = fs.realpathSync(fileURLToPath(import.meta.url));
+    const argv = fs.realpathSync(path.resolve(process2.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-var _isMain = _isCliEntry2();
+var _isMain = _isCliEntry();
 if (_isMain) {
   try {
-    process2.exitCode = main2();
+    process2.exitCode = main();
   } catch (e) {
     if (e instanceof _ExitError) {
       process2.exitCode = e.code;
@@ -1521,8 +247,8 @@ if (_isMain) {
 }
 
 // src/scripts/memory_report.ts
-var MEMORY_ROOT = path4.join("agents", "memory");
-var INTAKE_ROOT = path4.join(MEMORY_ROOT, "intake");
+var MEMORY_ROOT = path2.join("agents", "memory");
+var INTAKE_ROOT = path2.join(MEMORY_ROOT, "intake");
 function _setMemoryRoot(p) {
   MEMORY_ROOT = p;
 }
@@ -1535,10 +261,10 @@ var CURATED_TYPES = [
 ];
 var _MODE_MARKER_PATTERN = /<!--\s*role-mode:\s*([a-z0-9][a-z0-9-]*)\s*\|\s*contract:[^>]*-->/g;
 var _MODE_SCAN_DIRS = [
-  path4.join("agents", "sessions"),
-  path4.join("agents", "runtime", "reports"),
-  path4.join("agents", "handoffs"),
-  path4.join("agents", "learnings")
+  path2.join("agents", "sessions"),
+  path2.join("agents", "runtime", "reports"),
+  path2.join("agents", "handoffs"),
+  path2.join("agents", "learnings")
 ];
 var _KNOWN_MODES = /* @__PURE__ */ new Set([
   "developer",
@@ -1559,31 +285,31 @@ var PyTimestamp = class {
     return this.pyStr;
   }
 };
-var PyFloat2 = class {
+var PyFloat = class {
   constructor(value) {
     this.value = value;
   }
   value;
 };
-function _isPlainObject2(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v) && !(v instanceof PyTimestamp) && !(v instanceof PyFloat2);
+function _isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) && !(v instanceof PyTimestamp) && !(v instanceof PyFloat);
 }
 function _isFile(p) {
   try {
-    return fs4.statSync(p).isFile();
+    return fs2.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function _isDir(p) {
   try {
-    return fs4.statSync(p).isDirectory();
+    return fs2.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function _load_yaml(p) {
-  const text = fs4.readFileSync(p, "utf-8");
+  const text = fs2.readFileSync(p, "utf-8");
   const doc = (0, import_yaml.parseDocument)(text, { version: "1.1", prettyErrors: false });
   if (doc.errors.length > 0) {
     const err = doc.errors[0];
@@ -1643,30 +369,30 @@ function _pyYamlDatetimeStr(raw) {
 function _iter_curated_entries() {
   const out = [];
   for (const mtype of CURATED_TYPES) {
-    const single = path4.join(MEMORY_ROOT, `${mtype}.yml`);
+    const single = path2.join(MEMORY_ROOT, `${mtype}.yml`);
     if (_isFile(single)) {
       const data = _load_yaml(single);
       const entries = data["entries"];
       if (Array.isArray(entries)) {
         for (const e of entries) {
-          if (_isPlainObject2(e)) {
+          if (_isPlainObject(e)) {
             out.push([single, mtype, e]);
           }
         }
       }
     }
-    const type_dir = path4.join(MEMORY_ROOT, mtype);
+    const type_dir = path2.join(MEMORY_ROOT, mtype);
     if (_isDir(type_dir)) {
       for (const yml of _rglobYml(type_dir)) {
         const data = _load_yaml(yml) ?? {};
         const entries = data["entries"];
         if (Array.isArray(entries)) {
           for (const e of entries) {
-            if (_isPlainObject2(e)) {
+            if (_isPlainObject(e)) {
               out.push([yml, mtype, e]);
             }
           }
-        } else if (_isPlainObject2(data) && data["id"]) {
+        } else if (_isPlainObject(data) && data["id"]) {
           out.push([yml, mtype, data]);
         }
       }
@@ -1679,12 +405,12 @@ function _rglobYml(root) {
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs4.readdirSync(dir, { withFileTypes: true });
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const ent of entries) {
-      const full = path4.join(dir, ent.name);
+      const full = path2.join(dir, ent.name);
       if (ent.isDirectory()) {
         walk(full);
       } else if (ent.isFile() && ent.name.endsWith(".yml")) {
@@ -1699,11 +425,11 @@ function _rglobYml(root) {
 function _globJsonl(root) {
   let names;
   try {
-    names = fs4.readdirSync(root);
+    names = fs2.readdirSync(root);
   } catch {
     return [];
   }
-  return names.filter((n) => n.endsWith(".jsonl")).sort().map((n) => path4.join(root, n));
+  return names.filter((n) => n.endsWith(".jsonl")).sort().map((n) => path2.join(root, n));
 }
 function _intake_stats() {
   let total = 0;
@@ -1712,7 +438,7 @@ function _intake_stats() {
   let superseded = 0;
   if (_isDir(INTAKE_ROOT)) {
     for (const jsonl of _globJsonl(INTAKE_ROOT)) {
-      const stem = path4.basename(jsonl).replace(/\.jsonl$/, "");
+      const stem = path2.basename(jsonl).replace(/\.jsonl$/, "");
       const month = stem.replace("signals-", "");
       for (const obj of _readJsonl(jsonl)) {
         if (obj["type"] === "supersede") {
@@ -1738,7 +464,7 @@ function _intake_stats() {
 function _readJsonl(p) {
   let text;
   try {
-    text = fs4.readFileSync(p, "utf-8");
+    text = fs2.readFileSync(p, "utf-8");
   } catch {
     return [];
   }
@@ -1754,7 +480,7 @@ function _readJsonl(p) {
     } catch {
       continue;
     }
-    if (_isPlainObject2(obj)) {
+    if (_isPlainObject(obj)) {
       out.push(obj);
     }
   }
@@ -1872,7 +598,7 @@ function _quarterly_stats() {
   return {
     accepted_by_quarter: _mapToObj(accepted),
     retired_by_quarter: _mapToObj(retired),
-    staleness_rate: new PyFloat2(_pyRound3(rate)),
+    staleness_rate: new PyFloat(_pyRound3(rate)),
     curated_total: total,
     curated_overdue: overdue
   };
@@ -1901,7 +627,7 @@ function _role_mode_stats() {
     for (const md of _rglobMd(root)) {
       let text;
       try {
-        text = fs4.readFileSync(md, "utf-8");
+        text = fs2.readFileSync(md, "utf-8");
       } catch {
         continue;
       }
@@ -1930,7 +656,7 @@ function _role_mode_stats() {
 }
 function _exists(p) {
   try {
-    fs4.statSync(p);
+    fs2.statSync(p);
     return true;
   } catch {
     return false;
@@ -1941,12 +667,12 @@ function _rglobMd(root) {
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs4.readdirSync(dir, { withFileTypes: true });
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const ent of entries) {
-      const full = path4.join(dir, ent.name);
+      const full = path2.join(dir, ent.name);
       if (ent.isDirectory()) {
         walk(full);
       } else if (ent.isFile() && ent.name.endsWith(".md")) {
@@ -1972,19 +698,19 @@ function build_report() {
     role_modes: _role_mode_stats()
   };
 }
-function _print_text(report2) {
+function _print_text(report) {
   const out = [];
-  const b = report2.backend;
+  const b = report.backend;
   out.push(`Backend:   ${b.status} (backend=${b.backend})`);
   if (b.reason) {
     out.push(`           reason: ${b.reason}`);
   }
-  const intake = report2.intake;
+  const intake = report.intake;
   out.push(`Intake:    ${intake.total_active} active, ${intake.superseded} superseded`);
   for (const [t, n] of _sortedEntries(intake.by_type)) {
     out.push(`  - ${t}: ${n}`);
   }
-  const stale = report2.staleness;
+  const stale = report.staleness;
   if (stale.length === 0) {
     out.push("Staleness: no curated entries past review_after_days");
   } else {
@@ -1996,7 +722,7 @@ function _print_text(report2) {
       out.push(`  (+${stale.length - 5} more)`);
     }
   }
-  const q = report2.quarterly;
+  const q = report.quarterly;
   out.push(`Quarterly: staleness-rate=${_pyPercent1(q.staleness_rate.value)} (${q.curated_overdue}/${q.curated_total})`);
   if (Object.keys(q.accepted_by_quarter).length > 0) {
     const acc = _sortedEntries(q.accepted_by_quarter).map(([k, v]) => `${k}:${v}`).join(", ");
@@ -2006,7 +732,7 @@ function _print_text(report2) {
     const ret = _sortedEntries(q.retired_by_quarter).map(([k, v]) => `${k}:${v}`).join(", ");
     out.push(`  retired:  ${ret}`);
   }
-  const rm = report2.role_modes;
+  const rm = report.role_modes;
   if (rm.files_scanned) {
     out.push(`Role modes: ${rm.total_markers} marker(s) in ${rm.files_scanned} file(s)`);
     if (Object.keys(rm.by_mode).length > 0) {
@@ -2047,7 +773,7 @@ function _dumpsIndent(value, indent, depth) {
   if (value instanceof PyTimestamp) {
     return _jsonStrAscii(value.pyStr);
   }
-  if (value instanceof PyFloat2) {
+  if (value instanceof PyFloat) {
     return _jsonFloat(value.value);
   }
   if (Array.isArray(value)) {
@@ -2059,7 +785,7 @@ function _dumpsIndent(value, indent, depth) {
 ${items.join(",\n")}
 ${closePad}]`;
   }
-  if (_isPlainObject2(value)) {
+  if (_isPlainObject(value)) {
     const keys = Object.keys(value);
     if (keys.length === 0) {
       return "{}";
@@ -2141,7 +867,7 @@ function _escapeNonAscii2(s) {
 }
 var _PROG2 = "memory_report.py";
 var _USAGE2 = "usage: memory_report.py [-h] [--format {text,json}]\n";
-function _argError2(msg) {
+function _argError(msg) {
   process3.stderr.write(_USAGE2);
   process3.stderr.write(`${_PROG2}: error: ${msg}
 `);
@@ -2159,61 +885,61 @@ function _parseArgs2(argv) {
       process3.stdout.write(_USAGE2);
       process3.exit(0);
     } else {
-      _argError2(`unrecognized arguments: ${a}`);
+      _argError(`unrecognized arguments: ${a}`);
     }
   }
   return args;
 }
 function _checkChoice(value, choices, flag) {
   if (value === void 0 || !choices.includes(value)) {
-    _argError2(
+    _argError(
       `argument ${flag}: invalid choice: '${value ?? ""}' (choose from ${choices.map((c) => `'${c}'`).join(", ")})`
     );
   }
   return value;
 }
-function main3() {
+function main2() {
   const args = _parseArgs2(process3.argv.slice(2));
-  const report2 = build_report();
+  const report = build_report();
   if (args.format === "json") {
-    process3.stdout.write(`${pyJsonDumps(report2, 2)}
+    process3.stdout.write(`${pyJsonDumps(report, 2)}
 `);
   } else {
-    _print_text(report2);
+    _print_text(report);
   }
   return 0;
 }
-function _isCliEntry3() {
+function _isCliEntry2() {
   if (true) {
     return false;
   }
   if (process3.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL3(path4.resolve(process3.argv[1])).href;
+  const argvUrl = pathToFileURL2(path2.resolve(process3.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs4.realpathSync(fileURLToPath4(import.meta.url));
-    const argv = fs4.realpathSync(path4.resolve(process3.argv[1]));
+    const here = fs2.realpathSync(fileURLToPath2(import.meta.url));
+    const argv = fs2.realpathSync(path2.resolve(process3.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-var _isMain2 = _isCliEntry3();
+var _isMain2 = _isCliEntry2();
 if (_isMain2) {
-  process3.exit(main3());
+  process3.exit(main2());
 }
 
 // src/scripts/_lib/memory_fts_index.ts
-var MEMORY_INDEX_REL = path5.join("agents", "runtime", "state", "memory-index-v1.sqlite3");
+var MEMORY_INDEX_REL = path3.join("agents", "runtime", "state", "memory-index-v1.sqlite3");
 var SCHEMA_VERSION = 1;
 var CURATED_STATUS_EXCLUDE = /* @__PURE__ */ new Set(["deprecated", "archived", "superseded"]);
 var INDEX_TEXT_FIELDS = ["path", "key", "symptom", "feature", "rule", "body"];
 function resolveIndexPath(consumerRoot) {
-  return path5.join(consumerRoot ?? process.cwd(), MEMORY_INDEX_REL);
+  return path3.join(consumerRoot ?? process.cwd(), MEMORY_INDEX_REL);
 }
 function _pyStr(v) {
   if (v === void 0 || v === null) return "";
@@ -2229,7 +955,7 @@ function _entryIndexText(entry) {
   }
   return parts.join(" | ");
 }
-function _isPlainObject3(v) {
+function _isPlainObject2(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function _collectCurated(memoryRoot) {
@@ -2252,11 +978,11 @@ function _collectCurated(memoryRoot) {
 function _globJsonl2(intakeRoot) {
   let names;
   try {
-    names = fs5.readdirSync(intakeRoot);
+    names = fs3.readdirSync(intakeRoot);
   } catch {
     return [];
   }
-  return names.filter((n) => n.endsWith(".jsonl")).sort().map((n) => path5.join(intakeRoot, n));
+  return names.filter((n) => n.endsWith(".jsonl")).sort().map((n) => path3.join(intakeRoot, n));
 }
 function _collectIntake(intakeRoot) {
   const out = [];
@@ -2265,7 +991,7 @@ function _collectIntake(intakeRoot) {
     const superseded = /* @__PURE__ */ new Set();
     let content;
     try {
-      content = fs5.readFileSync(jsonl, "utf-8");
+      content = fs3.readFileSync(jsonl, "utf-8");
     } catch {
       continue;
     }
@@ -2278,7 +1004,7 @@ function _collectIntake(intakeRoot) {
       } catch {
         continue;
       }
-      if (!_isPlainObject3(obj)) continue;
+      if (!_isPlainObject2(obj)) continue;
       if (obj["type"] === "supersede") {
         const target = obj["supersedes"];
         if (typeof target === "string") superseded.add(target);
@@ -2302,7 +1028,7 @@ function _sourcesMaxMtimeMs(memoryRoot, intakeRoot) {
   let max = 0;
   const bump = (p) => {
     try {
-      const st = fs5.statSync(p);
+      const st = fs3.statSync(p);
       if (st.mtimeMs > max) max = st.mtimeMs;
     } catch {
     }
@@ -2310,21 +1036,21 @@ function _sourcesMaxMtimeMs(memoryRoot, intakeRoot) {
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs5.readdirSync(dir, { withFileTypes: true });
+      entries = fs3.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
-      const full = path5.join(dir, e.name);
+      const full = path3.join(dir, e.name);
       if (e.isDirectory()) walk(full);
       else if (e.isFile() && e.name.endsWith(".yml")) bump(full);
     }
   };
   let memEntries;
   try {
-    memEntries = fs5.readdirSync(memoryRoot, { withFileTypes: true });
+    memEntries = fs3.readdirSync(memoryRoot, { withFileTypes: true });
     for (const e of memEntries) {
-      const full = path5.join(memoryRoot, e.name);
+      const full = path3.join(memoryRoot, e.name);
       if (e.isFile() && e.name.endsWith(".yml")) bump(full);
       else if (e.isDirectory()) walk(full);
     }
@@ -2335,7 +1061,7 @@ function _sourcesMaxMtimeMs(memoryRoot, intakeRoot) {
 }
 var META_KEY_SOURCES_MTIME = "sources_mtime_ms";
 function isStale(indexPath, memoryRoot, intakeRoot) {
-  if (!fs5.existsSync(indexPath)) return true;
+  if (!fs3.existsSync(indexPath)) return true;
   let sqlite;
   try {
     sqlite = loadSqliteSync("memory_fts_index.isStale");
@@ -2361,11 +1087,11 @@ function isStale(indexPath, memoryRoot, intakeRoot) {
   }
 }
 function buildIndex(indexPath, memoryRoot, intakeRoot) {
-  fs5.mkdirSync(path5.dirname(indexPath), { recursive: true });
+  fs3.mkdirSync(path3.dirname(indexPath), { recursive: true });
   try {
-    fs5.rmSync(indexPath, { force: true });
-    fs5.rmSync(`${indexPath}-wal`, { force: true });
-    fs5.rmSync(`${indexPath}-shm`, { force: true });
+    fs3.rmSync(indexPath, { force: true });
+    fs3.rmSync(`${indexPath}-wal`, { force: true });
+    fs3.rmSync(`${indexPath}-shm`, { force: true });
   } catch {
   }
   const { DatabaseSync } = loadSqliteSync("memory_fts_index.buildIndex");
@@ -2449,39 +1175,40 @@ function queryIndex(indexPath, keys, types) {
 }
 
 // src/scripts/learning_sidecar.ts
-import { createHash as createHash2 } from "node:crypto";
-import * as fs6 from "node:fs";
-import * as path6 from "node:path";
+import { createHash } from "node:crypto";
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
 import process4 from "node:process";
-import { fileURLToPath as fileURLToPath5 } from "node:url";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 var PROG = "learning_sidecar.ts";
 var HALF_LIFE_DAYS = 30;
 var MIN_CORROBORATIONS = 2;
 var SIDECAR_NAME = ".agent-learning.json";
 var LESSONS_NAME = "LESSONS.md";
 var SCHEMA_VERSION2 = 1;
+var FORMATS = ["text", "json", "status"];
 function _parseTsMs(ts) {
   const t = Date.parse(ts);
   return Number.isNaN(t) ? null : t;
 }
 function _bodyHash(body) {
-  return createHash2("sha256").update(body.trim().toLowerCase()).digest("hex").slice(0, 12);
+  return createHash("sha256").update(body.trim().toLowerCase()).digest("hex").slice(0, 12);
 }
 function _globSignalFiles(dir) {
   let names;
   try {
-    names = fs6.readdirSync(dir);
+    names = fs4.readdirSync(dir);
   } catch {
     return [];
   }
-  return names.filter((n) => n.startsWith("signals-") && n.endsWith(".jsonl")).sort().map((n) => path6.join(dir, n));
+  return names.filter((n) => n.startsWith("signals-") && n.endsWith(".jsonl")).sort().map((n) => path4.join(dir, n));
 }
 function readSignals(intakeDir) {
   const out = [];
   for (const file of _globSignalFiles(intakeDir)) {
     let content;
     try {
-      content = fs6.readFileSync(file, "utf-8");
+      content = fs4.readFileSync(file, "utf-8");
     } catch {
       continue;
     }
@@ -2572,9 +1299,11 @@ function aggregate(signals, nowMs) {
   return lessons;
 }
 function buildSidecar(intakeDir, nowIso) {
+  return buildSidecarFromSignals(readSignals(intakeDir), nowIso);
+}
+function buildSidecarFromSignals(signals, nowIso) {
   const nowMs = _parseTsMs(nowIso) ?? 0;
-  const lessons = aggregate(readSignals(intakeDir), nowMs);
-  return { schema_version: SCHEMA_VERSION2, generated_at: nowIso, lessons };
+  return { schema_version: SCHEMA_VERSION2, generated_at: nowIso, lessons: aggregate(signals, nowMs) };
 }
 function renderLessonsMd(sidecar) {
   const dead = sidecar.lessons.filter((l) => l.verdict === "dead_end");
@@ -2604,9 +1333,42 @@ function renderLessonsMd(sidecar) {
   L.push("");
   return L.join("\n");
 }
-function main4(argv) {
-  let intakeDir = path6.join("agents", "memory", "intake");
-  let outDir = path6.join("agents", "memory");
+var STATUS_TOP_N = 5;
+var PROMOTION_HANDOFF = "Promote by hand: /memory:propose \xB7 src/skills/learning-to-rule-or-skill/SKILL.md";
+function renderStatus(sidecar) {
+  const byVerdict = { preferred: 0, contested: 0, dead_end: 0 };
+  for (const l of sidecar.lessons) byVerdict[l.verdict] += 1;
+  const nowMs = _parseTsMs(sidecar.generated_at) ?? 0;
+  const L = [];
+  L.push(`${PROG}: ${String(sidecar.lessons.length)} lesson(s) as of ${sidecar.generated_at}`);
+  L.push(
+    `preferred: ${String(byVerdict.preferred)} \xB7 contested: ${String(byVerdict.contested)} \xB7 dead-end: ${String(byVerdict.dead_end)}`
+  );
+  L.push("");
+  const preferred = sidecar.lessons.filter((l) => l.verdict === "preferred").sort((a, b) => b.score - a.score || (a.path < b.path ? -1 : 1)).slice(0, STATUS_TOP_N);
+  L.push(`Top ${String(STATUS_TOP_N)} preferred:`);
+  if (preferred.length === 0) {
+    L.push("  (none \u2014 a lesson needs corroboration before it appears here)");
+  } else {
+    preferred.forEach((l, i) => {
+      const ageDays = Math.max(0, Math.floor((nowMs - (_parseTsMs(l.last_ts) ?? nowMs)) / 864e5));
+      L.push(
+        `  ${String(i + 1)}. ${l.entry_type} @ ${l.path} \u2014 ${String(l.corroborations)} origins, ${String(ageDays)}d old`
+      );
+      L.push(`     ${l.body}`);
+    });
+  }
+  L.push("");
+  L.push(
+    `A lesson is promoted at ${String(MIN_CORROBORATIONS)} distinct origins, weighted by a ${String(HALF_LIFE_DAYS)}-day half-life; nothing here promotes itself.`
+  );
+  L.push(PROMOTION_HANDOFF);
+  return `${L.join("\n")}
+`;
+}
+function main3(argv) {
+  let intakeDir = path4.join("agents", "memory", "intake");
+  let outDir = path4.join("agents", "memory");
   let nowIso = "";
   let write = false;
   let format = "text";
@@ -2616,10 +1378,19 @@ function main4(argv) {
     else if (a === "--out-dir") outDir = argv[++i] ?? outDir;
     else if (a === "--now") nowIso = argv[++i] ?? "";
     else if (a === "--write") write = true;
-    else if (a === "--format") format = argv[++i] ?? "text";
-    else if (a === "-h" || a === "--help") {
+    else if (a === "--format") {
+      const raw = argv[++i] ?? "";
+      if (!FORMATS.includes(raw)) {
+        process4.stderr.write(
+          `${PROG}: error: argument --format: invalid choice: '${raw}' (choose from ${FORMATS.map((f) => `'${f}'`).join(", ")})
+`
+        );
+        return 2;
+      }
+      format = raw;
+    } else if (a === "-h" || a === "--help") {
       process4.stdout.write(
-        `usage: ${PROG} [--intake-dir DIR] [--out-dir DIR] [--now ISO] [--write] [--format text|json]
+        `usage: ${PROG} [--intake-dir DIR] [--out-dir DIR] [--now ISO] [--write] [--format ${FORMATS.join("|")}]
 `
       );
       return 0;
@@ -2629,6 +1400,11 @@ function main4(argv) {
       return 2;
     }
   }
+  if (format === "status" && write) {
+    process4.stderr.write(`${PROG}: error: --format status is read-only; drop --write
+`);
+    return 2;
+  }
   if (!nowIso) {
     nowIso = (/* @__PURE__ */ new Date(0)).toISOString();
   }
@@ -2641,14 +1417,18 @@ function main4(argv) {
     return 3;
   }
   if (write) {
-    fs6.mkdirSync(outDir, { recursive: true });
-    fs6.writeFileSync(path6.join(outDir, SIDECAR_NAME), JSON.stringify(sidecar, null, 2) + "\n");
-    fs6.writeFileSync(path6.join(outDir, LESSONS_NAME), renderLessonsMd(sidecar));
+    fs4.mkdirSync(outDir, { recursive: true });
+    fs4.writeFileSync(path4.join(outDir, SIDECAR_NAME), JSON.stringify(sidecar, null, 2) + "\n");
+    fs4.writeFileSync(path4.join(outDir, LESSONS_NAME), renderLessonsMd(sidecar));
   }
   if (format === "json") {
     process4.stdout.write(JSON.stringify(sidecar, null, 2) + "\n");
     return 0;
   }
+  if (format === "status") {
+    process4.stdout.write(renderStatus(sidecar));
+    return 0;
+  }
   const byVerdict = { preferred: 0, contested: 0, dead_end: 0 };
   for (const l of sidecar.lessons) byVerdict[l.verdict] += 1;
   process4.stdout.write(
@@ -2658,8 +1438,8 @@ function main4(argv) {
   return 0;
 }
 var _bundled = true;
-if (!_bundled && fileURLToPath5(import.meta.url) === path6.resolve(process4.argv[1] ?? "")) {
-  process4.exit(main4(process4.argv.slice(2)));
+if (!_bundled && fileURLToPath3(import.meta.url) === path4.resolve(process4.argv[1] ?? "")) {
+  process4.exit(main3(process4.argv.slice(2)));
 }
 
 // src/scripts/memory_lookup.ts
@@ -2674,15 +1454,15 @@ var PyTimestamp2 = class {
     return this.pyStr;
   }
 };
-var PyFloat3 = class {
+var PyFloat2 = class {
   constructor(value) {
     this.value = value;
   }
   value;
 };
-var MEMORY_ROOT2 = path7.join("agents", "memory");
-var INTAKE_ROOT2 = path7.join(MEMORY_ROOT2, "intake");
-var KNOWLEDGE_ROOT = path7.join(MEMORY_ROOT2, "knowledge");
+var MEMORY_ROOT2 = path5.join("agents", "memory");
+var INTAKE_ROOT2 = path5.join(MEMORY_ROOT2, "intake");
+var KNOWLEDGE_ROOT = path5.join(MEMORY_ROOT2, "knowledge");
 var _LEX_TYPE_FILES_MAX = 200;
 var _LEX_CORPUS_FILES_MAX = 500;
 var _LEX_SOURCE_FACTOR = { curated: 1, intake: 0.9, knowledge: 0.85 };
@@ -2691,17 +1471,17 @@ var _corpusFileCounts = null;
 var _learningOverlay;
 function _loadLearningOverlay() {
   if (_learningOverlay !== void 0) return _learningOverlay;
-  const file = path7.join(MEMORY_ROOT2, SIDECAR_NAME);
+  const file = path5.join(MEMORY_ROOT2, SIDECAR_NAME);
   try {
-    const parsed = JSON.parse(fs7.readFileSync(file, "utf-8"));
-    const lessons = _isPlainObject4(parsed) ? parsed["lessons"] : null;
+    const parsed = JSON.parse(fs5.readFileSync(file, "utf-8"));
+    const lessons = _isPlainObject3(parsed) ? parsed["lessons"] : null;
     if (!Array.isArray(lessons)) {
       _learningOverlay = null;
       return null;
     }
     const map = /* @__PURE__ */ new Map();
     for (const l of lessons) {
-      if (!_isPlainObject4(l)) continue;
+      if (!_isPlainObject3(l)) continue;
       const t = l["entry_type"];
       const p = l["path"];
       const v = l["verdict"];
@@ -2761,30 +1541,30 @@ var Hit = class {
       source: this.source,
       path: this.path,
       // score is a Python float — render `0.0` not `0` for whole numbers.
-      score: new PyFloat3(this.score),
+      score: new PyFloat2(this.score),
       entry: this.entry
     };
   }
 };
-function _isPlainObject4(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v) && !(v instanceof PyTimestamp2) && !(v instanceof PyFloat3);
+function _isPlainObject3(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) && !(v instanceof PyTimestamp2) && !(v instanceof PyFloat2);
 }
 function _isFile2(p) {
   try {
-    return fs7.statSync(p).isFile();
+    return fs5.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function _isDir2(p) {
   try {
-    return fs7.statSync(p).isDirectory();
+    return fs5.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function _load_yaml2(p) {
-  const text = fs7.readFileSync(p, "utf-8");
+  const text = fs5.readFileSync(p, "utf-8");
   const doc = (0, import_yaml2.parseDocument)(text, { version: "1.1", prettyErrors: false });
   if (doc.errors.length > 0) {
     const err = doc.errors[0];
@@ -2842,13 +1622,13 @@ function _pad22(v) {
   return v.length === 1 ? `0${v}` : v;
 }
 function* _iter_curated_entries2(mtype) {
-  const type_dir = path7.join(MEMORY_ROOT2, mtype);
-  const single_file = path7.join(MEMORY_ROOT2, `${mtype}.yml`);
+  const type_dir = path5.join(MEMORY_ROOT2, mtype);
+  const single_file = path5.join(MEMORY_ROOT2, `${mtype}.yml`);
   if (_isFile2(single_file)) {
     const data = _load_yaml2(single_file);
-    const entries = _isPlainObject4(data) ? data["entries"] : null;
+    const entries = _isPlainObject3(data) ? data["entries"] : null;
     for (const e of Array.isArray(entries) ? entries : []) {
-      if (_isPlainObject4(e)) {
+      if (_isPlainObject3(e)) {
         if (_statusExcluded(e)) {
           continue;
         }
@@ -2860,17 +1640,17 @@ function* _iter_curated_entries2(mtype) {
     for (const yml of _rglobYmlSorted(type_dir)) {
       const dataRaw = _load_yaml2(yml);
       const data = dataRaw == null ? {} : dataRaw;
-      const entries = _isPlainObject4(data) ? data["entries"] : void 0;
+      const entries = _isPlainObject3(data) ? data["entries"] : void 0;
       if (Array.isArray(entries)) {
         for (const e of entries) {
-          if (_isPlainObject4(e)) {
+          if (_isPlainObject3(e)) {
             if (_statusExcluded(e)) {
               continue;
             }
             yield [yml, e];
           }
         }
-      } else if (_isPlainObject4(data) && data["id"]) {
+      } else if (_isPlainObject3(data) && data["id"]) {
         if (_statusExcluded(data)) {
           continue;
         }
@@ -2880,13 +1660,13 @@ function* _iter_curated_entries2(mtype) {
   }
 }
 function* _iter_curated_entries_all(mtype) {
-  const type_dir = path7.join(MEMORY_ROOT2, mtype);
-  const single_file = path7.join(MEMORY_ROOT2, `${mtype}.yml`);
+  const type_dir = path5.join(MEMORY_ROOT2, mtype);
+  const single_file = path5.join(MEMORY_ROOT2, `${mtype}.yml`);
   if (_isFile2(single_file)) {
     const data = _load_yaml2(single_file);
-    const entries = _isPlainObject4(data) ? data["entries"] : null;
+    const entries = _isPlainObject3(data) ? data["entries"] : null;
     for (const e of Array.isArray(entries) ? entries : []) {
-      if (_isPlainObject4(e)) {
+      if (_isPlainObject3(e)) {
         yield [single_file, e];
       }
     }
@@ -2895,14 +1675,14 @@ function* _iter_curated_entries_all(mtype) {
     for (const yml of _rglobYmlSorted(type_dir)) {
       const dataRaw = _load_yaml2(yml);
       const data = dataRaw == null ? {} : dataRaw;
-      const entries = _isPlainObject4(data) ? data["entries"] : void 0;
+      const entries = _isPlainObject3(data) ? data["entries"] : void 0;
       if (Array.isArray(entries)) {
         for (const e of entries) {
-          if (_isPlainObject4(e)) {
+          if (_isPlainObject3(e)) {
             yield [yml, e];
           }
         }
-      } else if (_isPlainObject4(data) && data["id"]) {
+      } else if (_isPlainObject3(data) && data["id"]) {
         yield [yml, data];
       }
     }
@@ -2915,7 +1695,7 @@ function* _iter_intake_entries(mtype) {
   for (const jsonl of _globJsonlSorted(INTAKE_ROOT2)) {
     const by_id = /* @__PURE__ */ new Map();
     const superseded = /* @__PURE__ */ new Set();
-    const content = fs7.readFileSync(jsonl, "utf-8");
+    const content = fs5.readFileSync(jsonl, "utf-8");
     for (let line of content.split(/\n/)) {
       line = line.trim();
       if (!line) {
@@ -2927,7 +1707,7 @@ function* _iter_intake_entries(mtype) {
       } catch {
         continue;
       }
-      if (!_isPlainObject4(obj)) {
+      if (!_isPlainObject3(obj)) {
         continue;
       }
       if (obj["type"] === "supersede") {
@@ -2961,27 +1741,27 @@ function* _iter_knowledge_entries() {
     if (!_isDir2(ingest_dir)) {
       continue;
     }
-    const manifest_path = path7.join(ingest_dir, "manifest.json");
+    const manifest_path = path5.join(ingest_dir, "manifest.json");
     let manifest = {};
     if (_isFile2(manifest_path)) {
       try {
-        const parsed = JSON.parse(fs7.readFileSync(manifest_path, "utf-8"));
-        manifest = _isPlainObject4(parsed) ? parsed : {};
+        const parsed = JSON.parse(fs5.readFileSync(manifest_path, "utf-8"));
+        manifest = _isPlainObject3(parsed) ? parsed : {};
       } catch {
         manifest = {};
       }
     }
-    const ingest_id = String(manifest["ingest_id"] || path7.basename(ingest_dir));
+    const ingest_id = String(manifest["ingest_id"] || path5.basename(ingest_dir));
     const source = String(manifest["source"] || "");
     const pinned = Boolean(manifest["pinned"] ?? false);
-    const chunks_dir = path7.join(ingest_dir, "chunks");
+    const chunks_dir = path5.join(ingest_dir, "chunks");
     if (!_isDir2(chunks_dir)) {
       continue;
     }
     for (const chunk of _globMdSorted(chunks_dir)) {
       let body;
       try {
-        body = fs7.readFileSync(chunk, "utf-8");
+        body = fs5.readFileSync(chunk, "utf-8");
       } catch {
         continue;
       }
@@ -3083,7 +1863,7 @@ function _entry_id(mtype, file, entry, ordinals) {
   if (own !== void 0 && own !== null && String(own).trim() !== "") {
     return String(own);
   }
-  return `${mtype}:${path7.basename(file)}:${ordinal}`;
+  return `${mtype}:${path5.basename(file)}:${ordinal}`;
 }
 function _entry_title(entry, id) {
   for (const field of ["title", "key", "path"]) {
@@ -3108,7 +1888,7 @@ var _tokenizer;
 function _lazy_tokenizer() {
   if (_tokenizer === void 0) {
     try {
-      const req = createRequire2(import.meta.url);
+      const req = createRequire(import.meta.url);
       _tokenizer = req("./_lib/token_count.js");
     } catch {
       _tokenizer = null;
@@ -3127,13 +1907,13 @@ function _entry_tokens_estimate(envelope_entry) {
 function _countMdFiles(dir) {
   let entries;
   try {
-    entries = fs7.readdirSync(dir, { withFileTypes: true });
+    entries = fs5.readdirSync(dir, { withFileTypes: true });
   } catch {
     return 0;
   }
   let n = 0;
   for (const e of entries) {
-    if (e.isDirectory()) n += _countMdFiles(path7.join(dir, e.name));
+    if (e.isDirectory()) n += _countMdFiles(path5.join(dir, e.name));
     else if (e.isFile() && e.name.endsWith(".md")) n += 1;
   }
   return n;
@@ -3143,7 +1923,7 @@ function _countCorpusFiles() {
   const perType = /* @__PURE__ */ new Map();
   let total = 0;
   for (const t of CURATED_TYPES2) {
-    const exists = fs7.existsSync(path7.join(MEMORY_ROOT2, `${t}.yml`));
+    const exists = fs5.existsSync(path5.join(MEMORY_ROOT2, `${t}.yml`));
     const c = exists ? 1 : 0;
     perType.set(t, c);
     total += c;
@@ -3152,7 +1932,7 @@ function _countCorpusFiles() {
   perType.set(KNOWLEDGE_TYPE, kn);
   total += kn;
   try {
-    for (const e of fs7.readdirSync(INTAKE_ROOT2, { withFileTypes: true })) {
+    for (const e of fs5.readdirSync(INTAKE_ROOT2, { withFileTypes: true })) {
       if (e.isFile() && e.name.endsWith(".jsonl")) total += 1;
     }
   } catch {
@@ -3300,7 +2080,7 @@ function _retrieve_internal(types, keys, limit, today) {
   }
   const hits = (positives.length > 0 ? positives : repo_hits).slice(0, limit);
   for (const h of hits) {
-    if (_isPlainObject4(h.entry)) h.entry = sanitize_entry(h.entry);
+    if (_isPlainObject3(h.entry)) h.entry = sanitize_entry(h.entry);
   }
   return [hits, skipped];
 }
@@ -3344,7 +2124,7 @@ function retrieve_v1(types, keys, limit = 20, options = {}) {
   let truncation = null;
   for (let hi = 0; hi < hits.length; hi++) {
     const h = hits[hi];
-    const safeEntry = _isPlainObject4(h.entry) ? sanitize_entry(h.entry) : {};
+    const safeEntry = _isPlainObject3(h.entry) ? sanitize_entry(h.entry) : {};
     const learning = _learningVerdictFor(h.type, safeEntry);
     if (learning !== void 0) safeEntry["learning"] = learning;
     if (budgeted) {
@@ -3364,7 +2144,7 @@ function retrieve_v1(types, keys, limit = 20, options = {}) {
         id: h.id,
         type: h.type,
         source: "repo",
-        confidence: new PyFloat3(_round4(h.score)),
+        confidence: new PyFloat2(_round4(h.score)),
         line,
         ...learning !== void 0 ? { learning } : {}
       });
@@ -3378,7 +2158,7 @@ function retrieve_v1(types, keys, limit = 20, options = {}) {
       type: h.type,
       source: "repo",
       // confidence = round(float(score), 4) — always a Python float.
-      confidence: new PyFloat3(_round4(h.score)),
+      confidence: new PyFloat2(_round4(h.score)),
       body: safeEntry
     };
     if (h.type in slice_counts) {
@@ -3389,7 +2169,7 @@ function retrieve_v1(types, keys, limit = 20, options = {}) {
         id: h.id,
         type: h.type,
         source: "repo",
-        confidence: new PyFloat3(_round4(h.score)),
+        confidence: new PyFloat2(_round4(h.score)),
         title: _entry_title(safeEntry, h.id),
         tokens_estimate: _entry_tokens_estimate(envelope_entry),
         // Knowledge chunks carry their pinned flag in the index row
@@ -3438,7 +2218,7 @@ function memory_get_v1(ids) {
   const found = /* @__PURE__ */ new Map();
   const record = (id, mtype, entry) => {
     if (wanted.has(id) && !found.has(id)) {
-      const safeEntry = _isPlainObject4(entry) ? sanitize_entry(entry) : {};
+      const safeEntry = _isPlainObject3(entry) ? sanitize_entry(entry) : {};
       const learning = _learningVerdictFor(mtype, safeEntry);
       if (learning !== void 0) safeEntry["learning"] = learning;
       found.set(id, {
@@ -3563,7 +2343,7 @@ function _printUsage() {
     "usage: memory_lookup [-h] [--types TYPES] [--key KEY] [--limit LIMIT] [--format {text,json}] [--envelope {legacy,v1}] [--detail {index,full}] [--token-budget N]\n"
   );
 }
-function main5() {
+function main4() {
   const args = _parseArgs3(process5.argv.slice(2));
   const types = args.types.split(",").map((t) => t.trim()).filter((t) => t);
   if (types.length === 0) {
@@ -3710,12 +2490,12 @@ function _rglobYmlSorted(root) {
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs7.readdirSync(dir, { withFileTypes: true });
+      entries = fs5.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const ent of entries) {
-      const full = path7.join(dir, ent.name);
+      const full = path5.join(dir, ent.name);
       if (ent.name.endsWith(".yml")) {
         out.push(full);
       }
@@ -3737,27 +2517,27 @@ function _globMdSorted(dir) {
 function _globSorted(dir, suffix) {
   let entries;
   try {
-    entries = fs7.readdirSync(dir, { withFileTypes: true });
+    entries = fs5.readdirSync(dir, { withFileTypes: true });
   } catch {
     return [];
   }
-  const out = entries.filter((e) => e.name.endsWith(suffix) && (e.isFile() || e.isSymbolicLink() && _isFile2(path7.join(dir, e.name)))).map((e) => path7.join(dir, e.name));
+  const out = entries.filter((e) => e.name.endsWith(suffix) && (e.isFile() || e.isSymbolicLink() && _isFile2(path5.join(dir, e.name)))).map((e) => path5.join(dir, e.name));
   out.sort();
   return out;
 }
 function _iterdirSorted(dir) {
   let names;
   try {
-    names = fs7.readdirSync(dir);
+    names = fs5.readdirSync(dir);
   } catch {
     return [];
   }
-  const out = names.map((name) => path7.join(dir, name));
+  const out = names.map((name) => path5.join(dir, name));
   out.sort();
   return out;
 }
 function _stem(p) {
-  const base = path7.basename(p);
+  const base = path5.basename(p);
   const dot = base.lastIndexOf(".");
   return dot <= 0 ? base : base.slice(0, dot);
 }
@@ -3782,7 +2562,7 @@ function _dumpsIndent2(value, indent, depth) {
   if (value instanceof PyTimestamp2) {
     return _jsonStrAscii2(value.pyStr);
   }
-  if (value instanceof PyFloat3) {
+  if (value instanceof PyFloat2) {
     return _jsonFloat2(value.value);
   }
   if (Array.isArray(value)) {
@@ -3794,7 +2574,7 @@ function _dumpsIndent2(value, indent, depth) {
 ${items.join(",\n")}
 ${closePad}]`;
   }
-  if (_isPlainObject4(value)) {
+  if (_isPlainObject3(value)) {
     const keys = Object.keys(value);
     if (keys.length === 0) {
       return "{}";
@@ -3874,25 +2654,25 @@ function _escapeNonAscii3(s) {
   }
   return out;
 }
-function _isCliEntry4() {
+function _isCliEntry3() {
   if (process5.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL4(path7.resolve(process5.argv[1])).href;
+  const argvUrl = pathToFileURL3(path5.resolve(process5.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs7.realpathSync(fileURLToPath6(import.meta.url));
-    const argv = fs7.realpathSync(path7.resolve(process5.argv[1]));
+    const here = fs5.realpathSync(fileURLToPath4(import.meta.url));
+    const argv = fs5.realpathSync(path5.resolve(process5.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-var _isMain3 = _isCliEntry4();
+var _isMain3 = _isCliEntry3();
 if (_isMain3) {
-  process5.exit(main5());
+  process5.exit(main4());
 }
 
 export {