@event4u/agent-config 9.10.0 → 9.12.0

package/dist/cli-delegate/cmd_memory_get.js

@@ -0,0 +1,3878 @@
+#!/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());
+}
+
+// src/scripts/_cli/cmd_memory_get.ts
+var PROG2 = "agent-config memory:get";
+var USAGE = `usage: ${PROG2} <id> [<id> ...] [--format text|json]
+`;
+var ArgparseExit = class extends Error {
+  constructor(code) {
+    super(`argparse-exit-${code}`);
+    this.code = code;
+  }
+  code;
+};
+function _argError3(msg) {
+  process6.stderr.write(USAGE);
+  process6.stderr.write(`${PROG2}: error: ${msg}
+`);
+  throw new ArgparseExit(2);
+}
+function _parse(argv) {
+  const opts = { ids: [], format: "text" };
+  let i = 0;
+  while (i < argv.length) {
+    const a = argv[i];
+    if (a === "-h" || a === "--help") {
+      process6.stdout.write(
+        `${USAGE}
+Batch-fetch FULL memory entries by id \u2014 the second half of the
+index-first retrieval workflow (\`memory:lookup --detail index\`
+first, then \`memory:get\` the ids that justify the fetch).
+
+options:
+  --format text|json   output format (default: text)
+  -h, --help           show this help and exit
+
+exit codes:
+  0  every requested id was found
+  1  at least one requested id was not found
+  2  usage error
+`
+      );
+      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 !== "text" && val !== "json") {
+        _argError3(`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')`);
+      }
+      opts.format = val;
+      i += 1;
+    } else if (a.startsWith("--")) {
+      _argError3(`unrecognized arguments: ${a}`);
+    } else {
+      opts.ids.push(a);
+      i += 1;
+    }
+  }
+  if (opts.ids.length === 0) {
+    _argError3("at least one <id> is required");
+  }
+  return opts;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function _renderEntryText(entry) {
+  const lines = [];
+  const id = typeof entry["id"] === "string" ? entry["id"] : "(unknown id)";
+  const type = typeof entry["type"] === "string" ? entry["type"] : "(unknown type)";
+  lines.push(`[${id}] ${type}`);
+  const body = entry["body"];
+  if (isPlainObject(body)) {
+    for (const key of Object.keys(body).sort()) {
+      lines.push(`  ${key}: ${_renderValue(body[key])}`);
+    }
+  }
+  return lines.join("\n");
+}
+function _renderValue(value) {
+  if (typeof value === "string") return value;
+  if (isPlainObject(value) && typeof value["pyStr"] === "string" && Object.keys(value).length === 1) {
+    return value["pyStr"];
+  }
+  return JSON.stringify(value);
+}
+function main6(argv = null) {
+  const opts = _parse(argv ?? process6.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)}
+`);
+  } else {
+    if (entries.length === 0) {
+      process6.stdout.write("  (no entries found)\n");
+    } else {
+      for (const entry of entries) {
+        process6.stdout.write(`${_renderEntryText(entry)}
+`);
+      }
+    }
+    for (const id of unknown) {
+      process6.stderr.write(`${PROG2}: unknown id: ${id}
+`);
+    }
+  }
+  return unknown.length > 0 ? 1 : 0;
+}
+var _HERE2 = fileURLToPath7(import.meta.url);
+function _isCliEntry5() {
+  if (process6.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL5(path8.resolve(process6.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]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry5() || process6.argv[1] === _HERE2) {
+  try {
+    process6.exitCode = main6(process6.argv.slice(2));
+  } catch (exc) {
+    if (exc instanceof ArgparseExit) {
+      process6.exitCode = exc.code;
+    } else {
+      throw exc;
+    }
+  }
+}
+export {
+  ArgparseExit,
+  main6 as main
+};