@agfpd/iapeer-memory-core 0.1.1

package/src/smart-hash.ts

@@ -0,0 +1,85 @@
+/**
+ * sha256 of the SEMANTIC content of a vault .md file.
+ *
+ * TS port of the reference `scripts/mergemind-frontmatter-hash.py`
+ * (behavioural parity against `tests/python/test_frontmatter_hash.py`).
+ *
+ * The "semantic" part is the frontmatter without service fields plus the
+ * body. Service fields (`last_edited_by`, `updated`, `needs_review`) are
+ * rewritten by hooks after every edit and carry no meaning for the Index —
+ * noisy edits of those fields produce the SAME hash, the change detector
+ * emits no event, and the echo-loop is impossible below the instruction
+ * level (ADR-004/005: smart-hash is the idempotency primitive of the
+ * pipeline).
+ */
+
+import fs from "node:fs";
+import crypto from "node:crypto";
+
+/**
+ * Frontmatter fields ignored when hashing. Field NAMES are locale-independent
+ * (EN in both presets); the set is exported for detector configuration.
+ */
+export const SERVICE_FIELDS: ReadonlySet<string> = new Set([
+  "last_edited_by",
+  "updated",
+  "needs_review",
+]);
+
+const FRONTMATTER_RE = /^---[^\S\n]*\n([\s\S]*?\n)---[^\S\n]*(?:\n|$)/;
+const KEY_RE = /^([a-zA-Z_][\w-]*)\s*:/;
+
+function sha256Hex(data: Uint8Array | string): string {
+  return crypto.createHash("sha256").update(data).digest("hex");
+}
+
+/**
+ * Smart hash of raw file bytes. Invalid UTF-8 → raw-bytes hash (binary
+ * fallback). No frontmatter block → hash of the content as-is.
+ */
+export function smartHash(content: Uint8Array): string {
+  let text: string;
+  try {
+    text = new TextDecoder("utf-8", { fatal: true }).decode(content);
+  } catch {
+    // Binary / non-utf-8: hash as-is, no cleanup.
+    return sha256Hex(content);
+  }
+
+  const m = FRONTMATTER_RE.exec(text);
+  if (!m) {
+    // No frontmatter block — hash the body as-is.
+    return sha256Hex(content);
+  }
+
+  const fmBlock = m[1];
+  const body = text.slice(m[0].length);
+
+  // Drop service-field lines. The parser is simple — multi-line YAML values
+  // are not supported (our service fields are always single-line).
+  const cleanedLines: string[] = [];
+  for (const line of fmBlock.split("\n")) {
+    const keyMatch = KEY_RE.exec(line);
+    if (keyMatch && SERVICE_FIELDS.has(keyMatch[1])) continue;
+    cleanedLines.push(line);
+  }
+  const cleanedFm = cleanedLines.join("\n");
+
+  // Hash cleaned frontmatter + body. The `---` separator keeps frontmatter
+  // and body from merging (theoretical collision guard).
+  return sha256Hex(`${cleanedFm}\n---\n${body}`);
+}
+
+/**
+ * Smart hash of a file. Returns "" when the file is unreadable
+ * (silent skip — mirrors the reference CLI contract).
+ */
+export function hashFile(filePath: string): string {
+  let content: Buffer;
+  try {
+    content = fs.readFileSync(filePath);
+  } catch {
+    return "";
+  }
+  return smartHash(content);
+}

package/src/sqlite-loader.ts

