@event4u/agent-config 16.1.0 → 16.3.0

package/dist/cli-delegate/chunk-JQOM7TTM.js

@@ -0,0 +1,1201 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  DeadScopeError,
+  assertScanned
+} from "./chunk-I3EIN2YG.js";
+
+// src/scripts/_lib/security_lint.ts
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+var _HERE = path.dirname(fileURLToPath(import.meta.url));
+var ROOT = path.resolve(_HERE, "..", "..", "..");
+var EXAMPLE_FENCE_LANG = "security-example";
+var GUIDELINE = "docs/guidelines/agent-infra/security-lint-containment.md";
+var GUIDELINE_EPILOG = `False-positive containment (fenced security-example block, confidence weighting, per-file \`security-lint: allow\` pragma \u2014 no global allowlist): see ${GUIDELINE}.`;
+var DEFAULT_SCAN_ROOTS = [
+  "src/skills",
+  "src/rules",
+  "src/agent-src",
+  "src/domains",
+  "dist/agent-src"
+];
+var _EXAMPLE_PATH = /(^|\/)(docs|evals|tests?|fixtures?)(\/|$)|example|template|sample|\/_template/i;
+var _PRAGMA = /<!--\s*security-lint:\s*allow\s+([A-Za-z0-9_-]+)\s+"([^"]+)"((?:\s+sha256:[0-9a-f]{64})*)\s*-->/g;
+var _FENCE = /^(\s*)(`{3,}|~{3,})\s*([A-Za-z0-9_-]*)\s*$/;
+var SEVERITY_RANK = { LOW: 1, MED: 2, HIGH: 3 };
+var Finding = class {
+  path;
+  // repo-relative
+  line;
+  // 1-based; 0 = file-level
+  check;
+  // stable check id, also the pragma key
+  severity;
+  // HIGH | MED | LOW
+  message;
+  weight;
+  // 1.0 or 0.25
+  constructor(pathArg, line, check, severity, message, weight = 1) {
+    this.path = pathArg;
+    this.line = line;
+    this.check = check;
+    this.severity = severity;
+    this.message = message;
+    this.weight = weight;
+  }
+  /** A HIGH-severity, full-weight finding fails the build. */
+  get is_fail() {
+    return this.severity === "HIGH" && this.weight >= 1;
+  }
+  /** Mirror Python dataclass `__dict__` key order for `--json` parity. */
+  toDict() {
+    return {
+      path: this.path,
+      line: this.line,
+      check: this.check,
+      severity: this.severity,
+      message: this.message,
+      // float in Python → render integer-valued (1.0) as `1.0`.
+      weight: new PyFloat(this.weight)
+    };
+  }
+};
+function is_example_path(rel_path) {
+  return _EXAMPLE_PATH.test(rel_path);
+}
+function path_weight(rel_path) {
+  return is_example_path(rel_path) ? 0.25 : 1;
+}
+var PROJECTION_PREFIX = "dist/agent-src/";
+var PROJECTION_SOURCE_LANES = [
+  // The guidelines lane copies `docs/guidelines/` (`_lib/guidelines_lane.ts`),
+  // not `src/guidelines/`, which does not exist. Without this row a projected
+  // guideline gets a DIFFERENT identity from its own source, so a bound
+  // pragma written in the source cannot suppress the projection's copy of the
+  // very same line — measured on
+  // `untrusted-input-spotlighting.md`, a defense guideline that quotes
+  // role-takeover phrases to teach refusal and carries three accepted
+  // fingerprints for exactly that.
+  ["guidelines/", "docs/guidelines/"]
+];
+function source_identity(rel) {
+  if (!rel.startsWith(PROJECTION_PREFIX)) return rel;
+  const tail = rel.slice(PROJECTION_PREFIX.length);
+  for (const [lane, sourceRoot] of PROJECTION_SOURCE_LANES) {
+    if (tail.startsWith(lane)) return sourceRoot + tail.slice(lane.length);
+  }
+  return `src/${tail}`;
+}
+var ScannedFile = class {
+  path;
+  // absolute or as-given path
+  rel;
+  lines;
+  // per-line flags (1-based index → flag); index 0 unused
+  in_example_fence;
+  in_any_fence;
+  pragmas;
+  // check id → reason
+  /** check id → the sha256 fingerprints that pragma accepts. Empty = unbound. */
+  pragma_hashes;
+  weight;
+  constructor(pathArg, rel, lines, in_example_fence, in_any_fence, pragmas, weight, pragma_hashes = {}) {
+    this.path = pathArg;
+    this.rel = rel;
+    this.lines = lines;
+    this.in_example_fence = in_example_fence;
+    this.in_any_fence = in_any_fence;
+    this.pragmas = pragmas;
+    this.weight = weight;
+    this.pragma_hashes = pragma_hashes;
+  }
+  pragma_allows(check) {
+    return Object.prototype.hasOwnProperty.call(this.pragmas, check);
+  }
+  /**
+   * Which form of pragma this file carries for `check`.
+   *
+   * `absent`  — no pragma; scan normally.
+   * `legacy`  — a pragma with no fingerprint. Suppresses the whole file, as it
+   *             always did, and says so: a key lookup accepts whatever the
+   *             line is later changed to say, which is the defect being paid
+   *             down, not a mode anybody should choose.
+   * `bound`   — a pragma listing fingerprints. Suppresses exactly the matches
+   *             whose evidence hashes to one of them; anything else survives.
+   */
+  pragma_form(check) {
+    if (!this.pragma_allows(check)) return "absent";
+    return (this.pragma_hashes[check] ?? []).length > 0 ? "bound" : "legacy";
+  }
+  /**
+   * The fingerprint one finding's evidence hashes to.
+   *
+   * WHAT IS HASHED, and each part earns its place:
+   *   check id      — the same line may legitimately be accepted for one check
+   *                   and not another.
+   *   rel path      — the location IDENTITY. Not the line NUMBER: an unrelated
+   *                   insert above would otherwise break every pragma in the
+   *                   file, and a suppression that breaks on unrelated edits
+   *                   gets deleted rather than re-derived. A `dist/agent-src/`
+   *                   path folds to its `src/` original first, because the
+   *                   projection is byte-exact by contract (ADR-201) and
+   *                   carries the pragma verbatim — without the fold, every
+   *                   migrated pragma would suppress the source and leave its
+   *                   own copy flagged, which is a gate that reds on a file
+   *                   nobody may edit.
+   *   matched line, — the evidence. ASCII whitespace runs collapse so a reflow
+   *   normalized      does not invalidate the binding, `sha256:<hex>` tokens are
+   *                   removed, and NOTHING else is stripped: the zero-width
+   *                   characters this suite hunts are exactly what a wider
+   *                   normalizer would erase.
+   *
+   * WHY THE HASH TOKENS COME OUT. A pragma's own reason string can be the
+   * matched evidence — two in this tree are, because they quote the very
+   * phrases their check detects in order to explain themselves. Without this
+   * the fingerprint would have to be computed over a line that already
+   * contains it, which has no fixed point: writing the hash changes the line,
+   * which changes the hash. Stripping the tokens makes the fingerprint stable
+   * under the act of recording it, and costs nothing elsewhere — a `sha256:`
+   * token in ordinary prose is not evidence of anything a linter here checks.
+   *
+   * Deliberately NOT the whole file: incidental content elsewhere would make
+   * every unrelated edit re-fire the pragma, which is the noise that produces
+   * blanket suppressions.
+   */
+  evidence_fingerprint(finding) {
+    const text = finding.line > 0 ? this.lines[finding.line - 1] ?? "" : "";
+    const normalized = text.replace(/\s*sha256:[0-9a-f]{64}/g, "").replace(/[ \t]+/g, " ").trim();
+    return createHash("sha256").update(`${finding.check}
+${source_identity(this.rel)}
+${normalized}`, "utf-8").digest("hex");
+  }
+  /** Drop the findings this file's BOUND pragma for `check` accepts. */
+  filter_bound_pragma(check, findings) {
+    const accepted = new Set(this.pragma_hashes[check] ?? []);
+    if (accepted.size === 0) return [...findings];
+    return findings.filter((f) => !accepted.has(this.evidence_fingerprint(f)));
+  }
+  /** Yield [lineno, text] honouring the fence masks (mirrors iter_lines). */
+  *iter_lines(opts = {}) {
+    const skip_example_fence = opts.skip_example_fence ?? true;
+    const skip_any_fence = opts.skip_any_fence ?? false;
+    for (let i = 1; i <= this.lines.length; i++) {
+      if (skip_example_fence && this.in_example_fence[i]) {
+        continue;
+      }
+      if (skip_any_fence && this.in_any_fence[i]) {
+        continue;
+      }
+      yield [i, this.lines[i - 1]];
+    }
+  }
+};
+function _splitlines(text) {
+  const out = [];
+  let buf = "";
+  const n = text.length;
+  let i = 0;
+  while (i < n) {
+    const ch = text[i];
+    const code = text.charCodeAt(i);
+    if (code === 13) {
+      out.push(buf);
+      buf = "";
+      if (i + 1 < n && text.charCodeAt(i + 1) === 10) {
+        i += 2;
+      } else {
+        i += 1;
+      }
+      continue;
+    }
+    if (code === 10 || code === 11 || code === 12 || code === 28 || code === 29 || code === 30 || code === 133 || code === 8232 || code === 8233) {
+      out.push(buf);
+      buf = "";
+      i += 1;
+      continue;
+    }
+    buf += ch;
+    i += 1;
+  }
+  if (buf !== "") {
+    out.push(buf);
+  }
+  return out;
+}
+function scan_file(filePath) {
+  let rel;
+  if (path.isAbsolute(filePath)) {
+    const root = path.resolve(ROOT);
+    const resolved = path.resolve(filePath);
+    if (resolved === root || resolved.startsWith(root + path.sep)) {
+      rel = path.relative(root, resolved).split(path.sep).join("/");
+    } else {
+      rel = path.basename(filePath);
+    }
+  } else {
+    rel = filePath.split(path.sep).join("/");
+  }
+  const raw = fs.readFileSync(filePath, "utf-8");
+  const lines = _splitlines(raw);
+  const n = lines.length;
+  const in_example = new Array(n + 1).fill(false);
+  const in_any = new Array(n + 1).fill(false);
+  let fence_open = false;
+  let fence_marker = "";
+  let fence_is_example = false;
+  for (let idx = 1; idx <= n; idx++) {
+    const text = lines[idx - 1];
+    const m = _FENCE.exec(text);
+    if (m && !fence_open) {
+      fence_open = true;
+      fence_marker = m[2][0];
+      fence_is_example = m[3] === EXAMPLE_FENCE_LANG;
+      in_any[idx] = true;
+      in_example[idx] = fence_is_example;
+      continue;
+    }
+    if (fence_open) {
+      in_any[idx] = true;
+      in_example[idx] = fence_is_example;
+      const cm = _FENCE.exec(text);
+      if (cm && cm[2][0] === fence_marker && cm[3] === "") {
+        fence_open = false;
+        fence_is_example = false;
+      }
+    }
+  }
+  const pragmas = {};
+  const pragmaHashes = {};
+  for (const text of lines) {
+    _PRAGMA.lastIndex = 0;
+    let m;
+    while ((m = _PRAGMA.exec(text)) !== null) {
+      const check = m[1];
+      pragmas[check] = m[2];
+      const hashes = (m[3] ?? "").match(/sha256:([0-9a-f]{64})/g) ?? [];
+      pragmaHashes[check] = [
+        ...pragmaHashes[check] ?? [],
+        ...hashes.map((h) => h.slice("sha256:".length))
+      ];
+      if (m.index === _PRAGMA.lastIndex) {
+        _PRAGMA.lastIndex += 1;
+      }
+    }
+  }
+  return new ScannedFile(
+    filePath,
+    rel,
+    lines,
+    in_example,
+    in_any,
+    pragmas,
+    path_weight(rel),
+    pragmaHashes
+  );
+}
+function scan_path(filePath, base) {
+  const sf = scan_file(filePath);
+  let rel;
+  const baseResolved = path.resolve(base);
+  const fileResolved = path.resolve(filePath);
+  if (fileResolved === baseResolved || fileResolved.startsWith(baseResolved + path.sep)) {
+    rel = path.relative(baseResolved, fileResolved).split(path.sep).join("/");
+  } else {
+    rel = path.basename(filePath);
+  }
+  return new ScannedFile(
+    sf.path,
+    rel,
+    sf.lines,
+    sf.in_example_fence,
+    sf.in_any_fence,
+    sf.pragmas,
+    path_weight(rel),
+    sf.pragma_hashes
+  );
+}
+function _rglobSorted(base) {
+  const found = [];
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const full = path.join(dir, e.name);
+      found.push(full);
+      if (e.isDirectory()) {
+        walk(full);
+      }
+    }
+  };
+  walk(base);
+  found.sort((a, b) => _pathCmp(a, b));
+  return found;
+}
+function _pathCmp(a, b) {
+  const pa = a.split(path.sep);
+  const pb = b.split(path.sep);
+  const len = Math.min(pa.length, pb.length);
+  for (let i = 0; i < len; i++) {
+    if (pa[i] < pb[i]) return -1;
+    if (pa[i] > pb[i]) return 1;
+  }
+  if (pa.length < pb.length) return -1;
+  if (pa.length > pb.length) return 1;
+  return 0;
+}
+function* iter_corpus(roots = DEFAULT_SCAN_ROOTS, exts = [".md"], scanBase = ROOT) {
+  for (const root of roots) {
+    const base = path.join(scanBase, root);
+    if (!fs.existsSync(base)) {
+      continue;
+    }
+    for (const p of _rglobSorted(base)) {
+      let st;
+      try {
+        st = fs.statSync(p);
+      } catch {
+        continue;
+      }
+      if (st.isFile() && exts.includes(path.extname(p))) {
+        yield scan_path(p, scanBase);
+      }
+    }
+  }
+}
+var LEGACY_PRAGMA_CHECK = "legacy-pragma";
+function legacy_pragma_finding(sf, check) {
+  return new Finding(
+    sf.rel,
+    0,
+    LEGACY_PRAGMA_CHECK,
+    "LOW",
+    `unbound \`security-lint: allow ${check}\` pragma suppresses this whole file \u2014 it accepts whatever the matched text is later changed to say. Bind it with \`sha256:<hex>\` per accepted match.`,
+    sf.weight
+  );
+}
+var CHILD_SCANNED_PREFIX = "scanned: ";
+function report_child_scanned(count) {
+  process.stderr.write(`${CHILD_SCANNED_PREFIX}${String(count)}
+`);
+}
+function report(findings, opts) {
+  const check_label = opts.check_label;
+  if (findings.length === 0) {
+    process.stdout.write(`\u2705  ${check_label}: clean (${_corpus_note(opts.scanned_roots)}).
+`);
+    return 0;
+  }
+  const fails = findings.filter((f) => f.is_fail);
+  const warns = findings.filter((f) => !f.is_fail);
+  const sorted = [...findings].sort((a, b) => {
+    const ra = -(SEVERITY_RANK[a.severity] ?? 0);
+    const rb = -(SEVERITY_RANK[b.severity] ?? 0);
+    if (ra !== rb) return ra - rb;
+    if (a.path < b.path) return -1;
+    if (a.path > b.path) return 1;
+    return a.line - b.line;
+  });
+  for (const f of sorted) {
+    const glyph = f.is_fail ? "\u{1F534}" : "\u26A0\uFE0F";
+    const loc = f.line ? `${f.path}:${f.line}` : f.path;
+    const wnote = f.weight >= 1 ? "" : ` (weight ${_pyG(f.weight)})`;
+    process.stdout.write(`  ${glyph} [${f.severity}] ${f.check} \u2014 ${loc}${wnote}: ${f.message}
+`);
+  }
+  process.stdout.write("\n");
+  if (fails.length > 0) {
+    process.stdout.write(
+      `\u274C  ${check_label}: ${fails.length} blocking finding(s), ${warns.length} warning(s). Fix, or mark a true teaching example with a \`\`\`${EXAMPLE_FENCE_LANG} fence or a \`security-lint: allow\` pragma.
+`
+    );
+    return 1;
+  }
+  process.stdout.write(`\u26A0\uFE0F  ${check_label}: ${warns.length} warning(s), 0 blocking.
+`);
+  return 0;
+}
+function _pyG(n) {
+  let s = n.toPrecision(6);
+  if (s.includes(".")) {
+    s = s.replace(/0+$/, "").replace(/\.$/, "");
+  }
+  return s;
+}
+function _corpus_note(scanned_roots) {
+  const roots = scanned_roots && scanned_roots.length > 0 ? scanned_roots : DEFAULT_SCAN_ROOTS;
+  return "scanned " + roots.join(", ");
+}
+var PyFloat = class {
+  constructor(value) {
+    this.value = value;
+  }
+  value;
+};
+function _isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) && !(v instanceof PyFloat);
+}
+function _pyJsonStr(s) {
+  let out = '"';
+  for (const ch of s) {
+    const code = ch.codePointAt(0);
+    switch (ch) {
+      case '"':
+        out += '\\"';
+        break;
+      case "\\":
+        out += "\\\\";
+        break;
+      case "\n":
+        out += "\\n";
+        break;
+      case "\r":
+        out += "\\r";
+        break;
+      case "	":
+        out += "\\t";
+        break;
+      case "\b":
+        out += "\\b";
+        break;
+      case "\f":
+        out += "\\f";
+        break;
+      default:
+        if (code < 32) {
+          out += `\\u${code.toString(16).padStart(4, "0")}`;
+        } else {
+          out += ch;
+        }
+    }
+  }
+  return out + '"';
+}
+function _pyJsonFloat(n) {
+  if (!Number.isFinite(n)) {
+    if (Number.isNaN(n)) return "NaN";
+    return n > 0 ? "Infinity" : "-Infinity";
+  }
+  return Number.isInteger(n) ? `${n}.0` : String(n);
+}
+function _pyJsonScalar(value) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (value instanceof PyFloat) return _pyJsonFloat(value.value);
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      if (Number.isNaN(value)) return "NaN";
+      return value > 0 ? "Infinity" : "-Infinity";
+    }
+    return String(value);
+  }
+  if (typeof value === "string") return _pyJsonStr(value);
+  return null;
+}
+function py_json_dumps_indent2(value, depth = 0) {
+  return _dumpIndent2(value, depth, true);
+}
+function _dumpIndent2(value, depth, ensureAscii) {
+  const scalar = ensureAscii ? _pyJsonScalarAscii(value) : _pyJsonScalar(value);
+  if (scalar !== null) {
+    return scalar;
+  }
+  const pad = " ".repeat(2 * (depth + 1));
+  const closePad = " ".repeat(2 * depth);
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    const items = value.map((v) => pad + _dumpIndent2(v, depth + 1, ensureAscii));
+    return `[
+${items.join(",\n")}
+${closePad}]`;
+  }
+  if (_isPlainObject(value)) {
+    const keys = Object.keys(value);
+    if (keys.length === 0) return "{}";
+    const items = keys.map(
+      (k) => `${pad}${ensureAscii ? _pyJsonStrAscii(k) : _pyJsonStr(k)}: ${_dumpIndent2(value[k], depth + 1, ensureAscii)}`
+    );
+    return `{
+${items.join(",\n")}
+${closePad}}`;
+  }
+  return ensureAscii ? _pyJsonStrAscii(String(value)) : _pyJsonStr(String(value));
+}
+function _pyJsonStrAscii(s) {
+  let out = '"';
+  for (const ch of s) {
+    const code = ch.codePointAt(0);
+    switch (ch) {
+      case '"':
+        out += '\\"';
+        break;
+      case "\\":
+        out += "\\\\";
+        break;
+      case "\n":
+        out += "\\n";
+        break;
+      case "\r":
+        out += "\\r";
+        break;
+      case "	":
+        out += "\\t";
+        break;
+      case "\b":
+        out += "\\b";
+        break;
+      case "\f":
+        out += "\\f";
+        break;
+      default:
+        if (code < 32) {
+          out += `\\u${code.toString(16).padStart(4, "0")}`;
+        } else if (code < 127) {
+          out += ch;
+        } else if (code <= 65535) {
+          out += `\\u${code.toString(16).padStart(4, "0")}`;
+        } else {
+          const cp = code - 65536;
+          const hi = 55296 + (cp >> 10);
+          const lo = 56320 + (cp & 1023);
+          out += `\\u${hi.toString(16).padStart(4, "0")}\\u${lo.toString(16).padStart(4, "0")}`;
+        }
+    }
+  }
+  return out + '"';
+}
+function _pyJsonScalarAscii(value) {
+  if (typeof value === "string") return _pyJsonStrAscii(value);
+  return _pyJsonScalar(value);
+}
+
+// src/scripts/lint_hidden_unicode.ts
+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";
+var CHECK = "hidden-unicode";
+var _BIDI = /* @__PURE__ */ new Set([
+  8234,
+  8235,
+  8236,
+  8237,
+  8238,
+  8294,
+  8295,
+  8296,
+  8297,
+  8206,
+  8207,
+  1564
+]);
+var _ZERO_WIDTH = /* @__PURE__ */ new Set([8203, 8204, 8205, 8288, 65279, 173]);
+var _DEPRECATED = /* @__PURE__ */ new Set([
+  8298,
+  8299,
+  8300,
+  8301,
+  8302,
+  8303,
+  65529,
+  65530,
+  65531
+]);
+function _classify(cp) {
+  if (_BIDI.has(cp)) {
+    return "bidi-control";
+  }
+  if (_ZERO_WIDTH.has(cp)) {
+    return "zero-width";
+  }
+  if (cp >= 917504 && cp <= 917631) {
+    return "unicode-tag";
+  }
+  if (_DEPRECATED.has(cp)) {
+    return "deprecated-format";
+  }
+  if (cp >= 57344 && cp <= 63743 || cp >= 983040 && cp <= 1048573 || cp >= 1048576 && cp <= 1114109) {
+    return "private-use-area";
+  }
+  if ((cp >= 0 && cp <= 31 || cp >= 127 && cp <= 159) && cp !== 9 && cp !== 10 && cp !== 13) {
+    return "control-char";
+  }
+  return null;
+}
+var _VS_LO = 917760;
+var _VS_HI = 917999;
+function _isVS(cp) {
+  return cp >= _VS_LO && cp <= _VS_HI;
+}
+var _CP_NAME = {
+  173: "SOFT HYPHEN",
+  1564: "ARABIC LETTER MARK",
+  8203: "ZERO WIDTH SPACE",
+  8204: "ZERO WIDTH NON-JOINER",
+  8205: "ZERO WIDTH JOINER",
+  8206: "LEFT-TO-RIGHT MARK",
+  8207: "RIGHT-TO-LEFT MARK",
+  8234: "LEFT-TO-RIGHT EMBEDDING",
+  8235: "RIGHT-TO-LEFT EMBEDDING",
+  8236: "POP DIRECTIONAL FORMATTING",
+  8237: "LEFT-TO-RIGHT OVERRIDE",
+  8238: "RIGHT-TO-LEFT OVERRIDE",
+  8288: "WORD JOINER",
+  8294: "LEFT-TO-RIGHT ISOLATE",
+  8295: "RIGHT-TO-LEFT ISOLATE",
+  8296: "FIRST STRONG ISOLATE",
+  8297: "POP DIRECTIONAL ISOLATE",
+  8298: "INHIBIT SYMMETRIC SWAPPING",
+  8299: "ACTIVATE SYMMETRIC SWAPPING",
+  8300: "INHIBIT ARABIC FORM SHAPING",
+  8301: "ACTIVATE ARABIC FORM SHAPING",
+  8302: "NATIONAL DIGIT SHAPES",
+  8303: "NOMINAL DIGIT SHAPES",
+  65279: "ZERO WIDTH NO-BREAK SPACE",
+  65529: "INTERLINEAR ANNOTATION ANCHOR",
+  65530: "INTERLINEAR ANNOTATION SEPARATOR",
+  65531: "INTERLINEAR ANNOTATION TERMINATOR",
+  917505: "LANGUAGE TAG",
+  917536: "TAG SPACE",
+  917537: "TAG EXCLAMATION MARK",
+  917538: "TAG QUOTATION MARK",
+  917539: "TAG NUMBER SIGN",
+  917540: "TAG DOLLAR SIGN",
+  917541: "TAG PERCENT SIGN",
+  917542: "TAG AMPERSAND",
+  917543: "TAG APOSTROPHE",
+  917544: "TAG LEFT PARENTHESIS",
+  917545: "TAG RIGHT PARENTHESIS",
+  917546: "TAG ASTERISK",
+  917547: "TAG PLUS SIGN",
+  917548: "TAG COMMA",
+  917549: "TAG HYPHEN-MINUS",
+  917550: "TAG FULL STOP",
+  917551: "TAG SOLIDUS",
+  917552: "TAG DIGIT ZERO",
+  917553: "TAG DIGIT ONE",
+  917554: "TAG DIGIT TWO",
+  917555: "TAG DIGIT THREE",
+  917556: "TAG DIGIT FOUR",
+  917557: "TAG DIGIT FIVE",
+  917558: "TAG DIGIT SIX",
+  917559: "TAG DIGIT SEVEN",
+  917560: "TAG DIGIT EIGHT",
+  917561: "TAG DIGIT NINE",
+  917562: "TAG COLON",
+  917563: "TAG SEMICOLON",
+  917564: "TAG LESS-THAN SIGN",
+  917565: "TAG EQUALS SIGN",
+  917566: "TAG GREATER-THAN SIGN",
+  917567: "TAG QUESTION MARK",
+  917568: "TAG COMMERCIAL AT",
+  917569: "TAG LATIN CAPITAL LETTER A",
+  917570: "TAG LATIN CAPITAL LETTER B",
+  917571: "TAG LATIN CAPITAL LETTER C",
+  917572: "TAG LATIN CAPITAL LETTER D",
+  917573: "TAG LATIN CAPITAL LETTER E",
+  917574: "TAG LATIN CAPITAL LETTER F",
+  917575: "TAG LATIN CAPITAL LETTER G",
+  917576: "TAG LATIN CAPITAL LETTER H",
+  917577: "TAG LATIN CAPITAL LETTER I",
+  917578: "TAG LATIN CAPITAL LETTER J",
+  917579: "TAG LATIN CAPITAL LETTER K",
+  917580: "TAG LATIN CAPITAL LETTER L",
+  917581: "TAG LATIN CAPITAL LETTER M",
+  917582: "TAG LATIN CAPITAL LETTER N",
+  917583: "TAG LATIN CAPITAL LETTER O",
+  917584: "TAG LATIN CAPITAL LETTER P",
+  917585: "TAG LATIN CAPITAL LETTER Q",
+  917586: "TAG LATIN CAPITAL LETTER R",
+  917587: "TAG LATIN CAPITAL LETTER S",
+  917588: "TAG LATIN CAPITAL LETTER T",
+  917589: "TAG LATIN CAPITAL LETTER U",
+  917590: "TAG LATIN CAPITAL LETTER V",
+  917591: "TAG LATIN CAPITAL LETTER W",
+  917592: "TAG LATIN CAPITAL LETTER X",
+  917593: "TAG LATIN CAPITAL LETTER Y",
+  917594: "TAG LATIN CAPITAL LETTER Z",
+  917595: "TAG LEFT SQUARE BRACKET",
+  917596: "TAG REVERSE SOLIDUS",
+  917597: "TAG RIGHT SQUARE BRACKET",
+  917598: "TAG CIRCUMFLEX ACCENT",
+  917599: "TAG LOW LINE",
+  917600: "TAG GRAVE ACCENT",
+  917601: "TAG LATIN SMALL LETTER A",
+  917602: "TAG LATIN SMALL LETTER B",
+  917603: "TAG LATIN SMALL LETTER C",
+  917604: "TAG LATIN SMALL LETTER D",
+  917605: "TAG LATIN SMALL LETTER E",
+  917606: "TAG LATIN SMALL LETTER F",
+  917607: "TAG LATIN SMALL LETTER G",
+  917608: "TAG LATIN SMALL LETTER H",
+  917609: "TAG LATIN SMALL LETTER I",
+  917610: "TAG LATIN SMALL LETTER J",
+  917611: "TAG LATIN SMALL LETTER K",
+  917612: "TAG LATIN SMALL LETTER L",
+  917613: "TAG LATIN SMALL LETTER M",
+  917614: "TAG LATIN SMALL LETTER N",
+  917615: "TAG LATIN SMALL LETTER O",
+  917616: "TAG LATIN SMALL LETTER P",
+  917617: "TAG LATIN SMALL LETTER Q",
+  917618: "TAG LATIN SMALL LETTER R",
+  917619: "TAG LATIN SMALL LETTER S",
+  917620: "TAG LATIN SMALL LETTER T",
+  917621: "TAG LATIN SMALL LETTER U",
+  917622: "TAG LATIN SMALL LETTER V",
+  917623: "TAG LATIN SMALL LETTER W",
+  917624: "TAG LATIN SMALL LETTER X",
+  917625: "TAG LATIN SMALL LETTER Y",
+  917626: "TAG LATIN SMALL LETTER Z",
+  917627: "TAG LEFT CURLY BRACKET",
+  917628: "TAG VERTICAL LINE",
+  917629: "TAG RIGHT CURLY BRACKET",
+  917630: "TAG TILDE",
+  917631: "CANCEL TAG"
+};
+function _cpName(cp) {
+  const n = _CP_NAME[cp];
+  return n !== void 0 ? n : "<unnamed>";
+}
+function _scan(sf) {
+  const pragmaForm = sf.pragma_form(CHECK);
+  if (pragmaForm === "legacy") {
+    return [legacy_pragma_finding(sf, CHECK)];
+  }
+  const finish = (hits) => pragmaForm === "bound" ? sf.filter_bound_pragma(CHECK, hits) : hits;
+  const out = [];
+  for (const [lineno, text] of sf.iter_lines({ skip_example_fence: true })) {
+    let vs_run = 0;
+    for (const ch of text) {
+      const cp = ch.codePointAt(0);
+      if (_isVS(cp)) {
+        vs_run += 1;
+        continue;
+      }
+      const kind = _classify(cp);
+      if (kind) {
+        const name = _cpName(cp);
+        out.push(
+          new Finding(
+            sf.rel,
+            lineno,
+            CHECK,
+            "HIGH",
+            `${kind} U+${cp.toString(16).toUpperCase().padStart(4, "0")} (${name})`,
+            sf.weight
+          )
+        );
+      }
+    }
+    if (vs_run >= 3) {
+      out.push(
+        new Finding(
+          sf.rel,
+          lineno,
+          CHECK,
+          "HIGH",
+          `variation-selector run x${vs_run} (steganography signature)`,
+          sf.weight
+        )
+      );
+    }
+  }
+  return finish(out);
+}
+var _BINARY_EXT = /* @__PURE__ */ new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "ico",
+  "webp",
+  "avif",
+  "bmp",
+  "tiff",
+  "pdf",
+  "woff",
+  "woff2",
+  "ttf",
+  "otf",
+  "eot",
+  "zip",
+  "gz",
+  "tgz",
+  "bz2",
+  "xz",
+  "zst",
+  "7z",
+  "rar",
+  "wasm",
+  "mp3",
+  "mp4",
+  "wav",
+  "ogg",
+  "webm",
+  "mov",
+  "avi",
+  "so",
+  "dylib",
+  "dll",
+  "node",
+  "a",
+  "o",
+  "exe",
+  "jar",
+  "class",
+  "pyc",
+  "pyo",
+  "db",
+  "sqlite",
+  "sqlite3",
+  "bin",
+  "dat",
+  "docx",
+  "xlsx",
+  "pptx",
+  "doc",
+  "xls",
+  "ppt",
+  "odt",
+  "ods",
+  "odp"
+]);
+var _GENERATED_PREFIXES = [
+  "dist/",
+  ".augment/",
+  ".claude/",
+  ".cursor/",
+  ".clinerules/",
+  // Verbatim captured tool output, not authored text. These are RECORDINGS:
+  // escaping a control byte inside one would falsify the record it exists to
+  // preserve. If a capture needs to stay grep-readable, the fix is to escape
+  // at capture time — never to edit the artifact afterwards.
+  "agents/evidence/analysis/",
+  // The frozen hostile-encoding corpus. Its positives ARE raw control
+  // characters — that is the thing under test, so flagging them would demand
+  // escaping the fixtures and thereby delete the test. The corpus has its own,
+  // stronger integrity controls: a sha256 freeze plus a scope-guard test that
+  // is itself falsified by an out-of-scope fixture. Excluded here because it
+  // is DATA, on the same principle as the captures above.
+  "internal/bench/corpora/encoding-channels/"
+];
+function _isGenerated(rel) {
+  return _GENERATED_PREFIXES.some((p) => rel.startsWith(p));
+}
+function _isRawControlCodepoint(cp) {
+  if (cp === 9 || cp === 10 || cp === 13) return false;
+  return cp <= 31 || cp >= 127 && cp <= 159;
+}
+function _extensionOf(rel) {
+  const base = rel.slice(rel.lastIndexOf("/") + 1);
+  const dot = base.lastIndexOf(".");
+  return dot <= 0 ? "" : base.slice(dot + 1).toLowerCase();
+}
+function _trackedFiles() {
+  const res = spawnSync("git", ["ls-files", "-z"], {
+    cwd: ROOT,
+    maxBuffer: 64 * 1024 * 1024
+  });
+  if (res.status !== 0 || res.stdout === null) return null;
+  return res.stdout.toString("utf-8").split("\0").filter((p) => p !== "");
+}
+function _eligibleSourceFiles() {
+  const tracked = _trackedFiles();
+  if (tracked === null) return null;
+  return tracked.filter((rel) => !_isGenerated(rel) && !_BINARY_EXT.has(_extensionOf(rel)));
+}
+function _scanSourceControlBytes(files = null) {
+  const tracked = files ?? _eligibleSourceFiles();
+  if (tracked === null) return [];
+  const out = [];
+  for (const rel of tracked) {
+    if (_isGenerated(rel)) continue;
+    if (_BINARY_EXT.has(_extensionOf(rel))) continue;
+    let data;
+    try {
+      data = fs2.readFileSync(path2.join(ROOT, rel));
+    } catch {
+      continue;
+    }
+    try {
+      new TextDecoder("utf-8", { fatal: true }).decode(data);
+    } catch {
+      continue;
+    }
+    let line = 1;
+    for (const ch of data.toString("utf-8")) {
+      const cp = ch.codePointAt(0);
+      if (cp === void 0) continue;
+      if (cp === 10) {
+        line += 1;
+        continue;
+      }
+      if (!_isRawControlCodepoint(cp)) continue;
+      const hex = cp.toString(16).toUpperCase().padStart(2, "0");
+      out.push(
+        new Finding(
+          rel,
+          line,
+          CHECK,
+          "HIGH",
+          `raw control character U+${hex} in a text source \u2014 makes grep/file(1)/git treat this file as binary and skip it silently; use the language escape (e.g. \\0, \\x7F) instead`,
+          1
+        )
+      );
+    }
+  }
+  return out;
+}
+function _sanitize(filePath) {
+  const raw = fs2.readFileSync(filePath, "utf-8");
+  let cleaned = "";
+  for (const ch of raw) {
+    const cp = ch.codePointAt(0);
+    if (_classify(cp) === null && !_isVS(cp)) {
+      cleaned += ch;
+    }
+  }
+  cleaned = cleaned.normalize("NFKC");
+  const out = filePath + ".sanitized";
+  fs2.writeFileSync(out, cleaned, "utf-8");
+  return out;
+}
+function _argError(msg) {
+  process.stderr.write("usage: lint_hidden_unicode [-h] [--json] [--fix] [--root DIR]\n");
+  process.stderr.write(`lint_hidden_unicode: error: ${msg}
+`);
+  process.exit(2);
+}
+function parse_args(argv) {
+  const out = { json: false, fix: false };
+  const extra = [];
+  let rootPending = false;
+  for (const a of argv) {
+    if (rootPending) {
+      out.root = a;
+      rootPending = false;
+      continue;
+    }
+    if (a === "-h" || a === "--help") {
+      process.stdout.write("usage: lint_hidden_unicode [-h] [--json] [--fix] [--root DIR]\n");
+      process.exit(0);
+    } else if (a === "--json") {
+      out.json = true;
+    } else if (a === "--fix") {
+      out.fix = true;
+    } else if (a === "--root" || a.startsWith("--root=")) {
+      const eq = a.indexOf("=");
+      if (eq !== -1) {
+        out.root = a.slice(eq + 1);
+      } else {
+        rootPending = true;
+      }
+    } else {
+      extra.push(a);
+    }
+  }
+  if (extra.length > 0) {
+    _argError(`unrecognized arguments: ${extra.join(" ")}`);
+  }
+  return out;
+}
+function main(argv = null) {
+  const args = parse_args(argv ?? process.argv.slice(2));
+  const scanBase = args.root === void 0 ? ROOT : path2.resolve(args.root);
+  const findings = [];
+  const flagged = /* @__PURE__ */ new Set();
+  let corpusFiles = 0;
+  for (const sf of iter_corpus(DEFAULT_SCAN_ROOTS, [".md"], scanBase)) {
+    corpusFiles += 1;
+    const hits = _scan(sf);
+    for (const h of hits) {
+      findings.push(h);
+    }
+    if (hits.length > 0) {
+      flagged.add(sf.path);
+    }
+  }
+  try {
+    assertScanned({
+      gate: "lint_hidden_unicode",
+      scanned: corpusFiles,
+      units: "corpus file(s)",
+      roots: DEFAULT_SCAN_ROOTS
+    });
+  } catch (exc) {
+    if (exc instanceof DeadScopeError) {
+      process.stderr.write(`\u274C  ${exc.message}
+`);
+      return 1;
+    }
+    throw exc;
+  }
+  const sourceFiles = args.root === void 0 ? _eligibleSourceFiles() : [];
+  for (const h of _scanSourceControlBytes(sourceFiles)) {
+    findings.push(h);
+  }
+  if (!args.json) {
+    const n = sourceFiles === null ? 0 : sourceFiles.length;
+    process.stdout.write(
+      sourceFiles === null ? "  source pass: SKIPPED \u2014 `git ls-files` unavailable, 0 files read for raw control bytes\n" : `  source pass: ${n} tracked text file(s) read for raw C0 control bytes (generated trees + verbatim captures excluded)
+`
+    );
+  }
+  if (args.fix) {
+    for (const p of [...flagged].sort()) {
+      const sanitized = _sanitize(p);
+      const rel = path2.relative(path2.resolve(ROOT), path2.resolve(sanitized));
+      process.stdout.write(`  fixed \u2192 ${rel.split(path2.sep).join("/")}
+`);
+    }
+  }
+  if (args.json) {
+    report_child_scanned(corpusFiles + (sourceFiles === null ? 0 : sourceFiles.length));
+  }
+  if (args.json) {
+    const payload = py_json_dumps_indent2(findings.map((f) => f.toDict()));
+    process.stdout.write(payload + "\n");
+    return findings.some((f) => f.is_fail) ? 1 : 0;
+  }
+  return report(findings, { check_label: "hidden-unicode" });
+}
+function _isCliEntry() {
+  if (true) {
+    return false;
+  }
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL(path2.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs2.realpathSync(fileURLToPath2(import.meta.url));
+    const argv = fs2.realpathSync(path2.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry()) {
+  process.exitCode = main();
+}
+
+// src/scripts/_lib/confusables.ts
+var MIN_LETTERS = 3;
+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");
+var TOKEN_RE = /[\p{L}\p{M}\p{Nd}]+/gu;
+var CONFUSABLE_FOREIGN = /* @__PURE__ */ new Set([
+  // Cyrillic lowercase ↔ Latin
+  1072,
+  1077,
+  1086,
+  1088,
+  1089,
+  1091,
+  1093,
+  1109,
+  1110,
+  1112,
+  1211,
+  1281,
+  1307,
+  1399,
+  // Cyrillic uppercase ↔ Latin
+  1040,
+  1042,
+  1045,
+  1050,
+  1052,
+  1053,
+  1054,
+  1056,
+  1057,
+  1058,
+  1059,
+  1061,
+  1029,
+  1030,
+  1032,
+  // Greek lowercase ↔ Latin
+  945,
+  949,
+  959,
+  957,
+  961,
+  965,
+  967,
+  954,
+  // Greek uppercase ↔ Latin (only those with a real Latin twin)
+  913,
+  914,
+  917,
+  918,
+  919,
+  921,
+  922,
+  924,
+  925,
+  927,
+  929,
+  932,
+  933,
+  935,
+  914
+]);
+function _script_of(ch) {
+  if (_LATIN.test(ch)) return "latin";
+  if (_CYRILLIC.test(ch)) return "cyrillic";
+  if (_GREEK.test(ch)) return "greek";
+  return "other";
+}
+function classifyToken(token) {
+  let latin = 0;
+  let cyrillic = 0;
+  let greek = 0;
+  let letters = 0;
+  for (const ch of token) {
+    if (!_LETTER.test(ch)) continue;
+    letters += 1;
+    const script = _script_of(ch);
+    if (script === "latin") {
+      latin += 1;
+    } else if (script === "cyrillic" || script === "greek") {
+      if (CONFUSABLE_FOREIGN.has(ch.codePointAt(0))) {
+        if (script === "cyrillic") cyrillic += 1;
+        else greek += 1;
+      }
+    }
+  }
+  if (letters < MIN_LETTERS) return null;
+  const foreign = cyrillic + greek;
+  if (latin === 0 || foreign === 0) return null;
+  if (latin <= foreign) return null;
+  const which = cyrillic > 0 && greek > 0 ? "cyrillic+greek" : cyrillic > 0 ? "cyrillic" : "greek";
+  return `latin+${which} (${latin} latin / ${foreign} foreign-confusable)`;
+}
+
+export {
+  ROOT,
+  DEFAULT_SCAN_ROOTS,
+  Finding,
+  scan_file,
+  iter_corpus,
+  legacy_pragma_finding,
+  report_child_scanned,
+  report,
+  py_json_dumps_indent2,
+  _classify,
+  _scan,
+  TOKEN_RE,
+  classifyToken
+};