@inerrata-corporation/errata 2.0.6-dev.2330 → 2.0.6-dev.2494

package/consolidate-worker.mjs

@@ -378,6 +378,9 @@ import { createHash } from "node:crypto";
 function sha256(input) {
   return createHash("sha256").update(input).digest("hex");
 }
+function sha256Short(input, n = 8) {
+  return sha256(input).slice(0, n);
+}
 function canonicalJSON(value) {
   if (value === null || typeof value !== "object") {
     return JSON.stringify(value);
@@ -813,6 +816,12 @@ function identityId(input) {
       );
   }
 }
+function genericCanonicalId(prefix, content) {
+  return `${prefix}_${digest(content)}`.slice(0, 56);
+}
+function languageCanonicalId(name) {
+  return genericCanonicalId("Language", { name: name.trim().toLowerCase() });
+}
 var DESIGN_PROBLEM_PREFIX, DESIGN_PROBLEM_ID_LENGTH, DIAGNOSTIC_PROBLEM_PREFIX, DIAGNOSTIC_HASH_LENGTH, TRIAGE_PREFIX, TRIAGE_ID_LENGTH;
 var init_identity = __esm({
   "../../packages/shared/src/identity.ts"() {
@@ -15250,7 +15259,49 @@ var init_edge_rules = __esm({
 });
 
 // ../../packages/shared/src/symbol-intent.ts
-var SYMBOL_SUMMARY_KINDS, MAX_SYMBOL_SUMMARY_CHARS, MAX_SIDECAR_SYMBOLS;
+function extractIdentifierTokens(text) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const m of text.matchAll(TOKEN_RE2)) {
+    if (!seen.has(m[0])) {
+      seen.add(m[0]);
+      out.push(m[0]);
+    }
+  }
+  return out;
+}
+function sidecarDropBucket(reason) {
+  if (reason === null) return null;
+  if (reason === "empty summary") return "empty";
+  if (reason === "summary too long") return "too_long";
+  if (reason === "contains a path shape") return "path_shape";
+  if (reason === "contains a quoted literal") return "quoted_literal";
+  if (reason.startsWith("contains verbatim identifier")) return "verbatim_identifier";
+  return "other";
+}
+function summaryRejectionReason(summary, isKnownToken) {
+  if (!summary.trim()) return "empty summary";
+  if (summary.length > MAX_SYMBOL_SUMMARY_CHARS) return "summary too long";
+  if (PATH_SHAPE_RE.test(summary)) return "contains a path shape";
+  if (QUOTED_LITERAL_RE.test(summary.replace(CONTRACTION_RE, "$1$2")))
+    return "contains a quoted literal";
+  for (const tok of extractIdentifierTokens(summary)) {
+    if (isKnownToken(tok)) return `contains verbatim identifier '${tok}'`;
+    if (tok.includes(".")) {
+      const segs = tok.split(".");
+      for (let i = 0; i < segs.length; i++) {
+        let span = "";
+        for (let j = i; j < segs.length; j++) {
+          span = span ? `${span}.${segs[j]}` : segs[j];
+          if (span !== tok && span && isKnownToken(span))
+            return `contains verbatim identifier '${span}'`;
+        }
+      }
+    }
+  }
+  return null;
+}
+var SYMBOL_SUMMARY_KINDS, MAX_SYMBOL_SUMMARY_CHARS, MAX_SIDECAR_SYMBOLS, TOKEN_RE2, PATH_SHAPE_RE, CONTRACTION_RE, QUOTED_LITERAL_RE;
 var init_symbol_intent = __esm({
   "../../packages/shared/src/symbol-intent.ts"() {
     "use strict";
@@ -15263,10 +15314,23 @@ var init_symbol_intent = __esm({
     ];
     MAX_SYMBOL_SUMMARY_CHARS = 300;
     MAX_SIDECAR_SYMBOLS = 200;
+    TOKEN_RE2 = /[A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*/g;
+    PATH_SHAPE_RE = /[\w.~-]+[/\\][\w.$~-]+/;
+    CONTRACTION_RE = /([A-Za-z])'([A-Za-z])/g;
+    QUOTED_LITERAL_RE = /"[^"]+"|'[^']+'|`[^`]+`/;
   }
 });
 
 // ../../packages/shared/src/wire.ts
+function anchorVersionAttrs(attrs) {
+  if (!attrs) return {};
+  const commit = attrs["observedAtCommit"];
+  const hash2 = attrs["symbolContentHash"];
+  return {
+    ...typeof commit === "string" && ANCHOR_COMMIT_SHA_RE.test(commit) ? { observedAtCommit: commit } : {},
+    ...typeof hash2 === "string" && ANCHOR_BODY_HASH_RE.test(hash2) ? { symbolContentHash: hash2 } : {}
+  };
+}
 var CLOUD_NODE_LABELS, CLOUD_WRITABLE_NODE_LABELS, PROJECT_ONLY_NODE_LABELS, PROJECT_ONLY_NODE_LABEL_SET, PROJECT_ONLY_EDGE_TYPES, PROJECT_ONLY_EDGE_TYPE_SET, CLOUD_WRITABLE_NODE_LABEL_SET, CLOUD_EDGE_TYPES, INGEST_SOURCES, INGEST_EXTRACTION_SOURCES, CastaliaIngestNodeSchema, RouteContextCountWireSchema, ANCHOR_COMMIT_SHA_RE, ANCHOR_BODY_HASH_RE, CastaliaIngestEdgeSchema, SymbolSummarySidecarSchema, CastaliaIngestPayloadSchema;
 var init_wire = __esm({
   "../../packages/shared/src/wire.ts"() {
@@ -15355,7 +15419,7 @@ var init_wire = __esm({
       /** Org-membrane (M2): the daemon's anchor tag — it owns the lockfile, so it
        *  knows which packages are private. The door does NOT trust a `public` claim
        *  blindly (it re-confirms on the spine); absent ⇒ unknown ⇒ fail-closed to
-       *  org-private. Accepted-but-ignored until ORG_MEMBRANE_ENABLED flips. */
+       *  org-private. Ignored only where ORG_MEMBRANE_ENABLED=false (default ON). */
       anchorVisibility: external_exports.enum(["public", "private"]).optional(),
       /** The spine-resolvable anchor id backing a `public` tag (OM-anchor-tag): a
        *  Package purl or `languageCanonicalId`. The door validates THIS on the
@@ -15440,6 +15504,17 @@ var init_repo_locator = __esm({
 });
 
 // ../../packages/shared/src/project-symbol.ts
+import { createHmac } from "node:crypto";
+function normalizeSymbolPath(relPath) {
+  return relPath.replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^\.\//, "").replace(/^\//, "");
+}
+function projectSymbolId(projectSalt, projectId, relPath, qname, kind) {
+  const path = normalizeSymbolPath(relPath);
+  return `sym_${createHmac("sha256", projectSalt).update(`${projectId}:${path}:${qname}:${kind}`).digest("hex").slice(0, 24)}`;
+}
+function isMembraneSaltedId(id) {
+  return typeof id === "string" && /^(orgn_|teamn_|projn_)/.test(id);
+}
 var init_project_symbol = __esm({
   "../../packages/shared/src/project-symbol.ts"() {
     "use strict";
@@ -16894,6 +16969,7 @@ init_src();
 
 // ../../packages/local-graph/src/design-problem.ts
 var RECURRENCE_DEBOUNCE_MS = 60 * 60 * 1e3;
+var AUTO_MINT_PREFIX = "addressed by an edit to ";
 
 // ../../packages/local-graph/src/intent.ts
 init_src();
@@ -17002,6 +17078,9 @@ function percolate(l1, l2, opts) {
 init_src();
 init_src2();
 
+// ../../packages/math/src/constants.ts
+var NEMORI_DEDUP_COSINE = 0.88;
+
 // ../../packages/math/src/triage.ts
 var TRIAGE_GLOBAL_BUCKET = "*";
 function triageContextBuckets(ctx) {
@@ -17661,6 +17740,1593 @@ function findStrandedSymbols(store) {
   return stranded;
 }
 
+// src/package-index.ts
+init_src();
+function buildContextIngest(store, profile, daemonVersion, ignorePatterns = [], opts = {}) {
+  const labels = opts.includePackages === false ? ["Language"] : ["Package", "Language"];
+  const ignored = (s) => ignorePatterns.length > 0 && ignorePatterns.some((p) => s.toLowerCase().includes(p));
+  const nodes = [];
+  const seen = /* @__PURE__ */ new Set();
+  const localIdByWireId = {};
+  for (const label of labels) {
+    for (const n of store.findNodesByLabel(label)) {
+      if (n.attrs["source"] === "cloud") continue;
+      if (ignored(n.description) || ignored(String(n.attrs["name"] ?? ""))) continue;
+      if (typeof n.attrs["contributedAtSeq"] === "number") continue;
+      nodes.push({
+        ...n,
+        // Language wire id = the shared `languageCanonicalId` (warming-spine
+        // parity, EE-cloud-anchors) — the local `lang:<name>` id is internal.
+        // Package ids are already the purl (= the cross-stratum canonicalId).
+        id: label === "Language" ? languageCanonicalId(String(n.attrs["name"] ?? "").trim() || n.description) : n.id,
+        embedding: [],
+        // No `version` attr on the wire: the purl already encodes the resolved
+        // version, and the door's temporal guard rejects ANY `attrs.version` as
+        // bi-temporal bookkeeping (ingest-temporal-guard.ts) — shipping it 422s
+        // the whole batch. `resolved` still travels (range-vs-lockfile signal).
+        attrs: label === "Package" ? {
+          purl: n.attrs["purl"],
+          name: n.attrs["name"],
+          ecosystem: n.attrs["ecosystem"],
+          resolved: n.attrs["resolved"]
+        } : { name: n.attrs["name"] },
+        // OM-anchor-tag: context stubs are self-anchored — the wire id IS the
+        // spine key (purl / languageCanonicalId). The door re-confirms on the
+        // public spine; a private-registry or workspace package never confirms
+        // and fails closed to org, exactly as an untagged one would.
+        anchorVisibility: "public"
+      });
+      seen.add(n.id);
+      localIdByWireId[nodes[nodes.length - 1].id] = n.id;
+    }
+  }
+  if (nodes.length === 0) return null;
+  const edges = [];
+  for (const id of seen) {
+    for (const e of store.outEdges(id, ["DEPENDS_ON"])) {
+      if (seen.has(e.to)) edges.push({ ...e, attrs: {} });
+    }
+  }
+  const base = {
+    daemonVersion,
+    // Origin key (= project, the salted `wp_…`) — the door stamps it onto created
+    // nodes as `authoringProject`, arming the evidence channels' cross-origin gate
+    // (EE-corrob-live: without it every node is fail-open to self-corroboration).
+    ...profile.id ? { originProject: profile.id } : {},
+    profile: { stack: profile.stack, languages: profile.languages, domains: profile.domains },
+    nodes,
+    edges
+  };
+  return { ...base, payloadDigest: digest(base), localIds: [...seen], localIdByWireId };
+}
+
+// src/instance-ingest.ts
+init_src();
+init_src2();
+
+// ../../packages/privacy-edge/src/ontology.ts
+var DEFAULT_ONTOLOGY = {
+  email: { l1: "an email address", l2: "an email address" },
+  ip: { l1: "an IP address", l2: "an IP address" },
+  path: { l1: "a path", l2: "a path" },
+  file: { l1: "a file", l2: "a path" },
+  credential: "neutralize",
+  uuid: { l1: "an identifier", l2: "an identifier" },
+  hash: { l1: "a hash", l2: "a value" },
+  date: { l1: "a date", l2: "a date" },
+  // real values come from date-shapes
+  person: { l1: "a contributor", l2: "someone" },
+  org: { l1: "a company", l2: "an organization" }
+};
+function generalizePhrase(cls, level) {
+  const rule = DEFAULT_ONTOLOGY[cls];
+  if (rule === "neutralize") return "[redacted:credential]";
+  return level === 1 ? rule.l1 : rule.l2;
+}
+
+// ../../packages/privacy-edge/src/date-shapes.ts
+function seasonFor(month) {
+  if (month <= 4) return "early";
+  if (month <= 8) return "mid";
+  return "late";
+}
+var MONTHS = {
+  jan: 1,
+  feb: 2,
+  mar: 3,
+  apr: 4,
+  may: 5,
+  jun: 6,
+  jul: 7,
+  aug: 8,
+  sep: 9,
+  oct: 10,
+  nov: 11,
+  dec: 12
+};
+function generalizeDates(text, level) {
+  const yearOnly = level === 2;
+  let out = text;
+  out = out.replace(
+    /\b(\d{4})-(\d{2})-(\d{2})\b/g,
+    (_m, y, mo) => yearOnly ? y : `${seasonFor(Number(mo))} ${y}`
+  );
+  out = out.replace(/\b(\d{1,2})\/(\d{1,2})\/(\d{4})\b/g, (_m, mo, _d, y) => {
+    const m = Number(mo);
+    if (yearOnly || m < 1 || m > 12) return y;
+    return `${seasonFor(m)} ${y}`;
+  });
+  out = out.replace(
+    /\b(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*\.?\s+(\d{4})\b/gi,
+    (_m, mon, y) => {
+      const monNum = MONTHS[mon.slice(0, 3).toLowerCase()];
+      return yearOnly || !monNum ? y : `${seasonFor(monNum)} ${y}`;
+    }
+  );
+  return out;
+}
+
+// ../../packages/canonical/src/scrub.ts
+init_src();
+var API_KEY_PATTERNS = [
+  { name: "sk-ant-key", re: /\bsk-ant-[a-zA-Z0-9_\-]{30,}\b/g },
+  { name: "openai-key", re: /\bsk-[a-zA-Z0-9_\-]{30,}\b/g },
+  { name: "github-pat", re: /\bgh[psour]_[A-Za-z0-9]{36,}\b/g },
+  { name: "aws-key", re: /\bAKIA[0-9A-Z]{16}\b/g },
+  { name: "google-key", re: /\bAIza[0-9A-Za-z\-_]{35}\b/g },
+  { name: "stripe-key", re: /\b(sk|pk)_(test|live)_[0-9a-zA-Z]{24,}\b/g },
+  { name: "bearer", re: /\bBearer\s+[A-Za-z0-9_\-\.]{16,}\b/gi }
+];
+var EMAIL_RE = /\b[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}\b/g;
+var IPV4_RE = /\b(?:\d{1,3}\.){3}\d{1,3}\b/g;
+var IPV6_RE = /\b(?:[A-Fa-f0-9]{1,4}:){2,7}[A-Fa-f0-9:]{1,4}\b/g;
+var WIN_PATH_RE = /\b[A-Za-z]:[\\/](?![\\/])(?:[^\\/\s"']+[\\/])*[^\\/\s"']*/g;
+var WIN_UNC_RE = /\\\\[A-Za-z0-9_\-]+\\[A-Za-z0-9_\-$]+(?:\\[^\\\s"']+)*/g;
+var POSIX_USER_PATH_RE = /\/(?:Users|home)\/[A-Za-z0-9_\-\.]+(?:\/[^"'\s)]+)*/g;
+var LONG_HASH_RE = /\b[a-fA-F0-9]{24,}\b/g;
+var UUID_RE = /\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\b/g;
+function scrub(input) {
+  let text = input;
+  const found = [];
+  const bump = (kind, replaced) => {
+    const ex = found.find((f) => f.kind === kind && f.replaced === replaced);
+    if (ex) ex.count++;
+    else found.push({ kind, replaced, count: 1 });
+  };
+  for (const p of API_KEY_PATTERNS) {
+    text = text.replace(p.re, (m) => {
+      const id = sha256Short(m, 6);
+      bump("api-key", `<api-key:${id}>`);
+      return `<api-key:${id}>`;
+    });
+  }
+  text = text.replace(EMAIL_RE, (m) => {
+    const id = sha256Short(m, 6);
+    bump("email", `<email:${id}>`);
+    return `<email:${id}>`;
+  });
+  text = text.replace(WIN_UNC_RE, (m) => {
+    const id = sha256Short(m, 6);
+    bump("windows-path", `<unc:${id}>`);
+    return `<unc:${id}>`;
+  });
+  text = text.replace(WIN_PATH_RE, (m) => {
+    const file2 = m.split(/[\\/]/).pop() ?? "";
+    const id = sha256Short(m, 6);
+    const repl = file2 && file2.includes(".") ? `<path:${id}>/${file2}` : `<path:${id}>`;
+    bump("absolute-path", repl);
+    return repl;
+  });
+  text = text.replace(POSIX_USER_PATH_RE, (m) => {
+    const file2 = m.split("/").pop() ?? "";
+    const id = sha256Short(m, 6);
+    const repl = file2 && file2.includes(".") ? `<path:${id}>/${file2}` : `<path:${id}>`;
+    bump("home-dir", repl);
+    return repl;
+  });
+  text = text.replace(IPV4_RE, (m) => {
+    bump("ipv4", "<ipv4>");
+    return "<ipv4>";
+  });
+  text = text.replace(IPV6_RE, (m) => {
+    bump("ipv6", "<ipv6>");
+    return "<ipv6>";
+  });
+  text = text.replace(UUID_RE, (m) => {
+    bump("uuid", "<uuid>");
+    return "<uuid>";
+  });
+  text = text.replace(LONG_HASH_RE, (m) => {
+    bump("long-hash", "<hash>");
+    return "<hash>";
+  });
+  return { text, report: { found } };
+}
+
+// ../../packages/privacy-edge/src/self-reference.ts
+var L = "(?<![A-Za-z0-9])";
+var R = "(?![A-Za-z0-9])";
+var esc2 = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function locatorTerms(loc, full, part) {
+  if (!loc) return;
+  full.add(loc);
+  const segs = loc.split("/").filter(Boolean);
+  if (segs.length >= 2) {
+    part.add(segs[segs.length - 1]);
+    part.add(segs[segs.length - 2]);
+  }
+}
+function scrubSelfReferences(text, project) {
+  let out = text;
+  out = out.replace(
+    /\b(MRs?|PRs?|merge requests?|pull requests?|issues?|tickets?)\s+#?[0-9]+\b/gi,
+    (_m, kind) => {
+      const k = kind.toLowerCase();
+      if (k.startsWith("p")) return "a pull request";
+      if (k.startsWith("i")) return "an issue";
+      if (k.startsWith("t")) return "a ticket";
+      return "a merge request";
+    }
+  ).replace(new RegExp(`${L}![0-9]{1,6}(?![0-9])`, "g"), "a merge request").replace(new RegExp(`(?<![A-Za-z0-9#])#[0-9]{2,6}(?![0-9])`, "g"), "an issue");
+  const full = /* @__PURE__ */ new Set();
+  const part = /* @__PURE__ */ new Set();
+  locatorTerms(project.repoLocator, full, part);
+  for (const a of project.aliases ?? []) locatorTerms(a, full, part);
+  if (project.name) part.add(project.name);
+  for (const a of project.aka ?? []) part.add(a);
+  const ordered = [
+    ...[...full].map((t) => ({ t, repl: "the repository" })),
+    ...[...part].map((t) => ({ t, repl: "the project" }))
+  ].filter((x) => x.t && x.t.length >= 2).sort((a, b) => b.t.length - a.t.length);
+  for (const { t, repl } of ordered) {
+    out = out.replace(new RegExp(`${L}${esc2(t)}${R}`, "gi"), repl);
+  }
+  out = out.replace(/\b(the|a|an|its|our|this)\s+the\s+(project|repository)\b/gi, "the $2");
+  return out;
+}
+
+// ../../packages/privacy-edge/src/generalize.ts
+var TOKEN_RULES = [
+  { re: /<api-key:[0-9a-f]+>/gi, cls: "credential" },
+  { re: /<email:[0-9a-f]+>/gi, cls: "email" },
+  { re: /<unc:[0-9a-f]+>/gi, cls: "path" },
+  { re: /<path:[0-9a-f]+>\/[^\s)"']+/gi, cls: "file" },
+  // path + preserved filename
+  { re: /<path:[0-9a-f]+>/gi, cls: "path" },
+  { re: /<ipv4>|<ipv6>/gi, cls: "ip" },
+  { re: /<uuid>/gi, cls: "uuid" },
+  { re: /<hash>/gi, cls: "hash" }
+];
+function generalize(text, opts = {}) {
+  const level = opts.level ?? 1;
+  const seen = /* @__PURE__ */ new Set();
+  let out = generalizeDates(text, level);
+  out = scrub(out).text;
+  for (const { re, cls } of TOKEN_RULES) {
+    out = out.replace(re, () => {
+      seen.add(cls);
+      return generalizePhrase(cls, level);
+    });
+  }
+  if (opts.project) out = scrubSelfReferences(out, opts.project);
+  return { text: out, report: { level, classes: [...seen] } };
+}
+
+// src/instance-ingest.ts
+init_src();
+
+// src/contribution-ready.ts
+function cosine2(a, b) {
+  if (a.length === 0 || a.length !== b.length) return 0;
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  return na === 0 || nb === 0 ? 0 : dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+function noveltyAgainst(node, neighbors, opts = {}) {
+  const floor = opts.dedupCosine ?? NEMORI_DEDUP_COSINE;
+  const emb = node.embedding ?? [];
+  if (emb.length === 0) {
+    return { ready: true, surprise: 1, topCosine: 0, reason: "no-embedding (fidelity-first)" };
+  }
+  let topCosine = 0;
+  for (const other of neighbors) {
+    if (other.id === node.id) continue;
+    const oe = other.embedding ?? [];
+    if (oe.length !== emb.length) continue;
+    const c = cosine2(emb, oe);
+    if (c > topCosine) topCosine = c;
+  }
+  const ready = topCosine < floor;
+  return {
+    ready,
+    surprise: 1 - topCosine,
+    topCosine,
+    reason: ready ? "novel (not a near-duplicate)" : "near-duplicate of a reference node"
+  };
+}
+
+// src/profile.ts
+import { createHash as createHash2 } from "node:crypto";
+init_src2();
+
+// ../../node_modules/.pnpm/env-paths@3.0.0/node_modules/env-paths/index.js
+import os from "node:os";
+import process3 from "node:process";
+var homedir = os.homedir();
+var tmpdir = os.tmpdir();
+var { env } = process3;
+
+// src/git-remote.ts
+init_src();
+
+// src/profile.ts
+function sessionOriginKey(sessionId) {
+  if (!sessionId) return void 0;
+  return "ws_" + createHash2("sha256").update(sessionId).digest("hex").slice(0, 12);
+}
+
+// src/public-symbols.ts
+import { readFileSync, readdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+var HEAD_BYTES = 8 * 1024;
+var INDEX_TTL_MS = 10 * 60 * 1e3;
+var MIN_SYMBOL_LEN = 4;
+function isNameShapedSymbol(name) {
+  return /[A-Z0-9_$]/.test(name);
+}
+var NAMED_IMPORT_RE = /import\s+(?:type\s+)?(.+?)\s+from\s+['"]([^'"]+)['"]/g;
+var REQUIRE_RE = /(?:const|let|var)\s+(.+?)\s*=\s*require\(\s*['"]([^'"]+)['"]\s*\)/g;
+function isBareExternal(spec, internalNames) {
+  if (spec.startsWith(".") || spec.startsWith("/") || spec.startsWith("node:")) return false;
+  const pkg = spec.startsWith("@") ? spec.split("/").slice(0, 2).join("/") : spec.split("/")[0];
+  return !internalNames.has(pkg);
+}
+function bindingNames(clause) {
+  const names = [];
+  const braced = /\{([^}]*)\}/.exec(clause);
+  if (braced) {
+    for (const part of braced[1].split(",")) {
+      const local = part.split(/\s+as\s+/).pop()?.trim();
+      if (local && /^[A-Za-z_$][\w$]*$/.test(local)) names.push(local);
+    }
+  }
+  const ns = /\*\s+as\s+([A-Za-z_$][\w$]*)/.exec(clause);
+  if (ns) names.push(ns[1]);
+  const head = clause.replace(/\{[^}]*\}/, "").replace(/\*\s+as\s+[A-Za-z_$][\w$]*/, "");
+  const def = /(?:^|,)\s*([A-Za-z_$][\w$]*)\s*(?:,|$)/.exec(head.trim());
+  if (def) names.push(def[1]);
+  return names;
+}
+function internalPackageNames(workspaceRoot) {
+  const names = /* @__PURE__ */ new Set();
+  const tryRead = (dir) => {
+    const pj = join(dir, "package.json");
+    if (!existsSync(pj)) return;
+    try {
+      const name = JSON.parse(readFileSync(pj, "utf8")).name;
+      if (typeof name === "string" && name.length > 0) names.add(name);
+    } catch {
+    }
+  };
+  tryRead(workspaceRoot);
+  for (const group of ["packages", "apps"]) {
+    const groupDir = join(workspaceRoot, group);
+    if (!existsSync(groupDir)) continue;
+    try {
+      for (const entry of readdirSync(groupDir)) tryRead(join(groupDir, entry));
+    } catch {
+    }
+  }
+  return names;
+}
+var cache = /* @__PURE__ */ new Map();
+function publicSymbolIndex(store, workspaceRoot, deps = {}) {
+  const now = deps.nowMs ?? Date.now();
+  const cached2 = cache.get(workspaceRoot);
+  if (cached2 && now - cached2.builtAt < INDEX_TTL_MS) return cached2;
+  const readHead = deps.readHead ?? ((absPath) => {
+    try {
+      return readFileSync(absPath, "utf8").slice(0, HEAD_BYTES);
+    } catch {
+      return "";
+    }
+  });
+  const internal = internalPackageNames(workspaceRoot);
+  const bareModules = /* @__PURE__ */ new Set();
+  for (const mod of store.findNodesByLabel("Module")) {
+    if (isBareExternal(mod.description, internal)) bareModules.add(mod.id);
+  }
+  const files = /* @__PURE__ */ new Set();
+  for (const modId of bareModules) {
+    for (const e of store.inEdges(modId, ["IMPORTS"])) {
+      const f = store.getNode(e.from);
+      const rel = f?.attrs["relPath"];
+      if (f && f.validTo == null && typeof rel === "string") files.add(rel);
+    }
+  }
+  const symbols = /* @__PURE__ */ new Set();
+  for (const rel of files) {
+    const head = readHead(join(workspaceRoot, rel));
+    if (!head) continue;
+    for (const re of [NAMED_IMPORT_RE, REQUIRE_RE]) {
+      re.lastIndex = 0;
+      for (const m of head.matchAll(re)) {
+        if (!isBareExternal(m[2], internal)) continue;
+        for (const name of bindingNames(m[1])) {
+          if (name.length >= MIN_SYMBOL_LEN && isNameShapedSymbol(name)) symbols.add(name);
+        }
+      }
+    }
+  }
+  const index = { symbols, builtAt: now };
+  cache.set(workspaceRoot, index);
+  return index;
+}
+var PRESERVED_SYMBOLS_CAP = 8;
+function preservedSymbolsFor(description, index) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const m of description.matchAll(/[A-Za-z_$][\w$]{3,}/g)) {
+    const tok = m[0];
+    if (seen.has(tok) || !index.symbols.has(tok)) continue;
+    seen.add(tok);
+    out.push(tok);
+    if (out.length >= PRESERVED_SYMBOLS_CAP) break;
+  }
+  return out;
+}
+function internalSymbolsFor(description, lexiconHas, publicIndex) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const m of description.matchAll(/[A-Za-z_$][\w$]{2,}(?:\.[A-Za-z_$][\w$]+)*/g)) {
+    const tok = m[0];
+    if (seen.has(tok)) continue;
+    seen.add(tok);
+    if (!lexiconHas(tok)) continue;
+    if (publicIndex?.symbols.has(tok)) continue;
+    out.push(tok);
+    if (out.length >= PRESERVED_SYMBOLS_CAP) break;
+  }
+  return out;
+}
+
+// src/generalize-graph.ts
+init_src();
+
+// src/derive-summary.ts
+var NAME_DERIVED_ENABLED = true;
+var KIND_ARTICLE = {
+  function: "a",
+  method: "a",
+  class: "a",
+  interface: "an",
+  constant: "a"
+};
+var lead = (kind) => `${KIND_ARTICLE[kind]} ${kind}`;
+var MAX_PAYLOAD_CHARS = 56;
+var DANGLING = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "but",
+  "of",
+  "to",
+  "in",
+  "on",
+  "at",
+  "by",
+  "for",
+  "from",
+  "with",
+  "into",
+  "onto",
+  "over",
+  "under",
+  "as",
+  "that",
+  "which",
+  "when",
+  "while",
+  "if",
+  "so",
+  "then",
+  "than",
+  "its",
+  "their",
+  "this",
+  "these",
+  "those",
+  "is",
+  "are",
+  "was",
+  "be",
+  "been",
+  "not",
+  "no",
+  "per",
+  "via",
+  "up",
+  "out",
+  "off",
+  "about",
+  "after",
+  "before",
+  "during",
+  "without",
+  "within",
+  "against",
+  "between",
+  "through",
+  "across",
+  "upon"
+]);
+var VERBS = /* @__PURE__ */ new Set([
+  "accept",
+  "add",
+  "advance",
+  "allow",
+  "apply",
+  "assert",
+  "attach",
+  "bind",
+  "build",
+  "bump",
+  "cache",
+  "call",
+  "cap",
+  "carry",
+  "check",
+  "choose",
+  "clamp",
+  "classify",
+  "clean",
+  "clear",
+  "close",
+  "collapse",
+  "collect",
+  "compare",
+  "compute",
+  "connect",
+  "contain",
+  "convert",
+  "count",
+  "cover",
+  "create",
+  "decide",
+  "declare",
+  "decode",
+  "define",
+  "delete",
+  "demote",
+  "derive",
+  "describe",
+  "detach",
+  "detect",
+  "determine",
+  "disable",
+  "drain",
+  "drop",
+  "emit",
+  "enable",
+  "encode",
+  "ensure",
+  "enqueue",
+  "evaluate",
+  "expand",
+  "expose",
+  "extend",
+  "extract",
+  "fetch",
+  "fill",
+  "filter",
+  "find",
+  "fire",
+  "fix",
+  "flag",
+  "flatten",
+  "flip",
+  "flush",
+  "fold",
+  "format",
+  "gate",
+  "gather",
+  "generate",
+  "get",
+  "give",
+  "grant",
+  "guard",
+  "handle",
+  "hash",
+  "hide",
+  "hold",
+  "hook",
+  "index",
+  "infer",
+  "initialize",
+  "insert",
+  "inspect",
+  "join",
+  "keep",
+  "limit",
+  "link",
+  "list",
+  "load",
+  "locate",
+  "log",
+  "make",
+  "map",
+  "mark",
+  "match",
+  "materialize",
+  "measure",
+  "merge",
+  "mint",
+  "mount",
+  "move",
+  "name",
+  "normalize",
+  "note",
+  "observe",
+  "open",
+  "package",
+  "parse",
+  "persist",
+  "pick",
+  "pop",
+  "populate",
+  "prepare",
+  "produce",
+  "promote",
+  "prune",
+  "publish",
+  "pull",
+  "push",
+  "query",
+  "queue",
+  "raise",
+  "rank",
+  "read",
+  "rebuild",
+  "record",
+  "recover",
+  "redact",
+  "reduce",
+  "refresh",
+  "register",
+  "reject",
+  "release",
+  "remove",
+  "rename",
+  "render",
+  "repair",
+  "replace",
+  "replay",
+  "report",
+  "represent",
+  "require",
+  "reset",
+  "resolve",
+  "restore",
+  "retire",
+  "retry",
+  "return",
+  "reveal",
+  "revive",
+  "rewrite",
+  "route",
+  "run",
+  "sanitize",
+  "save",
+  "scan",
+  "schedule",
+  "score",
+  "scrub",
+  "seed",
+  "select",
+  "send",
+  "serialize",
+  "serve",
+  "set",
+  "show",
+  "sign",
+  "skip",
+  "sort",
+  "split",
+  "stamp",
+  "start",
+  "stop",
+  "store",
+  "strip",
+  "summarize",
+  "supply",
+  "suppress",
+  "sweep",
+  "switch",
+  "sync",
+  "tag",
+  "take",
+  "test",
+  "throw",
+  "toggle",
+  "touch",
+  "trace",
+  "track",
+  "transform",
+  "translate",
+  "traverse",
+  "trigger",
+  "trim",
+  "turn",
+  "unwrap",
+  "update",
+  "upsert",
+  "validate",
+  "verify",
+  "walk",
+  "warn",
+  "watch",
+  "wire",
+  "wrap",
+  "write",
+  "yield"
+]);
+function inflect(verb) {
+  if (/(?:s|x|ch|sh|z)$/.test(verb)) return `${verb}es`;
+  if (/[^aeiou]y$/.test(verb)) return `${verb.slice(0, -1)}ies`;
+  return `${verb}s`;
+}
+function deinflect(word) {
+  if (word.endsWith("ies") && VERBS.has(`${word.slice(0, -3)}y`)) return `${word.slice(0, -3)}y`;
+  if (word.endsWith("es") && VERBS.has(word.slice(0, -2))) return word.slice(0, -2);
+  if (word.endsWith("s") && VERBS.has(word.slice(0, -1))) return word.slice(0, -1);
+  return null;
+}
+function verbHead(word) {
+  const w = word.toLowerCase().replace(/[^a-z]/g, "");
+  if (!w) return null;
+  if (VERBS.has(w)) return inflect(w);
+  return deinflect(w) !== null ? w : null;
+}
+var tidy = (s) => s.replace(/\s+/g, " ").replace(/\s+([,.;:])/g, "$1").replace(/[\s,;:.]+$/, "").trim();
+function identifierWords(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/[_$]+/g, " ").toLowerCase().split(/\s+/).filter(Boolean);
+}
+function clipClause(text) {
+  let t = tidy(text.split(/\s+[—–-]\s+|[:;(]|,|\s+(?:and|or|plus)\s+|\s\+\s/)[0] ?? "");
+  if (t.length > MAX_PAYLOAD_CHARS) {
+    const cut = t.slice(0, MAX_PAYLOAD_CHARS).lastIndexOf(" ");
+    if (cut <= 20) return null;
+    t = tidy(t.slice(0, cut));
+  }
+  const words = t.split(/\s+/);
+  while (words.length > 0 && DANGLING.has(words[words.length - 1].toLowerCase().replace(/[^a-z]/g, ""))) {
+    words.pop();
+  }
+  const out = tidy(words.join(" "));
+  return out.length >= 12 && out.split(/\s+/).length >= 2 ? out : null;
+}
+function firstSentence(doc) {
+  const clean = doc.replace(/^[\s*/]+/gm, " ").replace(/\s+/g, " ").trim();
+  const m = clean.match(/^(.{10,400}?[.!?])(\s|$)/);
+  return (m ? m[1] : clean).slice(0, 280);
+}
+function stripUnshippable(sentence) {
+  return sentence.replace(/`[^`]*`|"[^"]*"|'[^']{2,}'/g, " ").replace(/[\w.~-]+[/\\][\w.$~-]+/g, " ").replace(/\([^)]*\)/g, " ");
+}
+function summaryFromDoc(doc, kind) {
+  const clipped = clipClause(stripUnshippable(firstSentence(doc)).replace(/^[^A-Za-z]+/, ""));
+  if (clipped === null) return null;
+  const words = clipped.split(/\s+/);
+  const verb = verbHead(words[0]);
+  if (verb !== null && words.length > 1) {
+    return tidy(`${lead(kind)} that ${verb} ${words.slice(1).join(" ")}`);
+  }
+  if (verb !== null) return null;
+  const noun = clipped.replace(/^(?:the|a|an)\s+/i, "");
+  return tidy(`${lead(kind)} for ${noun.charAt(0).toLowerCase()}${noun.slice(1)}`);
+}
+var VERB_PHRASE_KINDS = /* @__PURE__ */ new Set(["function", "method"]);
+function summaryFromName(name, kind) {
+  if (!NAME_DERIVED_ENABLED) return null;
+  const words = identifierWords(name);
+  while (words.length > 1 && DANGLING.has(words[words.length - 1])) words.pop();
+  if (words.length === 0) return null;
+  const verb = VERB_PHRASE_KINDS.has(kind) ? verbHead(words[0]) : null;
+  const rest = words.slice(1).join(" ");
+  const phrase = verb !== null && rest ? `${lead(kind)} that ${verb} the ${rest}` : verb !== null ? null : `${lead(kind)} for the ${words.join(" ")}`;
+  if (phrase === null) return null;
+  const trimmed = tidy(phrase);
+  return trimmed.length <= MAX_PAYLOAD_CHARS + 24 ? trimmed : null;
+}
+function summaryCandidates(name, kind, doc) {
+  const candidates = [];
+  const fromDoc = doc ? summaryFromDoc(doc, kind) : null;
+  if (fromDoc !== null) candidates.push(fromDoc);
+  const fromName = summaryFromName(name, kind);
+  if (fromName !== null && fromName !== fromDoc) candidates.push(fromName);
+  return candidates;
+}
+
+// src/generalize-graph.ts
+var SYMBOL_LABELS = [
+  ["Function", "function"],
+  ["Method", "method"],
+  ["Class", "class"],
+  ["Interface", "interface"],
+  ["Const", "constant"]
+];
+var BUILTIN_TYPE_NAMES = /* @__PURE__ */ new Set([
+  "Array",
+  "Boolean",
+  "Buffer",
+  "Date",
+  "Error",
+  "Function",
+  "Map",
+  "Math",
+  "Number",
+  "Object",
+  "Promise",
+  "Proxy",
+  "RegExp",
+  "Set",
+  "String",
+  "Symbol",
+  "WeakMap",
+  "WeakSet",
+  "TypeError",
+  "RangeError",
+  "SyntaxError",
+  "URL",
+  "Request",
+  "Response",
+  "Headers"
+]);
+function isDistinctiveIdentifier(name) {
+  if (name.length < 3) return false;
+  if (/[\s:]/.test(name)) return false;
+  if (BUILTIN_TYPE_NAMES.has(name)) return false;
+  if (name.includes(".") || name.includes("_") || /\d/.test(name)) return true;
+  if (/[a-z][A-Z]/.test(name)) return true;
+  if (/^[A-Z]/.test(name) && /[a-z]/.test(name) && name.length >= 4) return true;
+  return false;
+}
+var DOC_COMMENT_KINDS = /* @__PURE__ */ new Set(["docstring", "explanation"]);
+var MAX_DOC_CHARS = 600;
+function buildDocIndex(store) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const c of store.findNodesByLabel("Comment")) {
+    const name = c.attrs["attachedTo"];
+    const kind = c.attrs["kind"];
+    if (typeof name !== "string" || !name) continue;
+    if (typeof kind !== "string" || !DOC_COMMENT_KINDS.has(kind)) continue;
+    const text = typeof c.attrs["text"] === "string" ? c.attrs["text"] : c.description;
+    if (!text?.trim()) continue;
+    if (!byName.has(name)) byName.set(name, text.trim().slice(0, MAX_DOC_CHARS));
+  }
+  return byName;
+}
+function buildSymbolLexicon(store) {
+  const lex = /* @__PURE__ */ new Map();
+  const docs = buildDocIndex(store);
+  const candidates = [];
+  for (const [label, kind] of SYMBOL_LABELS) {
+    for (const n of store.findNodesByLabel(label)) {
+      const qname = String(n.attrs["qname"] ?? "");
+      const doc = (n.description ? docs.get(n.description) : void 0) ?? (qname ? docs.get(qname) : void 0);
+      for (const name of [n.description, qname]) {
+        if (name && isDistinctiveIdentifier(name) && !lex.has(name)) {
+          lex.set(name, { kind });
+          candidates.push([name, kind, doc]);
+        }
+      }
+    }
+  }
+  const isKnown = (tok) => lex.has(tok);
+  for (const [name, kind, doc] of candidates) {
+    for (const phrase of summaryCandidates(name, kind, doc)) {
+      if (summaryRejectionReason(phrase, isKnown) === null) {
+        lex.get(name).summary = phrase;
+        break;
+      }
+    }
+  }
+  return lex;
+}
+var RE_RESERVED = /[.*+?^${}()|[\]\\]/g;
+var escapeRe2 = (s) => s.replace(RE_RESERVED, "\\$&");
+var RE_LEADING_ARTICLE = /^(?:an?|the)\s/i;
+function replaceWithPhrase(text, before, escapedKey, after, phrase) {
+  if (!RE_LEADING_ARTICLE.test(phrase)) {
+    return text.replace(new RegExp(`${before}${escapedKey}${after}`, "g"), phrase);
+  }
+  const re = new RegExp(`${before}${String.raw`(?:(An|an|A|a|The|the)\s+)?`}${escapedKey}${after}`, "g");
+  return text.replace(
+    re,
+    (_match, article) => article !== void 0 && /^[A-Z]/.test(article) ? phrase.charAt(0).toUpperCase() + phrase.slice(1) : phrase
+  );
+}
+function isBareMatchableStem(stem) {
+  return stem.length >= 5 && /^[A-Za-z0-9]+(?:[-_][A-Za-z0-9]+)+$/.test(stem);
+}
+var CONVENTION_FILENAMES = /* @__PURE__ */ new Set([
+  "package.json",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "pnpm-workspace.yaml",
+  "yarn.lock",
+  "tsconfig.json",
+  "tsconfig.base.json",
+  "turbo.json",
+  "README.md",
+  "LICENSE",
+  "CHANGELOG.md",
+  "CONTRIBUTING.md",
+  // agent-config conventions — as cross-repo universal as README.md by 2026
+  "AGENTS.md",
+  "CLAUDE.md",
+  "Dockerfile",
+  "docker-compose.yml",
+  ".gitignore",
+  ".env",
+  ".env.example",
+  "index.ts",
+  "index.js",
+  "index.tsx",
+  "index.mjs"
+]);
+var CONVENTION_BASENAME_MIN_FILES = 3;
+var CONVENTION_STEMS = /* @__PURE__ */ new Set([
+  "well-known",
+  "read-only",
+  "type-safe",
+  "end-to-end",
+  "fail-open",
+  "fail-closed",
+  "up-to-date",
+  "server-side",
+  "client-side",
+  "cross-origin",
+  "same-origin",
+  "well-formed",
+  "first-class",
+  "in-memory",
+  "single-page",
+  "use-case",
+  "out-of-band"
+]);
+function buildFileLexicon(store) {
+  const byKey = /* @__PURE__ */ new Map();
+  const byBasename = /* @__PURE__ */ new Map();
+  const byStem = /* @__PURE__ */ new Map();
+  const basenameCount = /* @__PURE__ */ new Map();
+  const stemRelPaths = /* @__PURE__ */ new Map();
+  const entries = [];
+  for (const n of store.findNodesByLabel("File")) {
+    const relPath = typeof n.attrs["relPath"] === "string" && n.attrs["relPath"].length > 0 ? n.attrs["relPath"] : n.description;
+    if (!relPath) continue;
+    const basename = relPath.split("/").pop();
+    if (!basename.includes(".")) continue;
+    entries.push({ relPath, basename });
+    basenameCount.set(basename, (basenameCount.get(basename) ?? 0) + 1);
+    const stem = basename.slice(0, basename.indexOf("."));
+    if (isBareMatchableStem(stem)) {
+      let s = stemRelPaths.get(stem);
+      if (!s) stemRelPaths.set(stem, s = /* @__PURE__ */ new Set());
+      s.add(relPath);
+    }
+  }
+  for (const { relPath, basename } of entries) {
+    const entry = { relPath };
+    if (relPath !== basename) byKey.set(relPath, entry);
+    const conventional = CONVENTION_FILENAMES.has(basename) || (basenameCount.get(basename) ?? 0) >= CONVENTION_BASENAME_MIN_FILES;
+    if (!conventional && !byKey.has(basename)) byKey.set(basename, entry);
+    const list = byBasename.get(basename);
+    if (list) list.push(entry);
+    else byBasename.set(basename, [entry]);
+    const stem = basename.slice(0, basename.indexOf("."));
+    if (isBareMatchableStem(stem) && !CONVENTION_STEMS.has(stem) && !byStem.has(stem)) {
+      const dirStems = new Set(
+        [...stemRelPaths.get(stem) ?? []].map((p) => {
+          const bn = p.split("/").pop();
+          return p.slice(0, p.length - bn.length) + bn.slice(0, bn.indexOf("."));
+        })
+      );
+      if (dirStems.size === 1) byStem.set(stem, entry);
+    }
+  }
+  return { byKey, byBasename, byStem };
+}
+var FILE_TOKEN_RE = /(?:[A-Za-z0-9_.-]+\/)*[A-Za-z0-9_-][A-Za-z0-9_.-]*\.[A-Za-z0-9]+/g;
+function resolveFileToken(token, lexicon) {
+  const exact = lexicon.byKey.get(token);
+  if (exact) return exact;
+  if (!token.includes("/")) return null;
+  const basename = token.split("/").pop();
+  for (const entry of lexicon.byBasename.get(basename) ?? []) {
+    if (entry.relPath === token || entry.relPath.endsWith(`/${token}`)) return entry;
+  }
+  return null;
+}
+function internalFilesFor(description, lexicon) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const m of description.matchAll(FILE_TOKEN_RE)) {
+    const tok = m[0];
+    if (seen.has(tok)) continue;
+    seen.add(tok);
+    if (resolveFileToken(tok, lexicon)) out.push(tok);
+  }
+  return out;
+}
+function fileRolePhrase(relPath, level = 1) {
+  if (level !== 1) return "a file";
+  if (/\.(test|spec)\.|__tests__\/|(?:^|\/)e2e\//.test(relPath)) return "a test file";
+  if (/(?:^|\/)scripts?\//.test(relPath)) return "a script";
+  if (/\.md$/i.test(relPath)) return "a documentation file";
+  if (/\.(json|ya?ml|toml|env)$/i.test(relPath)) return "a config file";
+  return "a source file";
+}
+var STEM_TOKEN_RE = /[A-Za-z0-9]+(?:[-_][A-Za-z0-9]+)+/g;
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  "ts",
+  "tsx",
+  "js",
+  "jsx",
+  "mjs",
+  "cjs",
+  "py",
+  "go",
+  "rs",
+  "java",
+  "kt",
+  "rb",
+  "c",
+  "h",
+  "cc",
+  "cpp",
+  "hpp",
+  "cs",
+  "php",
+  "swift",
+  "scala",
+  "sh",
+  "ps1",
+  "sql",
+  "css",
+  "scss",
+  "html",
+  "vue",
+  "svelte",
+  "md",
+  "json",
+  "yaml",
+  "yml",
+  "toml",
+  "ini",
+  "env",
+  "cypher"
+]);
+function isSourceFileToken(token) {
+  const basename = token.split(/[/\\]/).pop() ?? token;
+  if (CONVENTION_FILENAMES.has(basename)) return false;
+  const ext = basename.split(".").pop();
+  return ext !== void 0 && SOURCE_EXTENSIONS.has(ext.toLowerCase());
+}
+function generalizeFileRefs(text, fileLexicon, level = 1) {
+  let out = text;
+  let lexiconMisses = 0;
+  const files = [];
+  const seenFiles = /* @__PURE__ */ new Set();
+  for (const m of out.matchAll(FILE_TOKEN_RE)) {
+    const tok = m[0];
+    if (seenFiles.has(tok)) continue;
+    seenFiles.add(tok);
+    const entry = resolveFileToken(tok, fileLexicon);
+    if (entry) files.push([tok, entry]);
+    else if (isSourceFileToken(tok)) lexiconMisses++;
+  }
+  files.sort((a, b) => b[0].length - a[0].length);
+  for (const [tok, entry] of files) {
+    out = replaceWithPhrase(
+      out,
+      "(?<![\\w$/\\\\.-])",
+      escapeRe2(tok),
+      "(?![\\w$-])",
+      fileRolePhrase(entry.relPath, level)
+    );
+  }
+  const stems = [];
+  const seenStems = /* @__PURE__ */ new Set();
+  for (const m of out.matchAll(STEM_TOKEN_RE)) {
+    const tok = m[0];
+    if (seenStems.has(tok)) continue;
+    seenStems.add(tok);
+    const entry = fileLexicon.byStem.get(tok);
+    if (entry) stems.push([tok, entry]);
+  }
+  stems.sort((a, b) => b[0].length - a[0].length);
+  for (const [tok, entry] of stems) {
+    out = replaceWithPhrase(
+      out,
+      "(?<![\\w$/\\\\.-])",
+      escapeRe2(tok),
+      "(?![\\w$/\\\\.-])",
+      fileRolePhrase(entry.relPath, level)
+    );
+  }
+  return { text: out, substitutions: files.length + stems.length, lexiconMisses };
+}
+
+// src/instance-ingest.ts
+var INSTANCE_LABELS = ["Problem", "Solution", "RootCause"];
+var INSTANCE_EDGES = ["CAUSED_BY", "SOLVED_BY"];
+var ANCHOR_EDGES = ["OCCURS_IN", "DEPENDS_ON", "PERTAIN_TO", "CONCERNS"];
+var ANCHOR_TARGET_LABELS = ["Language", "Package", "Domain", "Component"];
+function stripCodebaseScope(scope) {
+  const s = { ...scope ?? {} };
+  delete s["codebase"];
+  return s;
+}
+function contributedWireId(n) {
+  const cloudId = n.attrs["cloudNodeId"];
+  return isMembraneSaltedId(cloudId) ? cloudId : n.id;
+}
+var WIRE_CANONICAL_ID_MIN = 6;
+var SHIP_TERMINAL_REFUSALS = 3;
+function refusalFingerprint(reason, description) {
+  return digest(`${reason}\0${description}`);
+}
+function isRetryableRefusal(reason) {
+  return /\bretry\b/i.test(reason);
+}
+function isTerminallyRefused(n) {
+  const reason = String(n.attrs["shipRefusedReason"] ?? "");
+  return typeof n.attrs["shipRefusedCount"] === "number" && n.attrs["shipRefusedCount"] >= SHIP_TERMINAL_REFUSALS && !isRetryableRefusal(reason) && n.attrs["shipRefusedFingerprint"] === refusalFingerprint(reason, n.description);
+}
+function unshippableReason(canonical, label) {
+  void label;
+  if (canonical.length < WIRE_CANONICAL_ID_MIN) {
+    return `canonicalId "${canonical}" is ${canonical.length} chars; the door requires >= ${WIRE_CANONICAL_ID_MIN}`;
+  }
+  return null;
+}
+function wireContextId(n) {
+  if (n.label === "Language" && n.attrs["source"] !== "cloud") {
+    const name = String(n.attrs["name"] ?? "").trim() || n.description.trim() || n.id.replace(/^lang:/, "");
+    return languageCanonicalId(name);
+  }
+  if (n.label === "Domain" && n.attrs["source"] !== "cloud") {
+    return String(n.attrs["canonicalId"] ?? n.id);
+  }
+  if (n.label === "Component" && n.attrs["source"] !== "cloud") {
+    return String(n.attrs["canonicalId"] ?? n.id);
+  }
+  return n.id;
+}
+function langAnchor(t) {
+  const name = String(t.attrs["name"] ?? "").trim() || t.description.trim() || t.id.replace(/^lang:/, "").trim();
+  return name ? `lang:${name.toLowerCase()}` : void 0;
+}
+function shareableContext(n, wireId) {
+  const attrs = n.label === "Package" ? {
+    // No `version` attr: the purl encodes it, and the door's temporal
+    // guard 422s any `attrs.version` (mirrors buildContextIngest).
+    purl: n.attrs["purl"],
+    name: n.attrs["name"],
+    ecosystem: n.attrs["ecosystem"],
+    resolved: n.attrs["resolved"]
+  } : n.label === "Domain" ? { name: n.description, canonicalId: n.attrs["canonicalId"] } : n.label === "Component" ? { name: n.attrs["name"], canonicalId: n.attrs["canonicalId"] } : { name: n.attrs["name"] };
+  return {
+    ...n,
+    id: wireId,
+    embedding: [],
+    attrs,
+    ...n.label === "Package" ? { anchorVisibility: "public" } : {},
+    ...n.label === "Language" && langAnchor(n) ? { anchorVisibility: "public", anchor: langAnchor(n) } : {},
+    // A Component stub claims itself by slug (OM-agent-anchors) — the door
+    // confirms only against an EXISTING public Component of that slug, so an
+    // org-internal component name never crosses (fails closed to org).
+    ...n.label === "Component" ? { anchorVisibility: "public", anchor: `component:${wireId}` } : {}
+  };
+}
+function buildInstanceIngest(store, profile, daemonVersion, ignorePatterns = [], opts = {}) {
+  const level = opts.level ?? 1;
+  const noveltyOpts = opts.dedupCosine != null ? { dedupCosine: opts.dedupCosine } : {};
+  const ignored = (text) => ignorePatterns.length > 0 && ignorePatterns.some((p) => text.toLowerCase().includes(p));
+  const originSessionOf = (n) => {
+    const key = sessionOriginKey(n.attrs["sources"]?.[0]);
+    return key ? { originSession: key } : {};
+  };
+  const symbolIndex = opts.workspaceRoot ? publicSymbolIndex(store, opts.workspaceRoot) : null;
+  const ownLexicon = opts.lexicon ?? buildSymbolLexicon(store);
+  const projectIdentity = {
+    ...profile.name ? { name: profile.name } : {},
+    ...profile.repoLocator ? { repoLocator: profile.repoLocator } : {},
+    ...profile.repoLocatorAliases ? { aliases: profile.repoLocatorAliases } : {},
+    ...profile.aka ? { aka: profile.aka } : {}
+  };
+  const fileLexicon = buildFileLexicon(store);
+  const shareable = (n) => {
+    const preserved = symbolIndex ? preservedSymbolsFor(n.description, symbolIndex) : [];
+    const fileRefs = generalizeFileRefs(n.description, fileLexicon, level);
+    const fileScrubbed = fileRefs.text;
+    composition.fileRefsSubstituted += fileRefs.substitutions;
+    composition.fileRefLexiconMisses += fileRefs.lexiconMisses;
+    const generalized = generalize(fileScrubbed, { level, project: projectIdentity });
+    const shippedText = generalized.text;
+    if (generalized.report.classes.length > 0) composition.privacyRewritten++;
+    const internalSyms = internalSymbolsFor(shippedText, (t) => ownLexicon.has(t), symbolIndex);
+    const internalFiles = internalFilesFor(shippedText, fileLexicon);
+    const internal = [.../* @__PURE__ */ new Set([...internalFiles, ...internalSyms])].slice(
+      0,
+      PRESERVED_SYMBOLS_CAP
+    );
+    return {
+      ...n,
+      description: shippedText,
+      embedding: [],
+      ...originSessionOf(n),
+      attrs: {
+        scope: stripCodebaseScope(n.attrs["scope"]),
+        ...n.attrs["kind"] ? { kind: n.attrs["kind"] } : {},
+        ...n.attrs["resolvedAs"] ? { resolvedAs: n.attrs["resolvedAs"] } : {},
+        ...preserved.length > 0 ? { preservedSymbols: preserved } : {},
+        ...internal.length > 0 ? { internalSymbols: internal } : {}
+      }
+    };
+  };
+  const nodes = [];
+  const seen = /* @__PURE__ */ new Set();
+  const walked = /* @__PURE__ */ new Set();
+  const shippedById = /* @__PURE__ */ new Map();
+  const anchorSources = /* @__PURE__ */ new Set();
+  const semanticEndpoints = /* @__PURE__ */ new Map();
+  const includedByLabel = /* @__PURE__ */ new Map();
+  const composition = {
+    candidates: 0,
+    shipped: 0,
+    cloudSourced: 0,
+    falsePositive: 0,
+    ignored: 0,
+    watermarked: 0,
+    autoMint: 0,
+    notNovel: 0,
+    unshippable: 0,
+    heldOrphans: 0,
+    terminalRefused: 0,
+    privacyRewritten: 0,
+    sidecarDropped: 0,
+    sidecarDropReasons: {},
+    sidecarTruncatedAtCap: 0,
+    sidecarNoLexicon: 0,
+    sidecarNoSummary: 0,
+    fileRefsSubstituted: 0,
+    fileRefLexiconMisses: 0
+  };
+  for (const label of INSTANCE_LABELS) {
+    const ref = [];
+    includedByLabel.set(label, ref);
+    const population = label === "RootCause" && opts.sharedStore ? [...store.findNodesByLabel(label), ...opts.sharedStore.findNodesByLabel(label)] : store.findNodesByLabel(label);
+    for (const n of population) {
+      if (seen.has(n.id)) continue;
+      if (walked.has(n.id)) continue;
+      walked.add(n.id);
+      composition.candidates++;
+      if (n.attrs["source"] === "cloud") {
+        composition.cloudSourced++;
+        continue;
+      }
+      if (label === "Problem" && n.attrs["resolvedAs"] === PROBLEM_RESOLUTION.FALSE_POSITIVE) {
+        composition.falsePositive++;
+        continue;
+      }
+      if (ignored(n.description)) {
+        composition.ignored++;
+        continue;
+      }
+      const contributedAtSeq = n.attrs["contributedAtSeq"];
+      if (typeof contributedAtSeq === "number" && (n.lastReinforcedAtSeq ?? 0) <= contributedAtSeq) {
+        composition.watermarked++;
+        anchorSources.add(n.id);
+        semanticEndpoints.set(n.id, contributedWireId(n));
+        continue;
+      }
+      if (label === "Solution" && n.description.startsWith(AUTO_MINT_PREFIX)) {
+        composition.autoMint++;
+        continue;
+      }
+      if (isTerminallyRefused(n)) {
+        composition.terminalRefused++;
+        continue;
+      }
+      if (!noveltyAgainst(n, ref, noveltyOpts).ready) {
+        composition.notNovel++;
+        continue;
+      }
+      const reject = unshippableReason(n.id, n.label);
+      if (reject) {
+        console.warn(`[errata] skipping unshippable node ${n.id} (${n.label}): ${reject}`);
+        composition.unshippable++;
+        continue;
+      }
+      ref.push(n);
+      const wireNode = shareable(n);
+      nodes.push(wireNode);
+      shippedById.set(n.id, wireNode);
+      seen.add(n.id);
+      anchorSources.add(n.id);
+      semanticEndpoints.set(n.id, n.id);
+    }
+  }
+  for (const n of nodes) {
+    if (!INSTANCE_LABELS.includes(n.label)) {
+      throw new Error(`buildInstanceIngest: refusing to ship non-instance ${n.id} (${n.label}) \u2014 C7 invariant`);
+    }
+  }
+  const anchorEdges = [];
+  const contextNodes = [];
+  const contextSeen = /* @__PURE__ */ new Set();
+  const anchorDigests = {};
+  for (const sourceId of anchorSources) {
+    const targets = [];
+    for (const e of store.outEdges(sourceId, [...ANCHOR_EDGES])) {
+      const t = store.getNode(e.to);
+      if (!t || !ANCHOR_TARGET_LABELS.includes(t.label)) continue;
+      if (e.type === "OCCURS_IN" && t.label !== "Language") continue;
+      if (e.type === "DEPENDS_ON" && t.label !== "Package") continue;
+      if (e.type === "PERTAIN_TO" && t.label !== "Domain") continue;
+      if (e.type === "CONCERNS" && t.label !== "Component") continue;
+      if ((t.label === "Package" || t.label === "Component") && opts.includePackages !== true) continue;
+      if (ignored(t.description) || ignored(String(t.attrs["name"] ?? ""))) continue;
+      targets.push({ e, t, wireId: wireContextId(t) });
+    }
+    if (targets.length === 0) continue;
+    const shipped = shippedById.get(sourceId);
+    if (shipped) {
+      const anchors = (label) => targets.filter((x) => x.t.label === label).map(
+        (x) => label === "Language" ? langAnchor(x.t) : label === "Component" ? `component:${x.wireId}` : x.wireId
+      ).filter((a) => a != null).sort();
+      const anchor = anchors("Package")[0] ?? anchors("Component")[0] ?? anchors("Language")[0];
+      if (anchor) {
+        shipped.anchorVisibility = "public";
+        shipped.anchor = anchor;
+      }
+    }
+    const dg = digest(targets.map(({ e, wireId }) => `${e.type}>${wireId}`).sort());
+    const sourceNode = store.getNode(sourceId);
+    if (sourceNode?.attrs["anchorsContributedDigest"] === dg) continue;
+    anchorDigests[sourceId] = dg;
+    const wireFrom = seen.has(sourceId) || !sourceNode ? sourceId : contributedWireId(sourceNode);
+    for (const { e, t, wireId } of targets) {
+      const reject = unshippableReason(wireId, t.label);
+      if (reject) {
+        console.warn(`[errata] skipping unshippable anchor ${wireId} (${t.label}): ${reject}`);
+        continue;
+      }
+      anchorEdges.push({ ...e, from: wireFrom, to: wireId, attrs: {} });
+      if (t.attrs["source"] === "cloud" || contextSeen.has(wireId)) continue;
+      contextSeen.add(wireId);
+      contextNodes.push(shareableContext(t, wireId));
+    }
+  }
+  const primaryLang = (profile.languages ?? []).map((l) => String(l).trim().toLowerCase()).filter(Boolean)[0];
+  if (primaryLang) {
+    for (const shipped of shippedById.values()) {
+      if (!shipped.anchorVisibility) {
+        shipped.anchorVisibility = "public";
+        shipped.anchor = `lang:${primaryLang}`;
+      }
+    }
+  }
+  const project = opts.project;
+  const projectAnchorDigests = {};
+  if (project) {
+    const now = Date.now();
+    for (const sourceId of anchorSources) {
+      const source = store.getNode(sourceId);
+      if (!source) continue;
+      const wireFrom = seen.has(sourceId) ? sourceId : contributedWireId(source);
+      const planned = [];
+      for (const e of store.outEdges(sourceId, ["ANCHORED_AT"])) {
+        const target = store.getNode(e.to);
+        if (!target) continue;
+        const relPath = target.attrs["relPath"];
+        const qname = target.attrs["qname"];
+        if (typeof relPath !== "string" || typeof qname !== "string") continue;
+        if (ignored(relPath) || ignored(qname)) continue;
+        planned.push({ e, target, symId: projectSymbolId(project.salt, project.projectId, relPath, qname, target.label) });
+      }
+      if (planned.length === 0) continue;
+      const dg = digest(
+        planned.map(({ e, symId }) => `ANCHORED_AT>${symId}>${JSON.stringify(anchorVersionAttrs(e.attrs))}`).sort()
+      );
+      if (source.attrs["projectAnchorsContributedDigest"] === dg) continue;
+      projectAnchorDigests[sourceId] = dg;
+      for (const { e, target, symId } of planned) {
+        if (!contextSeen.has(symId)) {
+          contextSeen.add(symId);
+          contextNodes.push({
+            id: symId,
+            label: "Symbol",
+            // The id IS the description: there is nothing that can be said about an
+            // opaque symbol without disclosing it, and the wire requires a non-empty
+            // string. It must never carry the name or the path.
+            description: symId,
+            // `kind` is coarse (Function/Class/…) — shape, not identity.
+            attrs: { kind: target.label },
+            embedding: [],
+            extractionConfidence: 1,
+            extractionSource: "daemon-extracted",
+            cumulativeSurprise: 0,
+            peakSurprise: 0,
+            cumulativeHits: 0,
+            lastUpdatedAt: now,
+            createdAt: now,
+            memoryTier: "short-term",
+            pageRank: 0,
+            isLandmark: false,
+            community: null,
+            stability: "unstable"
+          });
+        }
+        anchorEdges.push({ ...e, from: wireFrom, to: symId, attrs: anchorVersionAttrs(e.attrs) });
+      }
+    }
+  }
+  const edges = [];
+  const semanticEdgeDigests = {};
+  for (const [sourceId, wireFrom] of semanticEndpoints) {
+    const rawOuts = [
+      ...store.outEdges(sourceId, [...INSTANCE_EDGES]),
+      ...opts.sharedStore?.outEdges(sourceId, [...INSTANCE_EDGES]) ?? []
+    ];
+    const dedup = /* @__PURE__ */ new Map();
+    for (const e of rawOuts) dedup.set(`${e.type}>${e.to}`, e);
+    const outs = [...dedup.values()].map((e) => ({ e, wireTo: semanticEndpoints.get(e.to) })).filter((x) => x.wireTo != null);
+    if (outs.length === 0) continue;
+    const dg = digest(outs.map(({ e, wireTo }) => `${e.type}>${wireTo}`).sort());
+    const owner = store.getNode(sourceId) ?? opts.sharedStore?.getNode(sourceId);
+    const digestSkip = owner?.attrs["semanticEdgesContributedDigest"] === dg;
+    if (!digestSkip) semanticEdgeDigests[sourceId] = dg;
+    for (const { e, wireTo } of outs) {
+      if (digestSkip && !shippedById.has(e.to)) continue;
+      edges.push({ ...e, from: wireFrom, to: wireTo, attrs: {} });
+    }
+  }
+  if (nodes.length === 0 && anchorEdges.length === 0 && edges.length === 0) {
+    opts.onComposition?.(composition);
+    return null;
+  }
+  let symbolSummaries;
+  if (!opts.lexicon || opts.lexicon.size === 0) composition.sidecarNoLexicon = 1;
+  if (opts.lexicon && opts.lexicon.size > 0 && nodes.length > 0) {
+    const lexicon = opts.lexicon;
+    const isKnown = (tok) => lexicon.has(tok);
+    const sidecar = {};
+    let count = 0;
+    outer: for (const n of nodes) {
+      if (!INSTANCE_LABELS.includes(n.label)) continue;
+      for (const tok of extractIdentifierTokens(n.description)) {
+        if (sidecar[tok]) continue;
+        const entry = lexicon.get(tok);
+        if (!entry) continue;
+        if (!entry.summary) {
+          composition.sidecarNoSummary++;
+          continue;
+        }
+        const scrubbed = generalize(entry.summary, { level, project: projectIdentity }).text.trim();
+        const dropBucket = !scrubbed ? "empty" : sidecarDropBucket(summaryRejectionReason(scrubbed, isKnown));
+        if (dropBucket !== null) {
+          composition.sidecarDropped++;
+          composition.sidecarDropReasons[dropBucket] = (composition.sidecarDropReasons[dropBucket] ?? 0) + 1;
+          continue;
+        }
+        if (count >= MAX_SIDECAR_SYMBOLS) {
+          composition.sidecarTruncatedAtCap = 1;
+          break outer;
+        }
+        sidecar[tok] = { kind: entry.kind, summary: scrubbed };
+        count++;
+      }
+    }
+    if (count > 0) symbolSummaries = sidecar;
+  }
+  edges.push(...anchorEdges);
+  const bindingEndpoints = /* @__PURE__ */ new Set();
+  for (const e of edges) {
+    if (e.type === "CAUSED_BY" || e.type === "SOLVED_BY") {
+      bindingEndpoints.add(e.from);
+      bindingEndpoints.add(e.to);
+    }
+  }
+  const heldOrphans = /* @__PURE__ */ new Set();
+  for (const wn of nodes) {
+    if (wn.label !== "RootCause" && wn.label !== "Solution") continue;
+    const src = store.getNode(wn.id) ?? opts.sharedStore?.getNode(wn.id);
+    if (typeof src?.attrs["contributedAtSeq"] === "number") continue;
+    if (bindingEndpoints.has(wn.id)) continue;
+    heldOrphans.add(wn.id);
+  }
+  const shippableNodes = heldOrphans.size === 0 ? nodes : nodes.filter((n) => !heldOrphans.has(n.id));
+  const shippableEdges = heldOrphans.size === 0 ? edges : edges.filter((e) => !heldOrphans.has(e.from) && !heldOrphans.has(e.to));
+  for (const id of heldOrphans) {
+    delete anchorDigests[id];
+    delete semanticEdgeDigests[id];
+    delete projectAnchorDigests[id];
+  }
+  if (heldOrphans.size > 0) {
+    console.warn(
+      `[errata] held ${heldOrphans.size} causal-orphan node(s) \u2014 no shippable binding edge this drain (VS-orphan-gate)`
+    );
+  }
+  composition.heldOrphans = heldOrphans.size;
+  composition.shipped = shippableNodes.length;
+  if (shippableNodes.length === 0 && shippableEdges.length === 0) {
+    opts.onComposition?.(composition);
+    return null;
+  }
+  const base = {
+    daemonVersion,
+    // Origin key (= project, the salted `wp_…`) — the door stamps it onto created
+    // nodes as `authoringProject`, arming the evidence channels' cross-origin gate
+    // (EE-corrob-live: this is the MAIN semantic drain; without the stamp every
+    // Problem/Solution lands fail-open to self-corroboration).
+    ...profile.id ? { originProject: profile.id } : {},
+    profile: { stack: profile.stack, languages: profile.languages, domains: profile.domains },
+    // Context nodes FIRST: a chunked drain (cloud-client, 25-node chunks) then
+    // co-locates the few Language/Package stubs with the first instance chunk,
+    // maximizing in-payload endpoint resolution.
+    nodes: [...contextNodes, ...shippableNodes],
+    edges: shippableEdges,
+    // Spread-if-present: an absent sidecar keeps `base` — and therefore the
+    // payloadDigest — byte-identical to the pre-sidecar batch (backward compat).
+    ...symbolSummaries ? { symbolSummaries } : {}
+  };
+  opts.onComposition?.(composition);
+  return { ...base, payloadDigest: digest(base), anchorDigests, semanticEdgeDigests, projectAnchorDigests, composition };
+}
+
+// src/drain-build.ts
+function buildDrainContext(store, input) {
+  return buildContextIngest(store, input.profile, input.daemonVersion, input.ignorePatterns, {
+    ...input.includePackages !== void 0 ? { includePackages: input.includePackages } : {}
+  });
+}
+function buildDrainInstances(store, sharedStore, input) {
+  let lexicon;
+  let lexiconError;
+  try {
+    lexicon = buildSymbolLexicon(store);
+  } catch (err) {
+    lexiconError = err instanceof Error ? err.message : String(err);
+  }
+  let composition = null;
+  const batch = buildInstanceIngest(store, input.profile, input.daemonVersion, input.ignorePatterns, {
+    ...input.includePackages !== void 0 ? { includePackages: input.includePackages } : {},
+    workspaceRoot: input.workspaceRoot,
+    sharedStore,
+    onComposition: (c) => {
+      composition = c;
+    },
+    ...lexicon ? { lexicon } : {},
+    ...input.project ? { project: input.project } : {}
+  });
+  return {
+    batch,
+    composition: composition ?? batch?.composition ?? null,
+    ...lexiconError ? { lexiconError } : {}
+  };
+}
+
 // src/consolidate-worker.ts
 var stores = /* @__PURE__ */ new Map();
 function storeAt(path) {
@@ -17709,6 +19375,16 @@ function runPass(msg) {
       if (!msg.castaliaPath) throw new Error("strandedCount: castaliaPath required");
       return findStrandedSymbols(storeAt(msg.castaliaPath)).length;
     }
+    case "drainContext": {
+      if (!msg.castaliaPath) throw new Error("drainContext: castaliaPath required");
+      if (!msg.drain) throw new Error("drainContext: drain input required");
+      return buildDrainContext(storeAt(msg.castaliaPath), msg.drain);
+    }
+    case "drainInstances": {
+      if (!msg.castaliaPath) throw new Error("drainInstances: castaliaPath required");
+      if (!msg.drain) throw new Error("drainInstances: drain input required");
+      return buildDrainInstances(storeAt(msg.castaliaPath), shared, msg.drain);
+    }
     default:
       throw new Error(`unknown consolidation pass: ${msg.kind}`);
   }