@@ -0,0 +1,151 @@
+/**
+ * SQLite runtime preparation for `bun:sqlite` + `sqlite-vec`.
+ *
+ * Why this file exists: bun's bundled SQLite is compiled with
+ * `SQLITE_OMIT_LOAD_EXTENSION`, which makes `Database.prototype.loadExtension`
+ * fail at runtime ("This build of sqlite3 does not support dynamic extension
+ * loading"). bun:sqlite exports a static escape hatch — `Database.setCustomSQLite(path)`
+ * — that swaps in any libsqlite3.dylib at process startup. Most non-bundled
+ * builds (homebrew, system Linux distro packages) compile with extension
+ * loading enabled, so we can use them as the runtime SQLite and load
+ * `sqlite-vec` on top.
+ *
+ * Call exactly once per process, BEFORE constructing any `Database` — the
+ * choice is process-wide. On failure (no non-stripped libsqlite3 found, or
+ * `setCustomSQLite` itself throws), the function does NOT crash the process:
+ * it returns `{ available: false, reason }` and the caller falls back to the
+ * bundled bun-sqlite (without vec). That keeps the plugin working in degraded
+ * BM25-only mode on machines that don't have homebrew sqlite.
+ */
+
+import fs from "node:fs";
+import { Database } from "bun:sqlite";
+
+export type SqliteRuntime = {
+  available: boolean;
+  dylibPath: string | null;
+  reason: string;
+};
+
+const DEFAULT_DYLIB_CANDIDATES = [
+  // macOS — Homebrew (preferred: stays up to date, compiled without
+  // OMIT_LOAD_EXTENSION).
+  "/opt/homebrew/opt/sqlite/lib/libsqlite3.dylib",
+  "/opt/homebrew/lib/libsqlite3.dylib",
+  "/usr/local/opt/sqlite/lib/libsqlite3.dylib",
+  "/usr/local/lib/libsqlite3.dylib",
+  // Linux — typical package paths. Both Debian/Ubuntu and Fedora ship
+  // libsqlite3 with extension loading enabled by default.
+  "/usr/lib/x86_64-linux-gnu/libsqlite3.so",
+  "/usr/lib/x86_64-linux-gnu/libsqlite3.so.0",
+  "/usr/lib/aarch64-linux-gnu/libsqlite3.so",
+  "/usr/lib/aarch64-linux-gnu/libsqlite3.so.0",
+  "/usr/lib64/libsqlite3.so",
+  "/usr/lib64/libsqlite3.so.0",
+  "/usr/lib/libsqlite3.so",
+  "/usr/lib/libsqlite3.so.0",
+];
+
+// Module-level guard: setCustomSQLite is global per process. Calling it twice
+// either silently no-ops or throws depending on bun version — easier to track
+// the first decision ourselves and surface the result on subsequent calls.
+let cached: SqliteRuntime | null = null;
+
+export function prepareSqliteRuntime(
+  logger?: { info: (msg: string) => void; warn: (msg: string) => void },
+): SqliteRuntime {
+  if (cached) return cached;
+
+  // Explicit env override wins. Lets operators point at a bundled or
+  // custom-built libsqlite3 without code changes.
+  const envOverride = process.env.IAPEER_MEMORY_SQLITE_DYLIB;
+  const candidates = envOverride
+    ? [envOverride, ...DEFAULT_DYLIB_CANDIDATES]
+    : DEFAULT_DYLIB_CANDIDATES;
+
+  let chosen: string | null = null;
+  for (const path of candidates) {
+    try {
+      if (fs.existsSync(path)) {
+        chosen = path;
+        break;
+      }
+    } catch {
+      // unreadable path — skip
+    }
+  }
+
+  if (!chosen) {
+    cached = {
+      available: false,
+      dylibPath: null,
+      reason:
+        "non-stripped libsqlite3 not found; install homebrew sqlite or set IAPEER_MEMORY_SQLITE_DYLIB",
+    };
+    logger?.warn(
+      `sqlite-loader: ${cached.reason} — falling back to bundled bun-sqlite (no vec)`,
+    );
+    return cached;
+  }
+
+  try {
+    Database.setCustomSQLite(chosen);
+  } catch (err) {
+    cached = {
+      available: false,
+      dylibPath: chosen,
+      reason: `setCustomSQLite(${chosen}) failed: ${String(err)}`,
+    };
+    logger?.warn(`sqlite-loader: ${cached.reason}`);
+    return cached;
+  }
+
+  // Verify the chosen sqlite supports extension loading. A `.dylib` whose
+  // build has OMIT_LOAD_EXTENSION compiled in would still let setCustomSQLite
+  // succeed but block sqliteVec.load() later — better to catch it here so the
+  // reason is reported once at startup, not on every search.
+  try {
+    const probe = new Database(":memory:");
+    const opts = probe.prepare("SELECT * FROM pragma_compile_options()").all() as Array<{
+      compile_options: string;
+    }>;
+    probe.close();
+    const stripped = opts.some((o) =>
+      /OMIT_LOAD_EXTENSION/i.test(String(o.compile_options ?? "")),
+    );
+    if (stripped) {
+      cached = {
+        available: false,
+        dylibPath: chosen,
+        reason: `${chosen} is built with SQLITE_OMIT_LOAD_EXTENSION`,
+      };
+      logger?.warn(`sqlite-loader: ${cached.reason} — falling back to BM25-only`);
+      return cached;
+    }
+  } catch (err) {
+    cached = {
+      available: false,
+      dylibPath: chosen,
+      reason: `compile-options probe failed: ${String(err)}`,
+    };
+    logger?.warn(`sqlite-loader: ${cached.reason}`);
+    return cached;
+  }
+
+  cached = {
+    available: true,
+    dylibPath: chosen,
+    reason: "ok",
+  };
+  logger?.info(`sqlite-loader: using ${chosen} (extension loading enabled)`);
+  return cached;
+}
+
+/**
+ * Test-only escape hatch: reset the module-level cache so a unit test can
+ * exercise the detection logic against a synthetic env or candidate list.
+ * Production code never calls this.
+ */
+export function _resetSqliteRuntimeCacheForTests(): void {
+  cached = null;
+}

