@event4u/agent-config 9.16.0 → 9.18.0

package/dist/cli-delegate/cmd_memory_get.js

@@ -1,3737 +1,18 @@
 #!/usr/bin/env tsx
 import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
 import {
-  require_dist
-} from "./chunk-OY53J6II.js";
-import {
-  __toESM
-} from "./chunk-J55WI3RR.js";
-
-// src/scripts/_cli/cmd_memory_get.ts
-import process6 from "node:process";
-import * as fs8 from "node:fs";
-import * as path8 from "node:path";
-import { fileURLToPath as fileURLToPath7, pathToFileURL as pathToFileURL5 } from "node:url";
-
-// 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 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 * 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*-->/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 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
-  weight;
-  constructor(pathArg, rel, lines, in_example_fence, in_any_fence, pragmas, weight) {
-    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;
-  }
-  pragma_allows(check) {
-    return Object.prototype.hasOwnProperty.call(this.pragmas, check);
-  }
-  /** 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 = {};
-  for (const text of lines) {
-    _PRAGMA.lastIndex = 0;
-    let m;
-    while ((m = _PRAGMA.exec(text)) !== null) {
-      pragmas[m[1]] = m[2];
-      if (m.index === _PRAGMA.lastIndex) {
-        _PRAGMA.lastIndex += 1;
-      }
-    }
-  }
-  return new ScannedFile(
-    filePath,
-    rel,
-    lines,
-    in_example,
-    in_any,
-    pragmas,
-    path_weight(rel)
-  );
-}
-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"]) {
-  for (const root of roots) {
-    const base = path.join(ROOT, 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_file(p);
-      }
-    }
-  }
-}
-function report(findings, opts) {
-  const check_label = opts.check_label;
-  if (findings.length === 0) {
-    process.stdout.write(`\u2705  ${check_label}: clean (${_corpus_note()}).
-`);
-    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() {
-  return "scanned " + DEFAULT_SCAN_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) {
-  if (sf.pragma_allows(CHECK)) {
-    return [];
-  }
-  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 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]\n");
-  process.stderr.write(`lint_hidden_unicode: error: ${msg}
-`);
-  process.exit(2);
-}
-function parse_args(argv) {
-  const out = { json: false, fix: false };
-  const extra = [];
-  for (const a of argv) {
-    if (a === "-h" || a === "--help") {
-      process.stdout.write("usage: lint_hidden_unicode [-h] [--json] [--fix]\n");
-      process.exit(0);
-    } else if (a === "--json") {
-      out.json = true;
-    } else if (a === "--fix") {
-      out.fix = 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 findings = [];
-  const flagged = /* @__PURE__ */ new Set();
-  for (const sf of iter_corpus()) {
-    const hits = _scan(sf);
-    for (const h of hits) {
-      findings.push(h);
-    }
-    if (hits.length > 0) {
-      flagged.add(sf.path);
-    }
-  }
-  const sourceFiles = _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) {
-    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");
-
-// src/scripts/_lib/retrieval_sanitize.ts
-var MAX_FIELD_CHARS = 8192;
-var _INVISIBLE_FILLERS = /* @__PURE__ */ new Set([
-  12644,
-  // HANGUL FILLER
-  4447,
-  // HANGUL CHOSEONG FILLER
-  4448
-  // HANGUL JUNGSEONG FILLER
-]);
-function _isStrippableControl(cp) {
-  if (cp === 9 || cp === 10) return false;
-  if (cp <= 31) return true;
-  if (cp === 127) return true;
-  if (cp >= 128 && cp <= 159) return true;
-  return false;
-}
-function sanitize_text(s) {
-  let out = "";
-  for (const ch of s) {
-    const cp = ch.codePointAt(0);
-    if (cp === void 0) continue;
-    if (_classify(cp) !== null) continue;
-    if (_isStrippableControl(cp)) continue;
-    if (_INVISIBLE_FILLERS.has(cp)) continue;
-    out += ch;
-  }
-  return out.length > MAX_FIELD_CHARS ? out.slice(0, MAX_FIELD_CHARS) : out;
-}
-function sanitize_entry(entry) {
-  const out = {};
-  for (const [k, v] of Object.entries(entry)) {
-    out[k] = _sanitize_value(v);
-  }
-  return out;
-}
-function _sanitize_value(v) {
-  if (typeof v === "string") return sanitize_text(v);
-  if (Array.isArray(v)) return v.map((x) => typeof x === "string" ? sanitize_text(x) : _sanitize_value(x));
-  if (v && typeof v === "object" && v.constructor === Object) {
-    return sanitize_entry(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}`);
-}
-
-// 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 process3 from "node:process";
-import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL3 } 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";
-var CONTRACT_VERSION = 1;
-var _FILE_BACKEND_VERSION = "0.0.0-file";
-var _FILE_BACKEND_FEATURES = ["file-fallback"];
-function status(_refresh = false) {
-  return {
-    status: "file",
-    // always "file" — no external backend
-    backend: "file",
-    reason: "file-backed memory (no external backend)",
-    elapsed_ms: 0
-  };
-}
-function health(_refresh = false) {
-  return {
-    contract_version: CONTRACT_VERSION,
-    status: "ok",
-    backend_version: _FILE_BACKEND_VERSION,
-    features: [..._FILE_BACKEND_FEATURES]
-  };
-}
-function _pyJsonDumps(value) {
-  return _escapeNonAscii(_pyCompactSeparators(JSON.stringify(value)));
-}
-function _pyCompactSeparators(json) {
-  let result = "";
-  let inString = false;
-  let escaped = false;
-  for (let i = 0; i < json.length; i += 1) {
-    const ch = json[i];
-    result += ch;
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (ch === "\\") {
-      escaped = true;
-      continue;
-    }
-    if (ch === '"') {
-      inString = !inString;
-      continue;
-    }
-    if (!inString && (ch === "," || ch === ":")) {
-      result += " ";
-    }
-  }
-  return result;
-}
-function _escapeNonAscii(s) {
-  let out = "";
-  for (const ch of s) {
-    const code = ch.codePointAt(0) ?? 0;
-    if (code > 127) {
-      for (let i = 0; i < ch.length; i += 1) {
-        out += `\\u${ch.charCodeAt(i).toString(16).padStart(4, "0")}`;
-      }
-    } else {
-      out += ch;
-    }
-  }
-  return out;
-}
-var _PROG = "memory_status.py";
-var _USAGE = "usage: memory_status.py [-h] [--format {text,json}] [--refresh] [--health]\n";
-var _ExitError = class extends Error {
-  constructor(code) {
-    super(`exit ${code}`);
-    this.code = code;
-  }
-  code;
-};
-function _usageError(msg) {
-  process2.stderr.write(_USAGE);
-  process2.stderr.write(`${_PROG}: error: ${msg}
-`);
-  throw new _ExitError(2);
-}
-function _parseArgs(argv) {
-  const args = { format: "text", refresh: false, health: false };
-  const checkFormat = (v) => {
-    if (v !== "text" && v !== "json") {
-      _usageError(`argument --format: invalid choice: '${v}' (choose from 'text', 'json')`);
-    }
-    return v;
-  };
-  for (let i = 0; i < argv.length; i += 1) {
-    const a = argv[i];
-    const takeValue = (flag) => {
-      const v = argv[++i];
-      if (v === void 0) {
-        _usageError(`argument ${flag}: expected one argument`);
-      }
-      return v;
-    };
-    if (a === "--format") {
-      args.format = checkFormat(takeValue("--format"));
-    } else if (a.startsWith("--format=")) {
-      args.format = checkFormat(a.slice("--format=".length));
-    } else if (a === "--refresh") {
-      args.refresh = true;
-    } else if (a === "--health") {
-      args.health = true;
-    } else if (a === "-h" || a === "--help") {
-      process2.stdout.write(_USAGE);
-      throw new _ExitError(0);
-    } else {
-      _usageError(`unrecognized arguments: ${a}`);
-    }
-  }
-  return args;
-}
-function main2() {
-  const args = _parseArgs(process2.argv.slice(2));
-  if (args.health) {
-    process2.stdout.write(`${_pyJsonDumps(health())}
-`);
-    return 0;
-  }
-  const r = status();
-  if (args.format === "json") {
-    process2.stdout.write(`${_pyJsonDumps(r)}
-`);
-  } else {
-    process2.stdout.write(`  \u2139\uFE0F  backend=${r.backend}  status=${r.status}  reason=${r.reason}
-`);
-  }
-  return 0;
-}
-function _isCliEntry2() {
-  if (true) {
-    return false;
-  }
-  if (process2.argv[1] === void 0) {
-    return false;
-  }
-  const argvUrl = pathToFileURL2(path3.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]));
-    return here === argv;
-  } catch {
-    return false;
-  }
-}
-var _isMain = _isCliEntry2();
-if (_isMain) {
-  try {
-    process2.exitCode = main2();
-  } catch (e) {
-    if (e instanceof _ExitError) {
-      process2.exitCode = e.code;
-    } else {
-      throw e;
-    }
-  }
-}
-
-// src/scripts/memory_report.ts
-var MEMORY_ROOT = path4.join("agents", "memory");
-var INTAKE_ROOT = path4.join(MEMORY_ROOT, "intake");
-function _setMemoryRoot(p) {
-  MEMORY_ROOT = p;
-}
-var CURATED_TYPES = [
-  "ownership",
-  "historical-patterns",
-  "domain-invariants",
-  "incident-learnings",
-  "product-rules"
-];
-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")
-];
-var _KNOWN_MODES = /* @__PURE__ */ new Set([
-  "developer",
-  "reviewer",
-  "tester",
-  "po",
-  "incident",
-  "planner"
-]);
-var PYYAML_DATE_ONLY_RE = /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/;
-var PYYAML_TIMESTAMP_RE = /^(?:[0-9]{4}-[0-9]{2}-[0-9]{2}|[0-9]{4}-[0-9]{1,2}-[0-9]{1,2}(?:[Tt]|[ \t]+)[0-9]{1,2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]*)?(?:[ \t]*(?:Z|[-+][0-9]{1,2}(?::[0-9]{2})?))?)$/;
-var PyTimestamp = class {
-  constructor(pyStr) {
-    this.pyStr = pyStr;
-  }
-  pyStr;
-  toString() {
-    return this.pyStr;
-  }
-};
-var PyFloat2 = 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 _isFile(p) {
-  try {
-    return fs4.statSync(p).isFile();
-  } catch {
-    return false;
-  }
-}
-function _isDir(p) {
-  try {
-    return fs4.statSync(p).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function _load_yaml(p) {
-  const text = fs4.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];
-    throw new Error(err ? err.message : "YAML parse error");
-  }
-  import_yaml.default.visit(doc, {
-    Scalar(_key, node) {
-      if (!node.range) {
-        return;
-      }
-      const raw = text.slice(node.range[0], node.range[1]);
-      if (node.value instanceof Date) {
-        if (PYYAML_DATE_ONLY_RE.test(raw)) {
-          node.value = new PyTimestamp(raw);
-        } else if (PYYAML_TIMESTAMP_RE.test(raw)) {
-          node.value = new PyTimestamp(_pyYamlDatetimeStr(raw));
-        }
-        return;
-      }
-      if (typeof node.value === "boolean" && node.type === "PLAIN" && /^[ynYN]$/.test(raw)) {
-        node.value = raw;
-      }
-    }
-  });
-  const data = doc.toJS({ mapAsMap: false });
-  return data == null ? {} : data;
-}
-function _pad2(v) {
-  return v.padStart(2, "0");
-}
-function _pyYamlDatetimeStr(raw) {
-  const m = /^(\d{4})-(\d{1,2})-(\d{1,2})(?:[Tt]|[ \t]+)(\d{1,2}):(\d{2}):(\d{2})(?:\.(\d*))?(?:[ \t]*(Z|[-+]\d{1,2}(?::\d{2})?))?$/.exec(
-    raw
-  );
-  if (!m) {
-    return raw;
-  }
-  const [, y, mo, d, h, mi, s, frac, tz] = m;
-  const date = `${y}-${_pad2(mo)}-${_pad2(d)}`;
-  let time = `${_pad2(h)}:${mi}:${s}`;
-  if (frac && /[1-9]/.test(frac)) {
-    time += `.${(frac + "000000").slice(0, 6)}`;
-  }
-  let off = "";
-  if (tz) {
-    if (tz === "Z") {
-      off = "+00:00";
-    } else {
-      const tm = /^([-+])(\d{1,2})(?::(\d{2}))?$/.exec(tz);
-      if (tm) {
-        off = `${tm[1]}${_pad2(tm[2])}:${tm[3] ?? "00"}`;
-      }
-    }
-  }
-  return `${date} ${time}${off}`;
-}
-function _iter_curated_entries() {
-  const out = [];
-  for (const mtype of CURATED_TYPES) {
-    const single = path4.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)) {
-            out.push([single, mtype, e]);
-          }
-        }
-      }
-    }
-    const type_dir = path4.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)) {
-              out.push([yml, mtype, e]);
-            }
-          }
-        } else if (_isPlainObject2(data) && data["id"]) {
-          out.push([yml, mtype, data]);
-        }
-      }
-    }
-  }
-  return out;
-}
-function _rglobYml(root) {
-  const found = [];
-  const walk = (dir) => {
-    let entries;
-    try {
-      entries = fs4.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const ent of entries) {
-      const full = path4.join(dir, ent.name);
-      if (ent.isDirectory()) {
-        walk(full);
-      } else if (ent.isFile() && ent.name.endsWith(".yml")) {
-        found.push(full);
-      }
-    }
-  };
-  walk(root);
-  found.sort();
-  return found;
-}
-function _globJsonl(root) {
-  let names;
-  try {
-    names = fs4.readdirSync(root);
-  } catch {
-    return [];
-  }
-  return names.filter((n) => n.endsWith(".jsonl")).sort().map((n) => path4.join(root, n));
-}
-function _intake_stats() {
-  let total = 0;
-  const by_type = /* @__PURE__ */ new Map();
-  const by_month = /* @__PURE__ */ new Map();
-  let superseded = 0;
-  if (_isDir(INTAKE_ROOT)) {
-    for (const jsonl of _globJsonl(INTAKE_ROOT)) {
-      const stem = path4.basename(jsonl).replace(/\.jsonl$/, "");
-      const month = stem.replace("signals-", "");
-      for (const obj of _readJsonl(jsonl)) {
-        if (obj["type"] === "supersede") {
-          superseded += 1;
-          continue;
-        }
-        total += 1;
-        const t = obj["entry_type"];
-        if (typeof t === "string") {
-          by_type.set(t, (by_type.get(t) ?? 0) + 1);
-        }
-        by_month.set(month, (by_month.get(month) ?? 0) + 1);
-      }
-    }
-  }
-  return {
-    total_active: total,
-    superseded,
-    by_type: _mapToObj(by_type),
-    by_month: _mapToObj(by_month)
-  };
-}
-function _readJsonl(p) {
-  let text;
-  try {
-    text = fs4.readFileSync(p, "utf-8");
-  } catch {
-    return [];
-  }
-  const out = [];
-  for (const rawLine of text.split("\n")) {
-    const line = rawLine.trim();
-    if (!line) {
-      continue;
-    }
-    let obj;
-    try {
-      obj = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    if (_isPlainObject2(obj)) {
-      out.push(obj);
-    }
-  }
-  return out;
-}
-function _mapToObj(m) {
-  const obj = {};
-  for (const [k, v] of m) {
-    obj[k] = v;
-  }
-  return obj;
-}
-function _todayDate() {
-  const now = /* @__PURE__ */ new Date();
-  return { y: now.getFullYear(), m: now.getMonth() + 1, d: now.getDate() };
-}
-function _dateDiffDays(a, b) {
-  const am = Date.UTC(a.y, a.m - 1, a.d);
-  const bm = Date.UTC(b.y, b.m - 1, b.d);
-  return Math.round((am - bm) / (24 * 60 * 60 * 1e3));
-}
-function _parseIsoDate(s) {
-  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(s);
-  if (!m) {
-    return null;
-  }
-  const y = Number(m[1]);
-  const mo = Number(m[2]);
-  const d = Number(m[3]);
-  if (mo < 1 || mo > 12 || d < 1 || d > 31) {
-    return null;
-  }
-  return { y, m: mo, d };
-}
-function _addDays(date, days) {
-  const ms = Date.UTC(date.y, date.m - 1, date.d) + days * 24 * 60 * 60 * 1e3;
-  const dt = new Date(ms);
-  return { y: dt.getUTCFullYear(), m: dt.getUTCMonth() + 1, d: dt.getUTCDate() };
-}
-function _staleness_report() {
-  const today = _todayDate();
-  const stale = [];
-  for (const [p, mtype, entry] of _iter_curated_entries()) {
-    const lv = entry["last_validated"];
-    const review_after = entry["review_after_days"];
-    const lvIsDateLike = typeof lv === "string" || lv instanceof PyTimestamp;
-    const reviewIsInt = typeof review_after === "number" && Number.isInteger(review_after) && typeof review_after !== "boolean";
-    if (!lvIsDateLike || !reviewIsInt) {
-      continue;
-    }
-    const lvStr = lv instanceof PyTimestamp ? lv.pyStr : lv;
-    const parsed = _parseIsoDate(lvStr);
-    if (parsed === null) {
-      continue;
-    }
-    const due = _addDays(parsed, review_after);
-    if (_dateDiffDays(due, today) < 0) {
-      stale.push({
-        file: p,
-        type: mtype,
-        id: entry["id"] ?? "?",
-        overdue_days: _dateDiffDays(today, due)
-      });
-    }
-  }
-  stale.sort((a, b) => b.overdue_days - a.overdue_days);
-  return stale;
-}
-function _quarter_of(d) {
-  let parsed = null;
-  if (typeof d === "string") {
-    const pd = _parseIsoDate(d.slice(0, 10));
-    if (pd === null) {
-      return "unknown";
-    }
-    parsed = pd;
-  } else if (d instanceof PyTimestamp) {
-    const pd = _parseIsoDate(d.pyStr.slice(0, 10));
-    if (pd === null) {
-      return "unknown";
-    }
-    parsed = pd;
-  } else {
-    return "unknown";
-  }
-  return `${parsed.y}Q${Math.floor((parsed.m - 1) / 3) + 1}`;
-}
-function _quarterly_stats() {
-  const accepted = /* @__PURE__ */ new Map();
-  for (const [, , entry] of _iter_curated_entries()) {
-    const created = entry["created"] ?? entry["last_validated"];
-    if (created !== void 0 && created !== null) {
-      const q = _quarter_of(created);
-      accepted.set(q, (accepted.get(q) ?? 0) + 1);
-    }
-  }
-  const retired = /* @__PURE__ */ new Map();
-  if (_isDir(INTAKE_ROOT)) {
-    for (const jsonl of _globJsonl(INTAKE_ROOT)) {
-      for (const obj of _readJsonl(jsonl)) {
-        if (obj["type"] !== "supersede") {
-          continue;
-        }
-        const ts = obj["ts"];
-        if (typeof ts === "string") {
-          const q = _quarter_of(ts);
-          retired.set(q, (retired.get(q) ?? 0) + 1);
-        }
-      }
-    }
-  }
-  const total = _iter_curated_entries().length;
-  const overdue = _staleness_report().length;
-  const rate = total ? overdue / total : 0;
-  return {
-    accepted_by_quarter: _mapToObj(accepted),
-    retired_by_quarter: _mapToObj(retired),
-    staleness_rate: new PyFloat2(_pyRound3(rate)),
-    curated_total: total,
-    curated_overdue: overdue
-  };
-}
-function _pyRound3(x) {
-  const factor = 1e3;
-  const scaled = x * factor;
-  const floor = Math.floor(scaled);
-  const diff = scaled - floor;
-  let rounded;
-  if (Math.abs(diff - 0.5) < 1e-9) {
-    rounded = floor % 2 === 0 ? floor : floor + 1;
-  } else {
-    rounded = Math.round(scaled);
-  }
-  return rounded / factor;
-}
-function _role_mode_stats() {
-  const counts = /* @__PURE__ */ new Map();
-  let files_scanned = 0;
-  const unknown_modes = /* @__PURE__ */ new Set();
-  for (const root of _MODE_SCAN_DIRS) {
-    if (!_exists(root)) {
-      continue;
-    }
-    for (const md of _rglobMd(root)) {
-      let text;
-      try {
-        text = fs4.readFileSync(md, "utf-8");
-      } catch {
-        continue;
-      }
-      files_scanned += 1;
-      _MODE_MARKER_PATTERN.lastIndex = 0;
-      let m;
-      while ((m = _MODE_MARKER_PATTERN.exec(text)) !== null) {
-        const slug = m[1].toLowerCase();
-        counts.set(slug, (counts.get(slug) ?? 0) + 1);
-        if (!_KNOWN_MODES.has(slug)) {
-          unknown_modes.add(slug);
-        }
-      }
-    }
-  }
-  let total = 0;
-  for (const v of counts.values()) {
-    total += v;
-  }
-  return {
-    total_markers: total,
-    files_scanned,
-    by_mode: _mapToObj(counts),
-    unknown_modes: [...unknown_modes].sort()
-  };
-}
-function _exists(p) {
-  try {
-    fs4.statSync(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function _rglobMd(root) {
-  const found = [];
-  const walk = (dir) => {
-    let entries;
-    try {
-      entries = fs4.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const ent of entries) {
-      const full = path4.join(dir, ent.name);
-      if (ent.isDirectory()) {
-        walk(full);
-      } else if (ent.isFile() && ent.name.endsWith(".md")) {
-        found.push(full);
-      }
-    }
-  };
-  walk(root);
-  found.sort();
-  return found;
-}
-function build_report() {
-  const st = status();
-  return {
-    backend: {
-      status: st.status,
-      backend: st.backend,
-      reason: st.reason
-    },
-    intake: _intake_stats(),
-    staleness: _staleness_report(),
-    quarterly: _quarterly_stats(),
-    role_modes: _role_mode_stats()
-  };
-}
-function _print_text(report2) {
-  const out = [];
-  const b = report2.backend;
-  out.push(`Backend:   ${b.status} (backend=${b.backend})`);
-  if (b.reason) {
-    out.push(`           reason: ${b.reason}`);
-  }
-  const intake = report2.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;
-  if (stale.length === 0) {
-    out.push("Staleness: no curated entries past review_after_days");
-  } else {
-    out.push(`Staleness: ${stale.length} entrie(s) overdue`);
-    for (const row of stale.slice(0, 5)) {
-      out.push(`  - ${row.id} (${row.type})  +${row.overdue_days}d  ${row.file}`);
-    }
-    if (stale.length > 5) {
-      out.push(`  (+${stale.length - 5} more)`);
-    }
-  }
-  const q = report2.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(", ");
-    out.push(`  accepted: ${acc}`);
-  }
-  if (Object.keys(q.retired_by_quarter).length > 0) {
-    const ret = _sortedEntries(q.retired_by_quarter).map(([k, v]) => `${k}:${v}`).join(", ");
-    out.push(`  retired:  ${ret}`);
-  }
-  const rm = report2.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) {
-      const modes = _sortedEntries(rm.by_mode).map(([k, v]) => `${k}:${v}`).join(", ");
-      out.push(`  by mode: ${modes}`);
-    }
-    if (rm.unknown_modes.length > 0) {
-      out.push(`  unknown: ${rm.unknown_modes.join(", ")} (not in the six reserved slugs)`);
-    }
-  }
-  process3.stdout.write(out.map((line) => `${line}
-`).join(""));
-}
-function _sortedEntries(obj) {
-  return Object.entries(obj).sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
-}
-function _pyPercent1(x) {
-  return `${(x * 100).toFixed(1)}%`;
-}
-function pyJsonDumps(value, indent) {
-  return _escapeNonAscii2(_dumpsIndent(value, indent, 0));
-}
-function _dumpsIndent(value, indent, depth) {
-  const pad = " ".repeat(indent * (depth + 1));
-  const closePad = " ".repeat(indent * depth);
-  if (value === null || value === void 0) {
-    return "null";
-  }
-  if (typeof value === "boolean") {
-    return value ? "true" : "false";
-  }
-  if (typeof value === "number") {
-    return _jsonNum(value);
-  }
-  if (typeof value === "string") {
-    return _jsonStrAscii(value);
-  }
-  if (value instanceof PyTimestamp) {
-    return _jsonStrAscii(value.pyStr);
-  }
-  if (value instanceof PyFloat2) {
-    return _jsonFloat(value.value);
-  }
-  if (Array.isArray(value)) {
-    if (value.length === 0) {
-      return "[]";
-    }
-    const items = value.map((v) => pad + _dumpsIndent(v, indent, depth + 1));
-    return `[
-${items.join(",\n")}
-${closePad}]`;
-  }
-  if (_isPlainObject2(value)) {
-    const keys = Object.keys(value);
-    if (keys.length === 0) {
-      return "{}";
-    }
-    const items = keys.map((k) => `${pad}${_jsonStrAscii(k)}: ${_dumpsIndent(value[k], indent, depth + 1)}`);
-    return `{
-${items.join(",\n")}
-${closePad}}`;
-  }
-  return _jsonStrAscii(String(value));
-}
-function _jsonNum(n) {
-  if (!Number.isFinite(n)) {
-    if (Number.isNaN(n)) {
-      return "NaN";
-    }
-    return n > 0 ? "Infinity" : "-Infinity";
-  }
-  return String(n);
-}
-function _jsonFloat(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 _jsonStrAscii(s) {
-  let out = '"';
-  for (const ch of s) {
-    const code = ch.codePointAt(0) ?? 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 _escapeNonAscii2(s) {
-  let out = "";
-  for (const ch of s) {
-    const code = ch.codePointAt(0) ?? 0;
-    if (code > 127) {
-      for (let i = 0; i < ch.length; i += 1) {
-        out += `\\u${ch.charCodeAt(i).toString(16).padStart(4, "0")}`;
-      }
-    } else {
-      out += ch;
-    }
-  }
-  return out;
-}
-var _PROG2 = "memory_report.py";
-var _USAGE2 = "usage: memory_report.py [-h] [--format {text,json}]\n";
-function _argError2(msg) {
-  process3.stderr.write(_USAGE2);
-  process3.stderr.write(`${_PROG2}: error: ${msg}
-`);
-  process3.exit(2);
-}
-function _parseArgs2(argv) {
-  const args = { format: "text" };
-  for (let i = 0; i < argv.length; i += 1) {
-    const a = argv[i];
-    if (a === "--format") {
-      args.format = _checkChoice(argv[++i], ["text", "json"], "--format");
-    } else if (a.startsWith("--format=")) {
-      args.format = _checkChoice(a.slice("--format=".length), ["text", "json"], "--format");
-    } else if (a === "-h" || a === "--help") {
-      process3.stdout.write(_USAGE2);
-      process3.exit(0);
-    } else {
-      _argError2(`unrecognized arguments: ${a}`);
-    }
-  }
-  return args;
-}
-function _checkChoice(value, choices, flag) {
-  if (value === void 0 || !choices.includes(value)) {
-    _argError2(
-      `argument ${flag}: invalid choice: '${value ?? ""}' (choose from ${choices.map((c) => `'${c}'`).join(", ")})`
-    );
-  }
-  return value;
-}
-function main3() {
-  const args = _parseArgs2(process3.argv.slice(2));
-  const report2 = build_report();
-  if (args.format === "json") {
-    process3.stdout.write(`${pyJsonDumps(report2, 2)}
-`);
-  } else {
-    _print_text(report2);
-  }
-  return 0;
-}
-function _isCliEntry3() {
-  if (true) {
-    return false;
-  }
-  if (process3.argv[1] === void 0) {
-    return false;
-  }
-  const argvUrl = pathToFileURL3(path4.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]));
-    return here === argv;
-  } catch {
-    return false;
-  }
-}
-var _isMain2 = _isCliEntry3();
-if (_isMain2) {
-  process3.exit(main3());
-}
-
-// src/scripts/_lib/memory_fts_index.ts
-var MEMORY_INDEX_REL = path5.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);
-}
-function _pyStr(v) {
-  if (v === void 0 || v === null) return "";
-  if (typeof v === "string") return v;
-  return String(v);
-}
-function _entryIndexText(entry) {
-  const parts = [];
-  for (const f of INDEX_TEXT_FIELDS) {
-    const v = entry[f];
-    if (typeof v === "string") parts.push(v);
-    else if (Array.isArray(v)) for (const x of v) parts.push(_pyStr(x));
-  }
-  return parts.join(" | ");
-}
-function _isPlainObject3(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function _collectCurated(memoryRoot) {
-  const out = [];
-  const previous = MEMORY_ROOT;
-  _setMemoryRoot(memoryRoot);
-  try {
-    for (const [file, mtype, entry] of _iter_curated_entries()) {
-      const status2 = entry["status"];
-      if (typeof status2 === "string" && CURATED_STATUS_EXCLUDE.has(status2)) continue;
-      const id = typeof entry["id"] === "string" ? entry["id"] : "";
-      if (id === "") continue;
-      out.push({ id, mtype, source: "curated", path: file, text: _entryIndexText(entry) });
-    }
-  } finally {
-    _setMemoryRoot(previous);
-  }
-  return out;
-}
-function _globJsonl2(intakeRoot) {
-  let names;
-  try {
-    names = fs5.readdirSync(intakeRoot);
-  } catch {
-    return [];
-  }
-  return names.filter((n) => n.endsWith(".jsonl")).sort().map((n) => path5.join(intakeRoot, n));
-}
-function _collectIntake(intakeRoot) {
-  const out = [];
-  for (const jsonl of _globJsonl2(intakeRoot)) {
-    const by_id = /* @__PURE__ */ new Map();
-    const superseded = /* @__PURE__ */ new Set();
-    let content;
-    try {
-      content = fs5.readFileSync(jsonl, "utf-8");
-    } catch {
-      continue;
-    }
-    for (let line of content.split(/\n/)) {
-      line = line.trim();
-      if (!line) continue;
-      let obj;
-      try {
-        obj = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      if (!_isPlainObject3(obj)) continue;
-      if (obj["type"] === "supersede") {
-        const target = obj["supersedes"];
-        if (typeof target === "string") superseded.add(target);
-        continue;
-      }
-      const eid = obj["id"];
-      if (typeof eid === "string") by_id.set(eid, obj);
-    }
-    for (const [eid, obj] of by_id.entries()) {
-      if (superseded.has(eid)) continue;
-      const mtype = typeof obj["entry_type"] === "string" ? obj["entry_type"] : "";
-      out.push({ id: eid, mtype, source: "intake", path: jsonl, text: _entryIndexText(obj) });
-    }
-  }
-  return out;
-}
-function collectEntries(memoryRoot, intakeRoot) {
-  return [..._collectCurated(memoryRoot), ..._collectIntake(intakeRoot)];
-}
-function _sourcesMaxMtimeMs(memoryRoot, intakeRoot) {
-  let max = 0;
-  const bump = (p) => {
-    try {
-      const st = fs5.statSync(p);
-      if (st.mtimeMs > max) max = st.mtimeMs;
-    } catch {
-    }
-  };
-  const walk = (dir) => {
-    let entries;
-    try {
-      entries = fs5.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const e of entries) {
-      const full = path5.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 });
-    for (const e of memEntries) {
-      const full = path5.join(memoryRoot, e.name);
-      if (e.isFile() && e.name.endsWith(".yml")) bump(full);
-      else if (e.isDirectory()) walk(full);
-    }
-  } catch {
-  }
-  for (const f of _globJsonl2(intakeRoot)) bump(f);
-  return max;
-}
-var META_KEY_SOURCES_MTIME = "sources_mtime_ms";
-function isStale(indexPath, memoryRoot, intakeRoot) {
-  if (!fs5.existsSync(indexPath)) return true;
-  let sqlite;
-  try {
-    sqlite = loadSqliteSync("memory_fts_index.isStale");
-  } catch {
-    return true;
-  }
-  let conn = null;
-  try {
-    conn = new sqlite.DatabaseSync(indexPath, { readOnly: true });
-    if (readUserVersion(conn) !== SCHEMA_VERSION) return true;
-    const row = conn.prepare("SELECT value FROM _meta WHERE key = ?").get(META_KEY_SOURCES_MTIME);
-    const stored = row?.["value"];
-    const storedMs = typeof stored === "string" ? Number(stored) : NaN;
-    if (!Number.isFinite(storedMs)) return true;
-    return _sourcesMaxMtimeMs(memoryRoot, intakeRoot) > storedMs;
-  } catch {
-    return true;
-  } finally {
-    try {
-      conn?.close();
-    } catch {
-    }
-  }
-}
-function buildIndex(indexPath, memoryRoot, intakeRoot) {
-  fs5.mkdirSync(path5.dirname(indexPath), { recursive: true });
-  try {
-    fs5.rmSync(indexPath, { force: true });
-    fs5.rmSync(`${indexPath}-wal`, { force: true });
-    fs5.rmSync(`${indexPath}-shm`, { force: true });
-  } catch {
-  }
-  const { DatabaseSync } = loadSqliteSync("memory_fts_index.buildIndex");
-  const conn = new DatabaseSync(indexPath);
-  let count = 0;
-  try {
-    conn.exec("PRAGMA journal_mode=WAL");
-    conn.exec(
-      "CREATE VIRTUAL TABLE entries USING fts5(id UNINDEXED, mtype UNINDEXED, source UNINDEXED, path UNINDEXED, text)"
-    );
-    conn.exec("CREATE TABLE _meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)");
-    const stmt = conn.prepare(
-      "INSERT INTO entries (id, mtype, source, path, text) VALUES (?, ?, ?, ?, ?)"
-    );
-    for (const e of collectEntries(memoryRoot, intakeRoot)) {
-      stmt.run(e.id, e.mtype, e.source, e.path, e.text);
-      count += 1;
-    }
-    const metaStmt = conn.prepare("INSERT INTO _meta (key, value) VALUES (?, ?)");
-    metaStmt.run(META_KEY_SOURCES_MTIME, String(_sourcesMaxMtimeMs(memoryRoot, intakeRoot)));
-    stampUserVersion(conn, SCHEMA_VERSION);
-    conn.exec("PRAGMA wal_checkpoint(TRUNCATE)");
-    conn.exec("PRAGMA journal_mode=DELETE");
-  } finally {
-    conn.close();
-  }
-  return { indexPath, entriesIndexed: count };
-}
-function ensureIndex(indexPath, memoryRoot, intakeRoot) {
-  if (!probeFts5Sync()) return false;
-  try {
-    if (isStale(indexPath, memoryRoot, intakeRoot)) {
-      buildIndex(indexPath, memoryRoot, intakeRoot);
-    }
-    return true;
-  } catch {
-    return false;
-  }
-}
-function _sanitizeFtsClause(key) {
-  return key.replace(/[^\p{L}\p{N}]+/gu, " ").trim();
-}
-function queryIndex(indexPath, keys, types) {
-  const clauses = keys.map(_sanitizeFtsClause).filter((c) => c.length > 0);
-  if (clauses.length === 0) return [];
-  let sqlite;
-  try {
-    sqlite = loadSqliteSync("memory_fts_index.queryIndex");
-  } catch {
-    return [];
-  }
-  let conn = null;
-  try {
-    conn = new sqlite.DatabaseSync(indexPath, { readOnly: true });
-    const matchQuery = clauses.map((c) => `(${c})`).join(" OR ");
-    const typeFilter = types.length > 0 ? `AND mtype IN (${types.map(() => "?").join(",")})` : "";
-    const rows = conn.prepare(
-      `SELECT id, mtype, source, path, bm25(entries) AS score
-                 FROM entries
-                 WHERE entries MATCH ? ${typeFilter}
-                 ORDER BY score ASC`
-    ).all(matchQuery, ...types);
-    return rows.map((r) => {
-      const bm25 = typeof r["score"] === "number" ? r["score"] : Number(r["score"] ?? 0);
-      return {
-        id: String(r["id"]),
-        mtype: String(r["mtype"]),
-        source: r["source"] ?? "curated",
-        path: String(r["path"]),
-        relevance: Math.max(0, -bm25)
-      };
-    });
-  } catch {
-    return [];
-  } finally {
-    try {
-      conn?.close();
-    } catch {
-    }
-  }
-}
-
-// src/scripts/learning_sidecar.ts
-import { createHash } from "node:crypto";
-import * as fs6 from "node:fs";
-import * as path6 from "node:path";
-import process4 from "node:process";
-import { fileURLToPath as fileURLToPath5 } 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;
-function _parseTsMs(ts) {
-  const t = Date.parse(ts);
-  return Number.isNaN(t) ? null : t;
-}
-function _bodyHash(body) {
-  return createHash("sha256").update(body.trim().toLowerCase()).digest("hex").slice(0, 12);
-}
-function _globSignalFiles(dir) {
-  let names;
-  try {
-    names = fs6.readdirSync(dir);
-  } catch {
-    return [];
-  }
-  return names.filter((n) => n.startsWith("signals-") && n.endsWith(".jsonl")).sort().map((n) => path6.join(dir, n));
-}
-function readSignals(intakeDir) {
-  const out = [];
-  for (const file of _globSignalFiles(intakeDir)) {
-    let content;
-    try {
-      content = fs6.readFileSync(file, "utf-8");
-    } catch {
-      continue;
-    }
-    for (const raw of content.split("\n")) {
-      const line = raw.trim();
-      if (!line) continue;
-      let obj;
-      try {
-        obj = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      if (typeof obj !== "object" || obj === null) continue;
-      const r = obj;
-      const ts = typeof r["ts"] === "string" ? r["ts"] : "";
-      const tsMs = _parseTsMs(ts);
-      const entryType = typeof r["entry_type"] === "string" ? r["entry_type"] : "";
-      const p = typeof r["path"] === "string" ? r["path"] : "";
-      const body = typeof r["body"] === "string" ? r["body"] : "";
-      if (tsMs === null || !entryType || !p || !body) continue;
-      const pol = r["polarity"] === "dead_end" ? "dead_end" : "preferred";
-      out.push({
-        id: typeof r["id"] === "string" ? r["id"] : "",
-        ts,
-        tsMs,
-        origin: typeof r["origin"] === "string" ? r["origin"] : "unknown",
-        entryType,
-        path: p,
-        body,
-        polarity: pol
-      });
-    }
-  }
-  return out;
-}
-function aggregate(signals, nowMs) {
-  const halfLifeMs = HALF_LIFE_DAYS * 24 * 60 * 60 * 1e3;
-  const groups = /* @__PURE__ */ new Map();
-  for (const s of signals) {
-    const gk = `${s.entryType}\0${s.path}`;
-    let g = groups.get(gk);
-    if (g === void 0) {
-      g = { entryType: s.entryType, path: s.path, claims: /* @__PURE__ */ new Map() };
-      groups.set(gk, g);
-    }
-    const ck = _bodyHash(s.body);
-    let c = g.claims.get(ck);
-    if (c === void 0) {
-      c = { body: s.body, polarity: s.polarity, origins: /* @__PURE__ */ new Set(), score: 0, lastMs: -1, lastTs: "" };
-      g.claims.set(ck, c);
-    }
-    const ageMs = Math.max(0, nowMs - s.tsMs);
-    c.score += Math.pow(0.5, ageMs / halfLifeMs);
-    c.origins.add(s.origin);
-    if (s.tsMs > c.lastMs) {
-      c.lastMs = s.tsMs;
-      c.lastTs = s.ts;
-      c.polarity = s.polarity;
-    }
-  }
-  const lessons = [];
-  for (const g of groups.values()) {
-    const claims = [...g.claims.values()].sort(
-      (a, b) => b.score - a.score || b.lastMs - a.lastMs || (a.body < b.body ? -1 : 1)
-    );
-    const top = claims[0];
-    if (top === void 0) continue;
-    const corroborations = top.origins.size;
-    if (corroborations < MIN_CORROBORATIONS) continue;
-    const secondCorroborated = claims.slice(1).some((c) => c.origins.size >= MIN_CORROBORATIONS);
-    let verdict;
-    if (secondCorroborated) verdict = "contested";
-    else if (top.polarity === "dead_end") verdict = "dead_end";
-    else verdict = "preferred";
-    lessons.push({
-      entry_type: g.entryType,
-      path: g.path,
-      verdict,
-      score: Math.round(top.score * 1e3) / 1e3,
-      corroborations,
-      last_ts: top.lastTs,
-      body: top.body
-    });
-  }
-  lessons.sort(
-    (a, b) => a.entry_type < b.entry_type ? -1 : a.entry_type > b.entry_type ? 1 : a.path < b.path ? -1 : a.path > b.path ? 1 : 0
-  );
-  return lessons;
-}
-function buildSidecar(intakeDir, nowIso) {
-  const nowMs = _parseTsMs(nowIso) ?? 0;
-  const lessons = aggregate(readSignals(intakeDir), nowMs);
-  return { schema_version: SCHEMA_VERSION2, generated_at: nowIso, lessons };
-}
-function renderLessonsMd(sidecar) {
-  const dead = sidecar.lessons.filter((l) => l.verdict === "dead_end");
-  const contested = sidecar.lessons.filter((l) => l.verdict === "contested");
-  const L = [];
-  L.push("# Lessons (generated \u2014 do not edit)");
-  L.push("");
-  L.push(`> Regenerated from the intake signal log by \`${PROG}\`. Local-only,`);
-  L.push("> intake-derived; never a substitute for curated memory. Proven lessons");
-  L.push("> should be MANUALLY promoted into `agents/memory/<type>/*.yml`.");
-  L.push("");
-  L.push("## Known dead ends \u2014 don't re-derive");
-  L.push("");
-  if (dead.length === 0) {
-    L.push("_None corroborated yet._");
-  } else {
-    for (const l of dead) L.push(`- \`${l.entry_type}\` @ \`${l.path}\` \u2014 ${l.body}`);
-  }
-  L.push("");
-  L.push("## Contested \u2014 recency-resolved, verify before relying");
-  L.push("");
-  if (contested.length === 0) {
-    L.push("_None._");
-  } else {
-    for (const l of contested) L.push(`- \`${l.entry_type}\` @ \`${l.path}\` \u2014 ${l.body}`);
-  }
-  L.push("");
-  return L.join("\n");
-}
-function main4(argv) {
-  let intakeDir = path6.join("agents", "memory", "intake");
-  let outDir = path6.join("agents", "memory");
-  let nowIso = "";
-  let write = false;
-  let format = "text";
-  for (let i = 0; i < argv.length; i++) {
-    const a = argv[i];
-    if (a === "--intake-dir") intakeDir = argv[++i] ?? intakeDir;
-    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") {
-      process4.stdout.write(
-        `usage: ${PROG} [--intake-dir DIR] [--out-dir DIR] [--now ISO] [--write] [--format text|json]
-`
-      );
-      return 0;
-    } else {
-      process4.stderr.write(`${PROG}: error: unknown argument ${a}
-`);
-      return 2;
-    }
-  }
-  if (!nowIso) {
-    nowIso = (/* @__PURE__ */ new Date(0)).toISOString();
-  }
-  let sidecar;
-  try {
-    sidecar = buildSidecar(intakeDir, nowIso);
-  } catch (exc) {
-    process4.stderr.write(`${PROG}: internal error: ${String(exc)}
-`);
-    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));
-  }
-  if (format === "json") {
-    process4.stdout.write(JSON.stringify(sidecar, null, 2) + "\n");
-    return 0;
-  }
-  const byVerdict = { preferred: 0, contested: 0, dead_end: 0 };
-  for (const l of sidecar.lessons) byVerdict[l.verdict] += 1;
-  process4.stdout.write(
-    `${PROG}: ${sidecar.lessons.length} lesson(s) \u2014 ${byVerdict.preferred} preferred, ${byVerdict.contested} contested, ${byVerdict.dead_end} dead-end${write ? " (written)" : ""}
-`
-  );
-  return 0;
-}
-var _bundled = true;
-if (!_bundled && fileURLToPath5(import.meta.url) === path6.resolve(process4.argv[1] ?? "")) {
-  process4.exit(main4(process4.argv.slice(2)));
-}
-
-// src/scripts/memory_lookup.ts
-var PYYAML_DATE_ONLY_RE2 = /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/;
-var PYYAML_TIMESTAMP_RE2 = /^(?:[0-9]{4}-[0-9]{2}-[0-9]{2}|[0-9]{4}-[0-9]{1,2}-[0-9]{1,2}(?:[Tt]|[ \t]+)[0-9]{1,2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]*)?(?:[ \t]*(?:Z|[-+][0-9]{1,2}(?::[0-9]{2})?))?)$/;
-var PyTimestamp2 = class {
-  constructor(pyStr) {
-    this.pyStr = pyStr;
-  }
-  pyStr;
-  toString() {
-    return this.pyStr;
-  }
-};
-var PyFloat3 = 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 _LEX_TYPE_FILES_MAX = 200;
-var _LEX_CORPUS_FILES_MAX = 500;
-var _LEX_SOURCE_FACTOR = { curated: 1, intake: 0.9, knowledge: 0.85 };
-var _lexTripwireOverride = null;
-var _corpusFileCounts = null;
-var _learningOverlay;
-function _loadLearningOverlay() {
-  if (_learningOverlay !== void 0) return _learningOverlay;
-  const file = path7.join(MEMORY_ROOT2, SIDECAR_NAME);
-  try {
-    const parsed = JSON.parse(fs7.readFileSync(file, "utf-8"));
-    const lessons = _isPlainObject4(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;
-      const t = l["entry_type"];
-      const p = l["path"];
-      const v = l["verdict"];
-      if (typeof t === "string" && typeof p === "string" && (v === "preferred" || v === "contested" || v === "dead_end")) {
-        map.set(`${t}\0${p}`, v);
-      }
-    }
-    _learningOverlay = map.size > 0 ? map : null;
-  } catch {
-    _learningOverlay = null;
-  }
-  return _learningOverlay;
-}
-function _learningVerdictFor(mtype, entry) {
-  const overlay = _loadLearningOverlay();
-  if (overlay === null) return void 0;
-  const anchor = typeof entry["path"] === "string" ? entry["path"] : entry["key"];
-  if (typeof anchor !== "string" || anchor === "") return void 0;
-  return overlay.get(`${mtype}\0${anchor}`);
-}
-var CURATED_TYPES2 = /* @__PURE__ */ new Set([
-  "ownership",
-  "historical-patterns",
-  "domain-invariants",
-  "incident-learnings",
-  "product-rules"
-]);
-var KNOWLEDGE_TYPE = "knowledge";
-var CROSS_REPO_TYPE = "cross-repo";
-var _CURATED_STATUS_EXCLUDE = /* @__PURE__ */ new Set(["deprecated", "archived", "superseded"]);
-function _statusExcluded(entry) {
-  const status2 = entry["status"];
-  return typeof status2 === "string" && _CURATED_STATUS_EXCLUDE.has(status2);
-}
-var Hit = class {
-  id;
-  type;
-  source;
-  // HitSource, kept as string to mirror the Python dataclass
-  path;
-  // file (or logical locator) that produced the hit
-  score;
-  // naive, content-match based [0..1]
-  entry;
-  constructor(id, type, source, p, score, entry = {}) {
-    this.id = id;
-    this.type = type;
-    this.source = source;
-    this.path = p;
-    this.score = score;
-    this.entry = entry;
-  }
-  as_dict() {
-    return {
-      id: this.id,
-      type: this.type,
-      source: this.source,
-      path: this.path,
-      // score is a Python float — render `0.0` not `0` for whole numbers.
-      score: new PyFloat3(this.score),
-      entry: this.entry
-    };
-  }
-};
-function _isPlainObject4(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v) && !(v instanceof PyTimestamp2) && !(v instanceof PyFloat3);
-}
-function _isFile2(p) {
-  try {
-    return fs7.statSync(p).isFile();
-  } catch {
-    return false;
-  }
-}
-function _isDir2(p) {
-  try {
-    return fs7.statSync(p).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function _load_yaml2(p) {
-  const text = fs7.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];
-    throw new Error(err ? err.message : "YAML parse error");
-  }
-  import_yaml2.default.visit(doc, {
-    Scalar(_key, node) {
-      if (!node.range) {
-        return;
-      }
-      const raw = text.slice(node.range[0], node.range[1]);
-      if (node.value instanceof Date) {
-        if (PYYAML_DATE_ONLY_RE2.test(raw)) {
-          node.value = new PyTimestamp2(raw);
-        } else if (PYYAML_TIMESTAMP_RE2.test(raw)) {
-          node.value = new PyTimestamp2(_pyYamlDatetimeStr2(raw));
-        }
-        return;
-      }
-      if (typeof node.value === "boolean" && node.type === "PLAIN" && /^[ynYN]$/.test(raw)) {
-        node.value = raw;
-      }
-    }
-  });
-  const data = doc.toJS({ mapAsMap: false });
-  return data == null ? {} : data;
-}
-function _pyYamlDatetimeStr2(raw) {
-  const m = /^(\d{4})-(\d{1,2})-(\d{1,2})(?:[Tt]|[ \t]+)(\d{1,2}):(\d{2}):(\d{2})(?:\.(\d*))?(?:[ \t]*(Z|[-+]\d{1,2}(?::\d{2})?))?$/.exec(
-    raw
-  );
-  if (!m) {
-    return raw;
-  }
-  const [, y, mo, d, h, mi, s, frac, tz] = m;
-  const date = `${y}-${_pad22(mo)}-${_pad22(d)}`;
-  let time = `${_pad22(h)}:${mi}:${s}`;
-  if (frac && /[1-9]/.test(frac)) {
-    time += `.${(frac + "000000").slice(0, 6)}`;
-  }
-  let off = "";
-  if (tz) {
-    if (tz === "Z") {
-      off = "+00:00";
-    } else {
-      const tm = /^([-+])(\d{1,2})(?::(\d{2}))?$/.exec(tz);
-      if (tm) {
-        off = `${tm[1]}${_pad22(tm[2])}:${tm[3] ?? "00"}`;
-      }
-    }
-  }
-  return `${date} ${time}${off}`;
-}
-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`);
-  if (_isFile2(single_file)) {
-    const data = _load_yaml2(single_file);
-    const entries = _isPlainObject4(data) ? data["entries"] : null;
-    for (const e of Array.isArray(entries) ? entries : []) {
-      if (_isPlainObject4(e)) {
-        if (_statusExcluded(e)) {
-          continue;
-        }
-        yield [single_file, e];
-      }
-    }
-  }
-  if (_isDir2(type_dir)) {
-    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;
-      if (Array.isArray(entries)) {
-        for (const e of entries) {
-          if (_isPlainObject4(e)) {
-            if (_statusExcluded(e)) {
-              continue;
-            }
-            yield [yml, e];
-          }
-        }
-      } else if (_isPlainObject4(data) && data["id"]) {
-        if (_statusExcluded(data)) {
-          continue;
-        }
-        yield [yml, data];
-      }
-    }
-  }
-}
-function* _iter_curated_entries_all(mtype) {
-  const type_dir = path7.join(MEMORY_ROOT2, mtype);
-  const single_file = path7.join(MEMORY_ROOT2, `${mtype}.yml`);
-  if (_isFile2(single_file)) {
-    const data = _load_yaml2(single_file);
-    const entries = _isPlainObject4(data) ? data["entries"] : null;
-    for (const e of Array.isArray(entries) ? entries : []) {
-      if (_isPlainObject4(e)) {
-        yield [single_file, e];
-      }
-    }
-  }
-  if (_isDir2(type_dir)) {
-    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;
-      if (Array.isArray(entries)) {
-        for (const e of entries) {
-          if (_isPlainObject4(e)) {
-            yield [yml, e];
-          }
-        }
-      } else if (_isPlainObject4(data) && data["id"]) {
-        yield [yml, data];
-      }
-    }
-  }
-}
-function* _iter_intake_entries(mtype) {
-  if (!_isDir2(INTAKE_ROOT2)) {
-    return;
-  }
-  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");
-    for (let line of content.split(/\n/)) {
-      line = line.trim();
-      if (!line) {
-        continue;
-      }
-      let obj;
-      try {
-        obj = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      if (!_isPlainObject4(obj)) {
-        continue;
-      }
-      if (obj["type"] === "supersede") {
-        const target = obj["supersedes"];
-        if (typeof target === "string") {
-          superseded.add(target);
-        }
-        continue;
-      }
-      const eid = obj["id"];
-      if (typeof eid === "string") {
-        by_id.set(eid, obj);
-      }
-    }
-    for (const [eid, obj] of by_id.entries()) {
-      if (superseded.has(eid)) {
-        continue;
-      }
-      if (mtype && obj["entry_type"] && obj["entry_type"] !== mtype) {
-        continue;
-      }
-      yield [jsonl, obj];
-    }
-  }
-}
-function* _iter_knowledge_entries() {
-  if (!_isDir2(KNOWLEDGE_ROOT)) {
-    return;
-  }
-  for (const ingest_dir of _iterdirSorted(KNOWLEDGE_ROOT)) {
-    if (!_isDir2(ingest_dir)) {
-      continue;
-    }
-    const manifest_path = path7.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 : {};
-      } catch {
-        manifest = {};
-      }
-    }
-    const ingest_id = String(manifest["ingest_id"] || path7.basename(ingest_dir));
-    const source = String(manifest["source"] || "");
-    const pinned = Boolean(manifest["pinned"] ?? false);
-    const chunks_dir = path7.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");
-      } catch {
-        continue;
-      }
-      const entry = {
-        id: `${ingest_id}:${_stem(chunk)}`,
-        ingest_id,
-        source,
-        path: source,
-        body,
-        pinned,
-        source_kind: "knowledge"
-      };
-      yield [chunk, entry];
-    }
-  }
-}
-function _score(entry, keys) {
-  if (keys.length === 0) {
-    return 0.1;
-  }
-  const hay_parts = [];
-  for (const field_name of ["path", "key", "symptom", "feature", "rule", "body"]) {
-    const v = entry[field_name];
-    if (typeof v === "string") {
-      hay_parts.push(v);
-    } else if (Array.isArray(v)) {
-      for (const x of v) {
-        hay_parts.push(_pyStr2(x));
-      }
-    }
-  }
-  const hay = hay_parts.join(" | ").toLowerCase();
-  let best = 0;
-  for (const k of keys) {
-    const kl = k.toLowerCase();
-    if (_fnmatch(hay, `*${kl}*`)) {
-      best = Math.max(best, 0.8);
-    } else if (hay.includes(kl)) {
-      best = Math.max(best, 0.6);
-    }
-  }
-  return best;
-}
-function _cross_repo_hits(keys, limit) {
-  const query = keys.filter((k) => k).join(" ").trim();
-  if (!query) {
-    return [];
-  }
-  void limit;
-  return [];
-}
-function _today() {
-  const now = /* @__PURE__ */ new Date();
-  return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
-}
-function _parseIsoDate2(s) {
-  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(s);
-  if (!m) {
-    return null;
-  }
-  const y = Number(m[1]);
-  const mo = Number(m[2]);
-  const d = Number(m[3]);
-  if (mo < 1 || mo > 12 || d < 1 || d > 31) {
-    return null;
-  }
-  const date = new Date(Date.UTC(y, mo - 1, d));
-  if (date.getUTCFullYear() !== y || date.getUTCMonth() !== mo - 1 || date.getUTCDate() !== d) {
-    return null;
-  }
-  return date;
-}
-function _pyStrDateLike(lv) {
-  if (lv instanceof PyTimestamp2) {
-    return lv.pyStr;
-  }
-  return _pyStr2(lv);
-}
-function _isStale(entry, today) {
-  const lv = entry["last_validated"];
-  const rad = entry["review_after_days"];
-  if (!lv || typeof rad !== "number" || !Number.isInteger(rad)) {
-    return false;
-  }
-  const validated = _parseIsoDate2(_pyStrDateLike(lv));
-  if (validated === null) {
-    return false;
-  }
-  const days = Math.round((today.getTime() - validated.getTime()) / 864e5);
-  return days > rad;
-}
-function _entry_id(mtype, file, entry, ordinals) {
-  const ordinal = ordinals.get(file) ?? 0;
-  ordinals.set(file, ordinal + 1);
-  const own = entry["id"];
-  if (typeof own === "string" && own.trim() !== "") {
-    return own;
-  }
-  if (own !== void 0 && own !== null && String(own).trim() !== "") {
-    return String(own);
-  }
-  return `${mtype}:${path7.basename(file)}:${ordinal}`;
-}
-function _entry_title(entry, id) {
-  for (const field of ["title", "key", "path"]) {
-    const v = entry[field];
-    if (typeof v === "string" && v.trim() !== "") {
-      return v.trim().slice(0, 120);
-    }
-  }
-  const body = entry["body"];
-  if (typeof body === "string" && body.trim() !== "") {
-    const first = body.trim().split("\n")[0];
-    return first.trim().slice(0, 120);
-  }
-  return id;
-}
-function _compact_line(hit, safeEntry) {
-  const head = _entry_title(safeEntry, hit.id).replace(/\s+/g, " ").trim();
-  const score = hit.score.toFixed(2);
-  return `HIT ${hit.type}/${hit.id} [src=${hit.path} score=${score}] ${head}`;
-}
-var _tokenizer;
-function _lazy_tokenizer() {
-  if (_tokenizer === void 0) {
-    try {
-      const req = createRequire2(import.meta.url);
-      _tokenizer = req("./_lib/token_count.js");
-    } catch {
-      _tokenizer = null;
-    }
-  }
-  return _tokenizer;
-}
-function _entry_tokens_estimate(envelope_entry) {
-  const serialized = JSON.stringify(envelope_entry);
-  const tok = _lazy_tokenizer();
-  if (tok !== null && tok !== void 0 && tok.TIKTOKEN_AVAILABLE) {
-    return tok.gpt_tokens(serialized).tokens;
-  }
-  return Math.ceil(serialized.length / 4);
-}
-function _countMdFiles(dir) {
-  let entries;
-  try {
-    entries = fs7.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));
-    else if (e.isFile() && e.name.endsWith(".md")) n += 1;
-  }
-  return n;
-}
-function _countCorpusFiles() {
-  if (_corpusFileCounts !== null) return _corpusFileCounts;
-  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 c = exists ? 1 : 0;
-    perType.set(t, c);
-    total += c;
-  }
-  const kn = _countMdFiles(KNOWLEDGE_ROOT);
-  perType.set(KNOWLEDGE_TYPE, kn);
-  total += kn;
-  try {
-    for (const e of fs7.readdirSync(INTAKE_ROOT2, { withFileTypes: true })) {
-      if (e.isFile() && e.name.endsWith(".jsonl")) total += 1;
-    }
-  } catch {
-  }
-  _corpusFileCounts = { perType, total };
-  return _corpusFileCounts;
-}
-function _lexicalRankActive(types) {
-  const typeMax = _lexTripwireOverride ?? _LEX_TYPE_FILES_MAX;
-  const corpusMax = _lexTripwireOverride ?? _LEX_CORPUS_FILES_MAX;
-  const counts = _countCorpusFiles();
-  if (counts.total > corpusMax) return true;
-  for (const t of types) {
-    if ((counts.perType.get(t) ?? 0) > typeMax) return true;
-  }
-  return false;
-}
-function _entryIndexText2(entry) {
-  const parts = [];
-  for (const f of ["path", "key", "symptom", "feature", "rule", "body"]) {
-    const v = entry[f];
-    if (typeof v === "string") parts.push(v);
-    else if (Array.isArray(v)) for (const x of v) parts.push(_pyStr2(x));
-  }
-  return parts.join(" | ");
-}
-function _lexicalRerank(hits, keys) {
-  if (hits.length === 0) return;
-  const index = new LexicalIndex(hits.map((h) => ({ id: h.id, text: _entryIndexText2(h.entry) })));
-  const qTerms = tokenize(keys.join(" "));
-  for (const h of hits) {
-    const bm25 = index.score(qTerms, h.id);
-    const factor = _LEX_SOURCE_FACTOR[h.source] ?? 0.8;
-    h.score = bm25 > 0 ? bm25 / (bm25 + 1) * factor : h.score * 1e-6;
-  }
-}
-var _FTS_RECALL_GAP_SOURCE_FACTOR = { curated: 0.5, intake: 0.45, knowledge: 0.4 };
-function _ftsRecallGapHits(repo_hits, keys) {
-  if (repo_hits.length === 0 || keys.length === 0) return [];
-  const indexPath = resolveIndexPath();
-  if (!ensureIndex(indexPath, MEMORY_ROOT2, INTAKE_ROOT2)) return [];
-  const types = [...new Set(repo_hits.map((h) => h.type))];
-  const ftsHits = queryIndex(indexPath, keys, types);
-  if (ftsHits.length === 0) return [];
-  const byId = new Map(ftsHits.map((h) => [h.id, h]));
-  const out = [];
-  for (const h of repo_hits) {
-    const fts = byId.get(h.id);
-    if (fts === void 0) continue;
-    const factor = _FTS_RECALL_GAP_SOURCE_FACTOR[h.source] ?? 0.4;
-    const score = fts.relevance / (fts.relevance + 1) * factor;
-    if (score > 0) out.push(new Hit(h.id, h.type, h.source, h.path, score, h.entry));
-  }
-  return out;
-}
-function _retrieve_internal(types, keys, limit, today) {
-  const repo_hits = [];
-  const skipped = [];
-  for (const mtype of types) {
-    if (mtype === KNOWLEDGE_TYPE) {
-      for (const [p, entry] of _iter_knowledge_entries()) {
-        let base = _score(entry, keys);
-        if (entry["pinned"]) {
-          base = Math.min(1, base + 0.05);
-        }
-        repo_hits.push(
-          new Hit(
-            String(entry["id"] ?? ""),
-            KNOWLEDGE_TYPE,
-            "knowledge",
-            String(p),
-            // Discount vs curated/intake so hand-reviewed repo
-            // entries still win on equal relevance.
-            base * 0.85,
-            entry
-          )
-        );
-      }
-      continue;
-    }
-    if (mtype === CROSS_REPO_TYPE) {
-      for (const h of _cross_repo_hits(keys, limit)) {
-        repo_hits.push(h);
-      }
-      continue;
-    }
-    if (!CURATED_TYPES2.has(mtype)) {
-      continue;
-    }
-    const _cur_ordinals = /* @__PURE__ */ new Map();
-    for (const [p, entry] of _iter_curated_entries2(mtype)) {
-      const eid = _entry_id(mtype, String(p), entry, _cur_ordinals);
-      if (_isStale(entry, today)) {
-        const lv = "last_validated" in entry ? _pyStrDateLike(entry["last_validated"]) : "unknown";
-        const rad = "review_after_days" in entry ? _pyStr2(entry["review_after_days"]) : "?";
-        skipped.push({
-          id: eid,
-          type: mtype,
-          reason: "stale",
-          details: `last_validated=${lv}, review_after_days=${rad}`
-        });
-        continue;
-      }
-      repo_hits.push(new Hit(eid, mtype, "curated", String(p), _score(entry, keys), entry));
-    }
-    for (const [p, entry] of _iter_curated_entries_all(mtype)) {
-      void p;
-      const status2 = "status" in entry && entry["status"] !== void 0 ? entry["status"] : "active";
-      if (typeof status2 === "string" && _CURATED_STATUS_EXCLUDE.has(status2)) {
-        skipped.push({
-          id: String(entry["id"] ?? ""),
-          type: mtype,
-          reason: "superseded",
-          details: `status=${_pyStr2(status2)}`
-        });
-      }
-    }
-    for (const [p, entry] of _iter_intake_entries(mtype)) {
-      repo_hits.push(
-        new Hit(
-          String(entry["id"] ?? ""),
-          mtype,
-          "intake",
-          String(p),
-          _score(entry, keys) * 0.9,
-          // slight discount vs curated
-          entry
-        )
-      );
-    }
-  }
-  _sortMerged(repo_hits);
-  let positives = repo_hits.filter((h) => h.score > 0);
-  if (positives.length > 0 && _lexicalRankActive(types)) {
-    _lexicalRerank(positives, keys);
-    _sortMerged(positives);
-    positives = positives.filter((h) => h.score > 0);
-  }
-  if (positives.length === 0 && repo_hits.length > 0) {
-    const ftsHits = _ftsRecallGapHits(repo_hits, keys);
-    if (ftsHits.length > 0) {
-      _sortMerged(ftsHits);
-      positives = ftsHits.filter((h) => h.score > 0);
-    }
-  }
-  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);
-  }
-  return [hits, skipped];
-}
-function retrieve(types, keys, limit = 5) {
-  const [hits] = _retrieve_internal(types, keys, limit, _today());
-  return hits;
-}
-function _sortMerged(merged) {
-  const indexed = merged.map((h, i) => ({ h, i }));
-  indexed.sort((a, b) => {
-    if (a.h.score !== b.h.score) {
-      return b.h.score - a.h.score;
-    }
-    const ac = a.h.source === "curated" ? 1 : 0;
-    const bc = b.h.source === "curated" ? 1 : 0;
-    if (ac !== bc) {
-      return bc - ac;
-    }
-    return a.i - b.i;
-  });
-  for (let i = 0; i < indexed.length; i += 1) {
-    merged[i] = indexed[i].h;
-  }
-}
-var _CONTRACT_VERSION = 1;
-var _KNOWN_TYPES = /* @__PURE__ */ new Set([...CURATED_TYPES2, KNOWLEDGE_TYPE, CROSS_REPO_TYPE]);
-function retrieve_v1(types, keys, limit = 20, options = {}) {
-  const detail = options.detail ?? "full";
-  const rawBudget = options.token_budget;
-  const budgeted = typeof rawBudget === "number" && Number.isFinite(rawBudget) && rawBudget > 0;
-  const budgetChars = budgeted ? Math.floor(rawBudget * 4) : 0;
-  const known = types.filter((t) => _KNOWN_TYPES.has(t));
-  const unknown = types.filter((t) => !_KNOWN_TYPES.has(t));
-  const hits = retrieve(known, keys, limit);
-  const slice_counts = {};
-  for (const t of known) {
-    slice_counts[t] = 0;
-  }
-  const entries = [];
-  let usedChars = 0;
-  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 learning = _learningVerdictFor(h.type, safeEntry);
-    if (learning !== void 0) safeEntry["learning"] = learning;
-    if (budgeted) {
-      const line = _compact_line(h, safeEntry);
-      const cost = line.length + 1;
-      if (usedChars + cost > budgetChars && entries.length > 0) {
-        const omitted = hits.length - hi;
-        const nextPath = h.path || "<path>";
-        truncation = {
-          omitted,
-          hint: `${omitted} more hit(s) \u2014 narrow with --key or read ${nextPath}`
-        };
-        break;
-      }
-      usedChars += cost;
-      entries.push({
-        id: h.id,
-        type: h.type,
-        source: "repo",
-        confidence: new PyFloat3(_round4(h.score)),
-        line,
-        ...learning !== void 0 ? { learning } : {}
-      });
-      if (h.type in slice_counts) {
-        slice_counts[h.type] = slice_counts[h.type] + 1;
-      }
-      continue;
-    }
-    const envelope_entry = {
-      id: h.id,
-      type: h.type,
-      source: "repo",
-      // confidence = round(float(score), 4) — always a Python float.
-      confidence: new PyFloat3(_round4(h.score)),
-      body: safeEntry
-    };
-    if (h.type in slice_counts) {
-      slice_counts[h.type] = slice_counts[h.type] + 1;
-    }
-    if (detail === "index") {
-      entries.push({
-        id: h.id,
-        type: h.type,
-        source: "repo",
-        confidence: new PyFloat3(_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
-        // (roadmap Phase 4) — pinned entries rank higher, so the
-        // caller should see why before fetching.
-        ...h.type === KNOWLEDGE_TYPE ? { pinned: Boolean(safeEntry["pinned"] ?? false) } : {},
-        ...learning !== void 0 ? { learning } : {}
-      });
-    } else {
-      entries.push(envelope_entry);
-    }
-  }
-  const slices = {};
-  for (const t of known) {
-    slices[t] = { status: "ok", count: slice_counts[t] ?? 0 };
-  }
-  const errors = [];
-  for (const t of unknown) {
-    slices[t] = { status: "unknown_type", count: 0 };
-    errors.push({
-      type: t,
-      code: "unknown_type",
-      message: `file-backed backend does not know type ${_pyRepr(t)}`
-    });
-  }
-  const sliceVals = Object.values(slices);
-  const oks = sliceVals.filter((s) => s["status"] === "ok");
-  const fails = sliceVals.filter((s) => s["status"] !== "ok");
-  const envelope_status = fails.length === 0 ? "ok" : oks.length === 0 ? "error" : "partial";
-  const envelope = {
-    contract_version: _CONTRACT_VERSION,
-    status: envelope_status,
-    entries,
-    slices
-  };
-  if (errors.length > 0) {
-    envelope["errors"] = errors;
-  }
-  if (truncation !== null) {
-    envelope["truncation"] = truncation;
-  }
-  return envelope;
-}
-function memory_get_v1(ids) {
-  const wanted = new Set(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 learning = _learningVerdictFor(mtype, safeEntry);
-      if (learning !== void 0) safeEntry["learning"] = learning;
-      found.set(id, {
-        id,
-        type: mtype,
-        source: "repo",
-        body: safeEntry
-      });
-    }
-  };
-  for (const mtype of CURATED_TYPES2) {
-    const ordinals = /* @__PURE__ */ new Map();
-    for (const [p, entry] of _iter_curated_entries2(mtype)) {
-      record(_entry_id(mtype, String(p), entry, ordinals), mtype, entry);
-    }
-    for (const [p, entry] of _iter_intake_entries(mtype)) {
-      void p;
-      const own = entry["id"];
-      if (typeof own === "string" && own.trim() !== "") {
-        record(own, mtype, entry);
-      }
-    }
-  }
-  for (const [p, entry] of _iter_knowledge_entries()) {
-    void p;
-    record(String(entry["id"] ?? ""), KNOWLEDGE_TYPE, entry);
-  }
-  const entries = [];
-  const idStatus = {};
-  for (const id of ids) {
-    const e = found.get(id);
-    if (e !== void 0) {
-      entries.push(e);
-      idStatus[id] = "ok";
-    } else {
-      idStatus[id] = "unknown";
-    }
-  }
-  const okCount = entries.length;
-  const status2 = okCount === ids.length ? "ok" : okCount === 0 ? "error" : "partial";
-  return {
-    contract_version: _CONTRACT_VERSION,
-    status: status2,
-    entries,
-    ids: idStatus
-  };
-}
-function _parseArgs3(argv) {
-  const args = {
-    types: "",
-    key: [],
-    limit: 5,
-    format: "text",
-    envelope: "legacy",
-    detail: "full",
-    tokenBudget: null
-  };
-  for (let i = 0; i < argv.length; i += 1) {
-    const a = argv[i];
-    if (a === "--types") {
-      args.types = argv[++i];
-    } else if (a.startsWith("--types=")) {
-      args.types = a.slice("--types=".length);
-    } else if (a === "--key") {
-      args.key.push(argv[++i]);
-    } else if (a.startsWith("--key=")) {
-      args.key.push(a.slice("--key=".length));
-    } else if (a === "--limit") {
-      args.limit = _parseInt(argv[++i], "--limit");
-    } else if (a.startsWith("--limit=")) {
-      args.limit = _parseInt(a.slice("--limit=".length), "--limit");
-    } else if (a === "--format") {
-      args.format = _checkChoice2(argv[++i], ["text", "json"], "--format");
-    } else if (a.startsWith("--format=")) {
-      args.format = _checkChoice2(a.slice("--format=".length), ["text", "json"], "--format");
-    } else if (a === "--envelope") {
-      args.envelope = _checkChoice2(argv[++i], ["legacy", "v1"], "--envelope");
-    } else if (a.startsWith("--envelope=")) {
-      args.envelope = _checkChoice2(a.slice("--envelope=".length), ["legacy", "v1"], "--envelope");
-    } else if (a === "--detail") {
-      args.detail = _checkChoice2(argv[++i], ["index", "full"], "--detail");
-    } else if (a.startsWith("--detail=")) {
-      args.detail = _checkChoice2(a.slice("--detail=".length), ["index", "full"], "--detail");
-    } else if (a === "--token-budget") {
-      args.tokenBudget = _parseInt(argv[++i], "--token-budget");
-    } else if (a.startsWith("--token-budget=")) {
-      args.tokenBudget = _parseInt(a.slice("--token-budget=".length), "--token-budget");
-    } else if (a === "-h" || a === "--help") {
-      _printUsage();
-      process5.exit(0);
-    } else {
-      process5.stderr.write(`memory_lookup: error: unrecognized arguments: ${a}
-`);
-      process5.exit(2);
-    }
-  }
-  return args;
-}
-function _parseInt(value, flag) {
-  const n = Number(value);
-  if (value === void 0 || !Number.isInteger(n)) {
-    process5.stderr.write(
-      `memory_lookup: error: argument ${flag}: invalid int value: '${value ?? ""}'
-`
-    );
-    process5.exit(2);
-  }
-  return n;
-}
-function _checkChoice2(value, choices, flag) {
-  if (value === void 0 || !choices.includes(value)) {
-    process5.stderr.write(
-      `memory_lookup: error: argument ${flag}: invalid choice: '${value ?? ""}' (choose from ${choices.map((c) => `'${c}'`).join(", ")})
-`
-    );
-    process5.exit(2);
-  }
-  return value;
-}
-function _printUsage() {
-  process5.stdout.write(
-    "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() {
-  const args = _parseArgs3(process5.argv.slice(2));
-  const types = args.types.split(",").map((t) => t.trim()).filter((t) => t);
-  if (types.length === 0) {
-    process5.stderr.write("error: --types is required\n");
-    return 2;
-  }
-  if (args.envelope === "v1") {
-    const opts = { detail: args.detail };
-    if (args.tokenBudget !== null) {
-      opts.token_budget = args.tokenBudget;
-    }
-    const envelope = retrieve_v1(types, args.key, args.limit, opts);
-    process5.stdout.write(`${pyJsonDumps2(envelope, 2)}
-`);
-    return 0;
-  }
-  const hits = retrieve(types, args.key, args.limit);
-  if (args.format === "json") {
-    const payload = {
-      hits: hits.map((h) => h.as_dict())
-    };
-    process5.stdout.write(`${pyJsonDumps2(payload, 2)}
-`);
-  } else {
-    if (hits.length === 0) {
-      process5.stdout.write("  (no hits)\n");
-    }
-    for (const h of hits) {
-      process5.stdout.write(
-        `  [${h.source}] ${h.type}  score=${_fixed2(h.score)}  id=${h.id || "-"}  path=${h.path}
-`
-      );
-    }
-  }
-  return 0;
-}
-function _fixed2(n) {
-  return n.toFixed(2);
-}
-function _round4(n) {
-  return _pyRound(n, 4);
-}
-function _pyRound(value, ndigits) {
-  const factor = 10 ** ndigits;
-  const scaled = value * factor;
-  const floor = Math.floor(scaled);
-  const diff = scaled - floor;
-  let rounded;
-  if (diff > 0.5) {
-    rounded = floor + 1;
-  } else if (diff < 0.5) {
-    rounded = floor;
-  } else {
-    rounded = floor % 2 === 0 ? floor : floor + 1;
-  }
-  return rounded / factor;
-}
-function _fnmatch(name, pattern) {
-  const re = _fnmatchTranslate(pattern);
-  return re.test(name);
-}
-function _fnmatchTranslate(pat) {
-  let res = "";
-  let i = 0;
-  const n = pat.length;
-  while (i < n) {
-    const c = pat[i];
-    i += 1;
-    if (c === "*") {
-      res += ".*";
-    } else if (c === "?") {
-      res += ".";
-    } else if (c === "[") {
-      let j = i;
-      if (j < n && pat[j] === "!") {
-        j += 1;
-      }
-      if (j < n && pat[j] === "]") {
-        j += 1;
-      }
-      while (j < n && pat[j] !== "]") {
-        j += 1;
-      }
-      if (j >= n) {
-        res += "\\[";
-      } else {
-        let stuff = pat.slice(i, j);
-        if (!stuff.includes("-")) {
-          stuff = stuff.replace(/\\/g, "\\\\");
-        } else {
-          stuff = stuff.replace(/\\/g, "\\\\");
-        }
-        i = j + 1;
-        if (stuff.startsWith("!")) {
-          stuff = `^${stuff.slice(1)}`;
-        } else if (stuff.startsWith("^") || stuff.startsWith("[")) {
-          stuff = `\\${stuff}`;
-        }
-        res += `[${stuff}]`;
-      }
-    } else {
-      res += _reEscape(c);
-    }
-  }
-  return new RegExp(`^(?:${res})$`, "s");
-}
-function _reEscape(ch) {
-  return ch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function _pyStr2(value) {
-  if (value === null || value === void 0) {
-    return "None";
-  }
-  if (value === true) {
-    return "True";
-  }
-  if (value === false) {
-    return "False";
-  }
-  return String(value);
-}
-function _pyRepr(s) {
-  const hasSingle = s.includes("'");
-  const hasDouble = s.includes('"');
-  const quote = hasSingle && !hasDouble ? '"' : "'";
-  let out = quote;
-  for (const ch of s) {
-    if (ch === quote || ch === "\\") {
-      out += `\\${ch}`;
-    } else if (ch === "\n") {
-      out += "\\n";
-    } else if (ch === "\r") {
-      out += "\\r";
-    } else if (ch === "	") {
-      out += "\\t";
-    } else {
-      out += ch;
-    }
-  }
-  return out + quote;
-}
-function _rglobYmlSorted(root) {
-  const out = [];
-  const walk = (dir) => {
-    let entries;
-    try {
-      entries = fs7.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const ent of entries) {
-      const full = path7.join(dir, ent.name);
-      if (ent.name.endsWith(".yml")) {
-        out.push(full);
-      }
-      if (ent.isDirectory() || ent.isSymbolicLink() && _isDir2(full)) {
-        walk(full);
-      }
-    }
-  };
-  walk(root);
-  out.sort();
-  return out;
-}
-function _globJsonlSorted(dir) {
-  return _globSorted(dir, ".jsonl");
-}
-function _globMdSorted(dir) {
-  return _globSorted(dir, ".md");
-}
-function _globSorted(dir, suffix) {
-  let entries;
-  try {
-    entries = fs7.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));
-  out.sort();
-  return out;
-}
-function _iterdirSorted(dir) {
-  let names;
-  try {
-    names = fs7.readdirSync(dir);
-  } catch {
-    return [];
-  }
-  const out = names.map((name) => path7.join(dir, name));
-  out.sort();
-  return out;
-}
-function _stem(p) {
-  const base = path7.basename(p);
-  const dot = base.lastIndexOf(".");
-  return dot <= 0 ? base : base.slice(0, dot);
-}
-function pyJsonDumps2(value, indent) {
-  return _escapeNonAscii3(_dumpsIndent2(value, indent, 0));
-}
-function _dumpsIndent2(value, indent, depth) {
-  const pad = " ".repeat(indent * (depth + 1));
-  const closePad = " ".repeat(indent * depth);
-  if (value === null || value === void 0) {
-    return "null";
-  }
-  if (typeof value === "boolean") {
-    return value ? "true" : "false";
-  }
-  if (typeof value === "number") {
-    return _jsonNum2(value);
-  }
-  if (typeof value === "string") {
-    return _jsonStrAscii2(value);
-  }
-  if (value instanceof PyTimestamp2) {
-    return _jsonStrAscii2(value.pyStr);
-  }
-  if (value instanceof PyFloat3) {
-    return _jsonFloat2(value.value);
-  }
-  if (Array.isArray(value)) {
-    if (value.length === 0) {
-      return "[]";
-    }
-    const items = value.map((v) => pad + _dumpsIndent2(v, indent, depth + 1));
-    return `[
-${items.join(",\n")}
-${closePad}]`;
-  }
-  if (_isPlainObject4(value)) {
-    const keys = Object.keys(value);
-    if (keys.length === 0) {
-      return "{}";
-    }
-    const items = keys.map((k) => `${pad}${_jsonStrAscii2(k)}: ${_dumpsIndent2(value[k], indent, depth + 1)}`);
-    return `{
-${items.join(",\n")}
-${closePad}}`;
-  }
-  return _jsonStrAscii2(String(value));
-}
-function _jsonNum2(n) {
-  if (!Number.isFinite(n)) {
-    if (Number.isNaN(n)) {
-      return "NaN";
-    }
-    return n > 0 ? "Infinity" : "-Infinity";
-  }
-  return String(n);
-}
-function _jsonFloat2(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 _jsonStrAscii2(s) {
-  let out = '"';
-  for (const ch of s) {
-    const code = ch.codePointAt(0) ?? 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 _escapeNonAscii3(s) {
-  let out = "";
-  for (const ch of s) {
-    const code = ch.codePointAt(0) ?? 0;
-    if (code > 127) {
-      for (let i = 0; i < ch.length; i += 1) {
-        out += `\\u${ch.charCodeAt(i).toString(16).padStart(4, "0")}`;
-      }
-    } else {
-      out += ch;
-    }
-  }
-  return out;
-}
-function _isCliEntry4() {
-  if (process5.argv[1] === void 0) {
-    return false;
-  }
-  const argvUrl = pathToFileURL4(path7.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]));
-    return here === argv;
-  } catch {
-    return false;
-  }
-}
-var _isMain3 = _isCliEntry4();
-if (_isMain3) {
-  process5.exit(main5());
-}
+  memory_get_v1
+} from "./chunk-XGA2NTU4.js";
+import "./chunk-OY53J6II.js";
+import "./chunk-J55WI3RR.js";
 
 // src/scripts/_cli/cmd_memory_get.ts
-var PROG2 = "agent-config memory:get";
-var USAGE = `usage: ${PROG2} <id> [<id> ...] [--format text|json]
+import process from "node:process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+var PROG = "agent-config memory:get";
+var USAGE = `usage: ${PROG} <id> [<id> ...] [--format text|json]
 `;
 var ArgparseExit = class extends Error {
   constructor(code) {
@@ -3740,9 +21,9 @@ var ArgparseExit = class extends Error {
   }
   code;
 };
-function _argError3(msg) {
-  process6.stderr.write(USAGE);
-  process6.stderr.write(`${PROG2}: error: ${msg}
+function _argError(msg) {
+  process.stderr.write(USAGE);
+  process.stderr.write(`${PROG}: error: ${msg}
 `);
   throw new ArgparseExit(2);
 }
@@ -3752,7 +33,7 @@ function _parse(argv) {
   while (i < argv.length) {
     const a = argv[i];
     if (a === "-h" || a === "--help") {
-      process6.stdout.write(
+      process.stdout.write(
         `${USAGE}
 Batch-fetch FULL memory entries by id \u2014 the second half of the
 index-first retrieval workflow (\`memory:lookup --detail index\`
@@ -3771,28 +52,28 @@ exit codes:
       throw new ArgparseExit(0);
     } else if (a === "--format") {
       const val = argv[i + 1];
-      if (val === void 0) _argError3("argument --format: expected one argument");
+      if (val === void 0) _argError("argument --format: expected one argument");
       if (val !== "text" && val !== "json") {
-        _argError3(`argument --format: invalid choice: '${val}' (choose from 'text', 'json')`);
+        _argError(`argument --format: invalid choice: '${val}' (choose from 'text', 'json')`);
       }
       opts.format = val;
       i += 2;
     } else if (a.startsWith("--format=")) {
       const val = a.slice("--format=".length);
       if (val !== "text" && val !== "json") {
-        _argError3(`argument --format: invalid choice: '${val}' (choose from 'text', 'json')`);
+        _argError(`argument --format: invalid choice: '${val}' (choose from 'text', 'json')`);
       }
       opts.format = val;
       i += 1;
     } else if (a.startsWith("--")) {
-      _argError3(`unrecognized arguments: ${a}`);
+      _argError(`unrecognized arguments: ${a}`);
     } else {
       opts.ids.push(a);
       i += 1;
     }
   }
   if (opts.ids.length === 0) {
-    _argError3("at least one <id> is required");
+    _argError("at least one <id> is required");
   }
   return opts;
 }
@@ -3819,54 +100,54 @@ function _renderValue(value) {
   }
   return JSON.stringify(value);
 }
-function main6(argv = null) {
-  const opts = _parse(argv ?? process6.argv.slice(2));
+function main(argv = null) {
+  const opts = _parse(argv ?? process.argv.slice(2));
   const envelope = memory_get_v1(opts.ids);
   const entries = Array.isArray(envelope["entries"]) ? envelope["entries"] : [];
   const idStatus = isPlainObject(envelope["ids"]) ? envelope["ids"] : {};
   const unknown = opts.ids.filter((id) => idStatus[id] === "unknown");
   if (opts.format === "json") {
-    process6.stdout.write(`${JSON.stringify(envelope, null, 2)}
+    process.stdout.write(`${JSON.stringify(envelope, null, 2)}
 `);
   } else {
     if (entries.length === 0) {
-      process6.stdout.write("  (no entries found)\n");
+      process.stdout.write("  (no entries found)\n");
     } else {
       for (const entry of entries) {
-        process6.stdout.write(`${_renderEntryText(entry)}
+        process.stdout.write(`${_renderEntryText(entry)}
 `);
       }
     }
     for (const id of unknown) {
-      process6.stderr.write(`${PROG2}: unknown id: ${id}
+      process.stderr.write(`${PROG}: unknown id: ${id}
 `);
     }
   }
   return unknown.length > 0 ? 1 : 0;
 }
-var _HERE2 = fileURLToPath7(import.meta.url);
-function _isCliEntry5() {
-  if (process6.argv[1] === void 0) {
+var _HERE = fileURLToPath(import.meta.url);
+function _isCliEntry() {
+  if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL5(path8.resolve(process6.argv[1])).href;
+  const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs8.realpathSync(fileURLToPath7(import.meta.url));
-    const argv = fs8.realpathSync(path8.resolve(process6.argv[1]));
+    const here = fs.realpathSync(fileURLToPath(import.meta.url));
+    const argv = fs.realpathSync(path.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry5() || process6.argv[1] === _HERE2) {
+if (_isCliEntry() || process.argv[1] === _HERE) {
   try {
-    process6.exitCode = main6(process6.argv.slice(2));
+    process.exitCode = main(process.argv.slice(2));
   } catch (exc) {
     if (exc instanceof ArgparseExit) {
-      process6.exitCode = exc.code;
+      process.exitCode = exc.code;
     } else {
       throw exc;
     }
@@ -3874,5 +155,5 @@ if (_isCliEntry5() || process6.argv[1] === _HERE2) {
 }
 export {
   ArgparseExit,
-  main6 as main
+  main
 };