package/src/tags-mirror.ts

@@ -0,0 +1,47 @@
+/**
+ * Tags-dictionary mirror decision core — a memoryd subsystem (ADR-004,
+ * нюанс 2: the standalone tags-mirror daemon of the reference merges into
+ * memoryd; the mirror feeds the Index's per-peer fragment).
+ *
+ * TS port of the pure core of `scripts/mergemind-tags-mirror.cjs`
+ * (behavioural parity against `tests/tags-mirror.test.ts`, 6 fixtures).
+ *
+ * Why a mirror at all: the dictionary lives in the vault (possibly on
+ * iCloud) — reading it directly at prompt-assembly time risks a dataless
+ * source → an EMPTY dictionary for the critical curator. The mirror in the
+ * local cache namespace is always materialised; the fragment assembly
+ * reads the mirror, never the iCloud source.
+ */
+
+import type { TaxonomyPreset } from "./taxonomy.js";
+
+export type MirrorDecision = { action: "write" | "skip"; reason: string };
+
+/**
+ * Decide whether to overwrite the mirror. No I/O.
+ *
+ * LOAD-BEARING invariant: NEVER clobber a populated mirror with an empty
+ * source — a dataless/broken read must not zero out the working dictionary.
+ * Degraded (stale slice) beats empty.
+ */
+export function decideMirror(args: {
+  srcContent: string | null;
+  mirrorContent: string | null;
+}): MirrorDecision {
+  const { srcContent, mirrorContent } = args;
+  if (srcContent === null) {
+    return { action: "skip", reason: "source-unreadable" };
+  }
+  if (srcContent.trim() === "") {
+    return { action: "skip", reason: "source-empty-keep-mirror" };
+  }
+  if (mirrorContent !== null && srcContent === mirrorContent) {
+    return { action: "skip", reason: "identical" };
+  }
+  return { action: "write", reason: mirrorContent === null ? "mirror-absent" : "changed" };
+}
+
+/** Vault-relative path of the dictionary source for a locale preset. */
+export function tagsDictionarySourceRel(taxonomy: TaxonomyPreset): string {
+  return `${taxonomy.folders.system}/${taxonomy.systemFiles.tagsDictionary}`;
+}

package/src/taxonomy.ts

@@ -0,0 +1,385 @@
+/**
+ * Vault taxonomy as configuration — ADR-002 (taxonomy is config, not code
+ * constants) and ADR-011 (EN base nomenclature, RU as the first locale
+ * preset).
+ *
+ * Every folder name, enum value (type / status / subtype), the links-section
+ * heading, project file-name prefixes and system file names live here.
+ * i18n = presets of this same configuration: the EN base plus the RU preset
+ * (the live MergeMind vault, used for migration parity).
+ *
+ * The canonical RU↔EN mapping is the table in `docs/01-vault-layout.md`
+ * §«Таксономия» — this module encodes that table; tests guard shape parity
+ * between presets.
+ *
+ * Ranking coefficients are locale-independent and live in DEFAULT_RANKING —
+ * same ADR-002 rule (config, not constants), different axis (tuning, not
+ * language).
+ */
+
+export type LocaleId = "en" | "ru";
+
+export type StatusGroup = "active" | "pending" | "stale";
+
+export type TaxonomyFolders = {
+  inbox: string;
+  inboxHuman: string;
+  knowledge: string;
+  decisions: string;
+  projects: string;
+  ideas: string;
+  lists: string;
+  agentMemory: string;
+  archive: string;
+  system: string;
+};
+
+export type TaxonomyTypes = {
+  knowledge: string;
+  decision: string;
+  idea: string;
+  project: string;
+  list: string;
+  agentMemory: string;
+};
+
+export type TaxonomySubtypes = {
+  feedback: string;
+  context: string;
+  reference: string;
+  personProfile: string;
+  pitfall: string;
+};
+
+/** Individual status tokens the WRITER side must emit (hook fills). */
+export type TaxonomyStatusTokens = {
+  /** Initial status of a new inbox draft. */
+  draft: string;
+  /** Initial status of a new agent-memory note. */
+  current: string;
+};
+
+export type TaxonomyStatuses = {
+  /** Current/live lifecycle states — search boost ×activeBoost. */
+  active: string[];
+  /** Draft/deferred states — search boost ×pendingPenalty. */
+  pending: string[];
+  /** Final/closed states — search boost ×stalePenalty; trigger archiving
+   *  and are filtered out of author indexes. */
+  stale: string[];
+};
+
+export type TaxonomyProjectFiles = {
+  /** `Overview <name>.md` / `Описание <имя>.md` */
+  overviewPrefix: string;
+  /** `Plan <name>.md` / `План <имя>.md` */
+  planPrefix: string;
+  /** `Phase — <title>.md` / `Фаза — <название>.md` */
+  phasePrefix: string;
+};
+
+export type TaxonomySystemFiles = {
+  draftTemplate: string;
+  tagsDictionary: string;
+};
+
+/** Locale strings for the author-index renderer (display, not schema). */
+export type TaxonomyIndexStrings = {
+  /** `# {header} \`agent\`` */
+  header: string;
+  generatedComment: string;
+  sections: {
+    agentMemory: string;
+    knowledge: string;
+    decisions: string;
+    projects: string;
+    ideas: string;
+    lists: string;
+  };
+  emptySection: string;
+  /** Suffix after the link count: `3 св.` / `3 links`. */
+  linksSuffix: string;
+  /** Placeholder in the projects folder display: `<имя>` / `<name>`. */
+  namePlaceholder: string;
+  /** `{bits}` and `{path}` placeholders. */
+  truncatedMarker: string;
+  memoryLabel: string;
+  canonLabel: string;
+  /** `{parts}` placeholder. */
+  projectsTrimmed: string;
+  /** `{n}` and `{cap}` placeholders. */
+  pendingPhases: string;
+  /** `{n}` and `{cap}` placeholders. */
+  overHardCap: string;
+};
+
+export type TaxonomyPreset = {
+  locale: LocaleId;
+  folders: TaxonomyFolders;
+  types: TaxonomyTypes;
+  subtypes: TaxonomySubtypes;
+  /** Subtype render order in author indexes (visual grouping). */
+  subtypeOrder: string[];
+  statuses: TaxonomyStatuses;
+  statusTokens: TaxonomyStatusTokens;
+  /** Phase status tokens in their project-group render order:
+   *  planned → active → paused → completed → cancelled. */
+  phaseStatusOrder: string[];
+  indexStrings: TaxonomyIndexStrings;
+  /** Links-section heading, e.g. `## Links` / `## Связи`. */
+  linksSection: string;
+  projectFiles: TaxonomyProjectFiles;
+  systemFiles: TaxonomySystemFiles;
+};
+
+/** EN base — public nomenclature accepted by ADR-011. */
+export const TAXONOMY_EN: TaxonomyPreset = {
+  locale: "en",
+  folders: {
+    inbox: "00_Inbox",
+    inboxHuman: "00_Inbox_Human",
+    knowledge: "01_Knowledge",
+    decisions: "02_Decisions",
+    projects: "03_Projects",
+    ideas: "04_Ideas",
+    lists: "05_Lists",
+    agentMemory: "06_Agent_Memory",
+    archive: "07_Archive",
+    system: "99_System",
+  },
+  types: {
+    knowledge: "knowledge",
+    decision: "decision",
+    idea: "idea",
+    project: "project",
+    list: "list",
+    agentMemory: "agent_memory",
+  },
+  subtypes: {
+    feedback: "feedback",
+    context: "context",
+    reference: "reference",
+    personProfile: "person_profile",
+    pitfall: "pitfall",
+  },
+  subtypeOrder: ["feedback", "context", "reference", "person_profile", "pitfall"],
+  statuses: {
+    active: ["current", "active", "accepted", "new", "in_progress"],
+    pending: ["draft", "planned", "paused"],
+    stale: ["outdated", "superseded", "dropped", "completed", "cancelled"],
+  },
+  statusTokens: { draft: "draft", current: "current" },
+  phaseStatusOrder: ["planned", "active", "paused", "completed", "cancelled"],
+  indexStrings: {
+    header: "Vault index of notes by",
+    generatedComment: "<!-- Generated by iapeer-memory index-render. Do not edit manually. -->",
+    sections: {
+      agentMemory: "Agent memory",
+      knowledge: "Knowledge",
+      decisions: "Decisions",
+      projects: "Projects",
+      ideas: "Ideas",
+      lists: "Lists",
+    },
+    emptySection: "_(no notes of this type yet)_",
+    linksSuffix: "links",
+    namePlaceholder: "<name>",
+    truncatedMarker: "_Index truncated: {bits}. Full uncapped list — `Read {path}`._",
+    memoryLabel: "memory",
+    canonLabel: "canon",
+    projectsTrimmed: "projects: trimmed {parts}",
+    pendingPhases: "{n} PENDING phases (section > {cap})",
+    overHardCap: "{n} over the {cap} limit",
+  },
+  linksSection: "## Links",
+  projectFiles: {
+    overviewPrefix: "Overview ",
+    planPrefix: "Plan ",
+    phasePrefix: "Phase — ",
+  },
+  systemFiles: {
+    draftTemplate: "Templates/Draft.md",
+    tagsDictionary: "Tags.md",
+  },
+};
+
+/**
+ * RU preset — the live MergeMind vault taxonomy (frozen reference, ADR-002).
+ * Values are verbatim from the reference `src/` constants and
+ * `docs/01-vault-layout.md`; migration parity runs against this preset.
+ */
+export const TAXONOMY_RU: TaxonomyPreset = {
+  locale: "ru",
+  folders: {
+    inbox: "00_Входящие",
+    inboxHuman: "00_Входящие_человек",
+    knowledge: "01_Знания",
+    decisions: "02_Решения",
+    projects: "03_Проекты",
+    ideas: "04_Идеи",
+    lists: "05_Списки",
+    agentMemory: "06_Оперативка_агентов",
+    archive: "07_Архив",
+    system: "99_Система",
+  },
+  types: {
+    knowledge: "знание",
+    decision: "решение",
+    idea: "идея",
+    project: "проект",
+    list: "список",
+    agentMemory: "оперативка агентов",
+  },
+  subtypes: {
+    feedback: "обратная_связь",
+    context: "контекст",
+    reference: "справка",
+    personProfile: "профиль_человека",
+    pitfall: "грабли",
+  },
+  subtypeOrder: ["обратная_связь", "контекст", "справка", "профиль_человека", "грабли"],
+  statuses: {
+    // RU carries gendered/inflected duplicates the EN base collapses
+    // (активный/активная → active; завершён/завершена → completed).
+    active: ["актуально", "активный", "активная", "принято", "новая", "реализуется"],
+    pending: ["черновик", "запланирована", "на паузе"],
+    stale: ["устарело", "заменено", "отброшена", "завершён", "завершена", "отменена"],
+  },
+  statusTokens: { draft: "черновик", current: "актуально" },
+  phaseStatusOrder: ["запланирована", "активная", "на паузе", "завершена", "отменена"],
+  indexStrings: {
+    header: "Vault-индекс заметок автора",
+    generatedComment: "<!-- Сгенерировано iapeer-memory index-render. Не править вручную. -->",
+    sections: {
+      agentMemory: "Оперативка агентов",
+      knowledge: "Знания",
+      decisions: "Решения",
+      projects: "Проекты",
+      ideas: "Идеи",
+      lists: "Списки",
+    },
+    emptySection: "_(пока нет твоих заметок этого типа)_",
+    linksSuffix: "св.",
+    namePlaceholder: "<имя>",
+    truncatedMarker: "_Индекс обрезан: {bits}. Полный список заметок (без cap'а) — `Read {path}`._",
+    memoryLabel: "оперативка",
+    canonLabel: "канон",
+    projectsTrimmed: "проекты: отрезано {parts}",
+    pendingPhases: "{n} PENDING-фаз (секция > {cap})",
+    overHardCap: "{n} сверх лимита {cap}",
+  },
+  linksSection: "## Связи",
+  projectFiles: {
+    overviewPrefix: "Описание ",
+    planPrefix: "План ",
+    phasePrefix: "Фаза — ",
+  },
+  systemFiles: {
+    draftTemplate: "Шаблоны/Черновик.md",
+    tagsDictionary: "Теги.md",
+  },
+};
+
+const PRESETS: Record<LocaleId, TaxonomyPreset> = {
+  en: TAXONOMY_EN,
+  ru: TAXONOMY_RU,
+};
+
+export function getTaxonomy(locale: LocaleId): TaxonomyPreset {
+  return PRESETS[locale];
+}
+
+export function isLocaleId(value: string): value is LocaleId {
+  return value === "en" || value === "ru";
+}
+
+/**
+ * Path prefix for the agent-memory zone (`06_Agent_Memory/<name>/...`).
+ * Used by both the foreign-memory score penalty (search) and the one-way
+ * graph filter (mcp-tools). One derived value for both call sites.
+ *
+ * DB paths are stored without a leading slash, so the marker has none.
+ * The trailing slash is load-bearing: a note named
+ * `06_Agent_Memory_README.md` must NOT be classified as agent memory.
+ */
+export function agentMemoryFolderMarker(taxonomy: TaxonomyPreset): string {
+  return `${taxonomy.folders.agentMemory}/`;
+}
+
+/**
+ * Status → lifecycle group lookup. Returns null for unknown statuses
+ * (no boost / no penalty — neutral, mirrors the reference behaviour where
+ * an unknown status falls through all three Set checks).
+ */
+export function statusGroup(
+  taxonomy: TaxonomyPreset,
+  status: string,
+): StatusGroup | null {
+  if (taxonomy.statuses.active.includes(status)) return "active";
+  if (taxonomy.statuses.pending.includes(status)) return "pending";
+  if (taxonomy.statuses.stale.includes(status)) return "stale";
+  return null;
+}
+
+/**
+ * Default search-index exclusions: both inboxes (raw drafts, possibly without
+ * frontmatter) and the system folder (templates/dictionary, not content).
+ * The archive is NOT excluded — it stays searchable with the stale boost.
+ */
+export function defaultExcludeFolders(taxonomy: TaxonomyPreset): string[] {
+  return [
+    taxonomy.folders.inbox,
+    taxonomy.folders.inboxHuman,
+    taxonomy.folders.system,
+  ];
+}
+
+/**
+ * Regex matching a body that STARTS with the links section, mirroring the
+ * reference parser semantics: `\b` is ASCII-only in JS, useless after a
+ * cyrillic heading, so the pattern uses `(?:\s|$)` explicitly.
+ */
+export function linksSectionPattern(taxonomy: TaxonomyPreset): RegExp {
+  const escaped = taxonomy.linksSection.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^${escaped}(?:\\s|$)`);
+}
+
+/**
+ * Ranking coefficients — locale-independent tuning config (ADR-002).
+ * Defaults are verbatim from the reference `search.ts`.
+ */
+export type RankingConfig = {
+  activeBoost: number;
+  pendingPenalty: number;
+  stalePenalty: number;
+  /** Foreign agent-memory penalty (×0.7) — `docs/03-operatives.md`. */
+  foreignAgentMemoryPenalty: number;
+  /** 1-hop graph-expand neighbour penalty. */
+  graphExpandPenalty: number;
+  /** Incoming-wikilink count from which a note counts as a hub. */
+  backlinkHubThreshold: number;
+  backlinkHubBoost: number;
+};
+
+export const DEFAULT_RANKING: RankingConfig = {
+  activeBoost: 1.2,
+  pendingPenalty: 0.8,
+  stalePenalty: 0.5,
+  foreignAgentMemoryPenalty: 0.7,
+  graphExpandPenalty: 0.4,
+  backlinkHubThreshold: 5,
+  backlinkHubBoost: 1.15,
+};
+
+/**
+ * Curator set (ADR-006): personalities whose edits are sanctioned curation —
+ * the post-write hook does NOT stamp `needs_review` for them, and zone
+ * validation accepts their edits on foreign notes within a task. Replaces the
+ * reference hard-coded `agent != "index"` rule. Config, not a constant: the
+ * set is extendable per deployment.
+ */
+export const DEFAULT_CURATOR_SET: readonly string[] = [
+  "index",
+  "copywriter",
+  "dreamweaver",
+];