@remnic/core 1.1.12 → 1.1.13

package/dist/chunk-MY6TPVXW.js

@@ -0,0 +1,219 @@
+import {
+  countRecallTokenOverlap,
+  normalizeRecallTokens
+} from "./chunk-DT5TVLJE.js";
+import {
+  assertIsoRecordedAt,
+  assertSafePathSegment,
+  assertString,
+  isRecord,
+  optionalString,
+  optionalStringArray,
+  recordStoreDay,
+  validateStringRecord
+} from "./chunk-DGXUHMOV.js";
+import {
+  listJsonFiles,
+  readJsonFile
+} from "./chunk-LPSF4OQH.js";
+
+// src/causal-trajectory.ts
+import path from "path";
+import { mkdir, writeFile } from "fs/promises";
+function validateMetadata(raw) {
+  return validateStringRecord(raw, "metadata");
+}
+function resolveCausalTrajectoryStoreDir(memoryDir, overrideDir) {
+  if (typeof overrideDir === "string" && overrideDir.trim().length > 0) {
+    return overrideDir.trim();
+  }
+  return path.join(memoryDir, "state", "causal-trajectories");
+}
+function validateCausalTrajectoryRecord(raw) {
+  if (!isRecord(raw)) throw new Error("causal trajectory record must be an object");
+  if (raw.schemaVersion !== 1) throw new Error("schemaVersion must be 1");
+  const outcomeKind = assertString(raw.outcomeKind, "outcomeKind");
+  if (!["success", "failure", "partial", "unknown"].includes(outcomeKind)) {
+    throw new Error("outcomeKind must be one of success|failure|partial|unknown");
+  }
+  return {
+    schemaVersion: 1,
+    trajectoryId: assertSafePathSegment(assertString(raw.trajectoryId, "trajectoryId"), "trajectoryId"),
+    recordedAt: assertIsoRecordedAt(assertString(raw.recordedAt, "recordedAt")),
+    sessionKey: assertString(raw.sessionKey, "sessionKey"),
+    goal: assertString(raw.goal, "goal"),
+    actionSummary: assertString(raw.actionSummary, "actionSummary"),
+    observationSummary: assertString(raw.observationSummary, "observationSummary"),
+    outcomeKind,
+    outcomeSummary: assertString(raw.outcomeSummary, "outcomeSummary"),
+    followUpSummary: optionalString(raw.followUpSummary),
+    objectiveStateSnapshotRefs: optionalStringArray(raw.objectiveStateSnapshotRefs, "objectiveStateSnapshotRefs"),
+    entityRefs: optionalStringArray(raw.entityRefs, "entityRefs"),
+    tags: optionalStringArray(raw.tags, "tags"),
+    metadata: validateMetadata(raw.metadata)
+  };
+}
+async function recordCausalTrajectory(options) {
+  const rootDir = resolveCausalTrajectoryStoreDir(options.memoryDir, options.causalTrajectoryStoreDir);
+  const validated = validateCausalTrajectoryRecord(options.record);
+  const day = recordStoreDay(validated.recordedAt);
+  const trajectoriesDir = path.join(rootDir, "trajectories", day);
+  const filePath = path.join(trajectoriesDir, `${validated.trajectoryId}.json`);
+  await mkdir(trajectoriesDir, { recursive: true });
+  await writeFile(filePath, JSON.stringify(validated, null, 2), "utf8");
+  if (options.actionGraphRecallEnabled === true) {
+    try {
+      const { appendCausalTrajectoryGraphEdges } = await import("./causal-trajectory-graph.js");
+      await appendCausalTrajectoryGraphEdges({
+        memoryDir: options.memoryDir,
+        record: validated
+      });
+    } catch (error) {
+      const { log } = await import("./logger.js");
+      log.warn(
+        `[causal-trajectory] action-conditioned graph write failed for ${validated.trajectoryId}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  if (options.cmcEnabled === true) {
+    try {
+      const { stitchCausalChain } = await import("./causal-chain.js");
+      await stitchCausalChain({
+        memoryDir: options.memoryDir,
+        causalTrajectoryStoreDir: options.causalTrajectoryStoreDir,
+        newTrajectory: validated,
+        config: {
+          lookbackDays: options.cmcStitchLookbackDays ?? 7,
+          minScore: options.cmcStitchMinScore ?? 2.5,
+          maxEdgesPerTrajectory: options.cmcStitchMaxEdgesPerTrajectory ?? 3
+        }
+      });
+    } catch (error) {
+      const { log } = await import("./logger.js");
+      log.warn(
+        `[cmc] causal chain stitching failed for ${validated.trajectoryId}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return filePath;
+}
+async function readCausalTrajectoryRecords(options) {
+  const rootDir = resolveCausalTrajectoryStoreDir(options.memoryDir, options.causalTrajectoryStoreDir);
+  const files = await listJsonFiles(path.join(rootDir, "trajectories"));
+  const trajectories = [];
+  const invalidTrajectories = [];
+  for (const filePath of files) {
+    try {
+      trajectories.push(validateCausalTrajectoryRecord(await readJsonFile(filePath)));
+    } catch (error) {
+      invalidTrajectories.push({
+        path: filePath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return { files, trajectories, invalidTrajectories };
+}
+function filterTrajectoriesByLookbackDays(trajectories, lookbackDays, nowMs = Date.now()) {
+  const days = Math.max(1, Math.floor(lookbackDays));
+  const cutoff = nowMs - days * 864e5;
+  return trajectories.filter((t) => {
+    const ms = Date.parse(t.recordedAt);
+    return Number.isFinite(ms) && ms >= cutoff;
+  });
+}
+async function getCausalTrajectoryStoreStatus(options) {
+  const rootDir = resolveCausalTrajectoryStoreDir(options.memoryDir, options.causalTrajectoryStoreDir);
+  const trajectoriesDir = path.join(rootDir, "trajectories");
+  const { files, trajectories, invalidTrajectories } = await readCausalTrajectoryRecords(options);
+  trajectories.sort((a, b) => b.recordedAt.localeCompare(a.recordedAt));
+  const byOutcome = {};
+  for (const trajectory of trajectories) {
+    byOutcome[trajectory.outcomeKind] = (byOutcome[trajectory.outcomeKind] ?? 0) + 1;
+  }
+  return {
+    enabled: options.enabled,
+    rootDir,
+    trajectoriesDir,
+    trajectories: {
+      total: files.length,
+      valid: trajectories.length,
+      invalid: invalidTrajectories.length,
+      byOutcome,
+      latestTrajectoryId: trajectories[0]?.trajectoryId,
+      latestRecordedAt: trajectories[0]?.recordedAt,
+      latestSessionKey: trajectories[0]?.sessionKey
+    },
+    latestTrajectory: trajectories[0],
+    invalidTrajectories
+  };
+}
+function lexicalScoreCausalTrajectoryRecord(record, queryTokens) {
+  const weightedFields = [
+    ["goal", record.goal, 4],
+    ["action", record.actionSummary, 3],
+    ["observation", record.observationSummary, 3],
+    ["outcome", record.outcomeSummary, 3],
+    ["follow_up", record.followUpSummary, 2],
+    ["outcome_kind", record.outcomeKind, 1],
+    ["tags", record.tags?.join(" "), 2],
+    ["entity_refs", record.entityRefs?.join(" "), 2],
+    ["objective_state_refs", record.objectiveStateSnapshotRefs?.join(" "), 1]
+  ];
+  let score = 0;
+  const matchedFields = [];
+  for (const [field, value, weight] of weightedFields) {
+    const matches = countRecallTokenOverlap(queryTokens, value, ["make"]);
+    if (matches > 0) matchedFields.push(field);
+    score += matches * weight;
+  }
+  return { score, matchedFields };
+}
+function scoreCausalTrajectoryRecord(record, lexicalScore, sessionKey) {
+  let score = lexicalScore;
+  if (sessionKey && record.sessionKey === sessionKey) score += 1.5;
+  const recordedAtMs = Date.parse(record.recordedAt);
+  if (Number.isFinite(recordedAtMs)) {
+    const ageHours = Math.max(0, (Date.now() - recordedAtMs) / 36e5);
+    score += 1 / (1 + ageHours);
+  }
+  return score;
+}
+async function searchCausalTrajectories(options) {
+  const maxResults = Math.max(0, Math.floor(options.maxResults));
+  if (maxResults === 0) return [];
+  const { trajectories } = await readCausalTrajectoryRecords(options);
+  if (trajectories.length === 0) return [];
+  const queryTokens = new Set(normalizeRecallTokens(options.query, ["make"]));
+  if (queryTokens.size === 0) return [];
+  const scored = trajectories.map((record) => {
+    const lexical = lexicalScoreCausalTrajectoryRecord(record, queryTokens);
+    return {
+      record,
+      matchedFields: lexical.matchedFields,
+      lexicalScore: lexical.score,
+      score: scoreCausalTrajectoryRecord(record, lexical.score, options.sessionKey)
+    };
+  });
+  const filtered = scored.filter((result) => result.lexicalScore > 0);
+  filtered.sort((left, right) => {
+    if (right.score !== left.score) return right.score - left.score;
+    return right.record.recordedAt.localeCompare(left.record.recordedAt);
+  });
+  return filtered.slice(0, maxResults).map(({ record, score, matchedFields }) => ({
+    record,
+    score,
+    matchedFields
+  }));
+}
+
+export {
+  resolveCausalTrajectoryStoreDir,
+  validateCausalTrajectoryRecord,
+  recordCausalTrajectory,
+  readCausalTrajectoryRecords,
+  filterTrajectoriesByLookbackDays,
+  getCausalTrajectoryStoreStatus,
+  searchCausalTrajectories
+};
+//# sourceMappingURL=chunk-MY6TPVXW.js.map

package/dist/chunk-N2D6GXBM.js

@@ -0,0 +1,267 @@
+// src/enrichment/types.ts
+function defaultEnrichmentPipelineConfig() {
+  return {
+    enabled: false,
+    providers: [],
+    importanceThresholds: {
+      critical: [],
+      high: [],
+      normal: [],
+      low: []
+    },
+    maxCandidatesPerEntity: 20,
+    autoEnrichOnCreate: false,
+    scheduleIntervalMs: 36e5
+  };
+}
+
+// src/enrichment/provider-registry.ts
+var EnrichmentProviderRegistry = class {
+  providers = /* @__PURE__ */ new Map();
+  /** Register a provider. Overwrites any existing provider with the same id. */
+  register(provider) {
+    this.providers.set(provider.id, provider);
+  }
+  /** Look up a single provider by id. */
+  get(id) {
+    return this.providers.get(id);
+  }
+  /**
+   * Return all registered providers whose id appears in the config's
+   * `providers` list with `enabled: true`.
+   */
+  listEnabled(config) {
+    const enabledIds = new Set(
+      config.providers.filter((p) => p.enabled).map((p) => p.id)
+    );
+    const result = [];
+    for (const [id, provider] of this.providers.entries()) {
+      if (enabledIds.has(id)) {
+        result.push(provider);
+      }
+    }
+    return result;
+  }
+  /**
+   * Return providers that should run for a given importance level.
+   * Providers are resolved from `config.importanceThresholds[level]` and
+   * filtered to only those that are both registered and enabled.
+   */
+  getForImportance(level, config) {
+    if (level === "trivial") return [];
+    const thresholds = config.importanceThresholds;
+    const providerIds = level === "critical" ? thresholds.critical : level === "high" ? thresholds.high : level === "normal" ? thresholds.normal : thresholds.low;
+    const enabledIds = new Set(
+      config.providers.filter((p) => p.enabled).map((p) => p.id)
+    );
+    const result = [];
+    for (const id of providerIds) {
+      if (!enabledIds.has(id)) continue;
+      const provider = this.providers.get(id);
+      if (provider) {
+        result.push(provider);
+      }
+    }
+    return result;
+  }
+};
+
+// src/enrichment/web-search-provider.ts
+var WebSearchProvider = class {
+  id = "web-search";
+  costTier = "cheap";
+  searchFn;
+  constructor(options = {}) {
+    this.searchFn = options.searchFn;
+  }
+  async isAvailable() {
+    return this.searchFn !== void 0;
+  }
+  async enrich(entity) {
+    if (!this.searchFn) return [];
+    const query = `${entity.name} ${entity.type}`;
+    let snippets;
+    try {
+      snippets = await this.searchFn(query);
+    } catch {
+      return [];
+    }
+    return snippets.filter((s) => typeof s === "string" && s.trim().length > 0).map((snippet) => ({
+      text: snippet.trim(),
+      source: this.id,
+      sourceUrl: void 0,
+      confidence: 0.5,
+      category: "fact",
+      tags: ["web-search"]
+    }));
+  }
+};
+
+// src/enrichment/pipeline.ts
+function isRateLimited(provider, config, buckets) {
+  const providerCfg = config.providers.find((p) => p.id === provider.id);
+  if (!providerCfg?.rateLimit) return false;
+  const now = Date.now();
+  let bucket = buckets.get(provider.id);
+  if (!bucket) {
+    bucket = {
+      minuteCount: 0,
+      minuteReset: now + 6e4,
+      dayCount: 0,
+      dayReset: now + 864e5
+    };
+    buckets.set(provider.id, bucket);
+  }
+  if (now >= bucket.minuteReset) {
+    bucket.minuteCount = 0;
+    bucket.minuteReset = now + 6e4;
+  }
+  if (now >= bucket.dayReset) {
+    bucket.dayCount = 0;
+    bucket.dayReset = now + 864e5;
+  }
+  const { maxPerMinute, maxPerDay } = providerCfg.rateLimit;
+  return bucket.minuteCount >= maxPerMinute || bucket.dayCount >= maxPerDay;
+}
+function recordCall(providerId, buckets) {
+  const bucket = buckets.get(providerId);
+  if (bucket) {
+    bucket.minuteCount += 1;
+    bucket.dayCount += 1;
+  }
+}
+async function runEnrichmentPipeline(entities, registry, config, log) {
+  if (!config.enabled) return [];
+  if (entities.length === 0) return [];
+  const rateBuckets = /* @__PURE__ */ new Map();
+  const results = [];
+  for (const entity of entities) {
+    const providers = registry.getForImportance(entity.importanceLevel, config);
+    for (const provider of providers) {
+      const start = Date.now();
+      let available;
+      try {
+        available = await provider.isAvailable();
+      } catch {
+        available = false;
+      }
+      if (!available) {
+        log.debug?.(
+          `enrichment: skipping provider ${provider.id} for ${entity.name} \u2014 unavailable`
+        );
+        results.push({
+          entityName: entity.name,
+          provider: provider.id,
+          candidatesFound: 0,
+          candidatesAccepted: 0,
+          candidatesRejected: 0,
+          acceptedCandidates: [],
+          elapsed: Date.now() - start
+        });
+        continue;
+      }
+      if (isRateLimited(provider, config, rateBuckets)) {
+        log.debug?.(
+          `enrichment: skipping provider ${provider.id} for ${entity.name} \u2014 rate limited`
+        );
+        results.push({
+          entityName: entity.name,
+          provider: provider.id,
+          candidatesFound: 0,
+          candidatesAccepted: 0,
+          candidatesRejected: 0,
+          acceptedCandidates: [],
+          elapsed: Date.now() - start
+        });
+        continue;
+      }
+      let candidates;
+      try {
+        candidates = await provider.enrich(entity);
+      } catch (err) {
+        recordCall(provider.id, rateBuckets);
+        log.error?.(
+          `enrichment: provider ${provider.id} failed for ${entity.name}: ${err instanceof Error ? err.message : String(err)}`
+        );
+        results.push({
+          entityName: entity.name,
+          provider: provider.id,
+          candidatesFound: 0,
+          candidatesAccepted: 0,
+          candidatesRejected: 0,
+          acceptedCandidates: [],
+          elapsed: Date.now() - start
+        });
+        continue;
+      }
+      recordCall(provider.id, rateBuckets);
+      for (const candidate of candidates) {
+        candidate.source = provider.id;
+      }
+      const maxCandidates = config.maxCandidatesPerEntity;
+      let accepted;
+      if (maxCandidates === 0) {
+        accepted = [];
+      } else if (maxCandidates > 0 && candidates.length > maxCandidates) {
+        accepted = candidates.slice(0, maxCandidates);
+      } else {
+        accepted = candidates;
+      }
+      const rejected = candidates.length - accepted.length;
+      results.push({
+        entityName: entity.name,
+        provider: provider.id,
+        candidatesFound: candidates.length,
+        candidatesAccepted: accepted.length,
+        candidatesRejected: rejected,
+        acceptedCandidates: accepted,
+        elapsed: Date.now() - start
+      });
+    }
+  }
+  return results;
+}
+
+// src/enrichment/audit.ts
+import { mkdir, readFile, appendFile } from "fs/promises";
+import { existsSync } from "fs";
+import path from "path";
+var AUDIT_FILENAME = "enrichment-audit.jsonl";
+function auditFilePath(auditDir) {
+  return path.join(auditDir, AUDIT_FILENAME);
+}
+async function appendAuditEntry(auditDir, entry) {
+  await mkdir(auditDir, { recursive: true });
+  const line = JSON.stringify(entry) + "\n";
+  await appendFile(auditFilePath(auditDir), line, "utf-8");
+}
+async function readAuditLog(auditDir, since) {
+  const filePath = auditFilePath(auditDir);
+  if (!existsSync(filePath)) return [];
+  const raw = await readFile(filePath, "utf-8");
+  const entries = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (typeof parsed === "object" && parsed !== null && "timestamp" in parsed && "entityName" in parsed) {
+        const entry = parsed;
+        if (since && entry.timestamp < since) continue;
+        entries.push(entry);
+      }
+    } catch {
+    }
+  }
+  return entries;
+}
+
+export {
+  defaultEnrichmentPipelineConfig,
+  EnrichmentProviderRegistry,
+  WebSearchProvider,
+  runEnrichmentPipeline,
+  appendAuditEntry,
+  readAuditLog
+};
+//# sourceMappingURL=chunk-N2D6GXBM.js.map

package/dist/chunk-N2D6GXBM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/enrichment/types.ts","../src/enrichment/provider-registry.ts","../src/enrichment/web-search-provider.ts","../src/enrichment/pipeline.ts","../src/enrichment/audit.ts"],"sourcesContent":["/**\n * Enrichment pipeline types (issue #365).\n *\n * Defines the provider interface, candidate shape, pipeline config,\n * and result types for the external enrichment subsystem.\n */\n\nimport type { ImportanceLevel, MemoryCategory } from \"../types.js\";\n\n// ---------------------------------------------------------------------------\n// Provider config & interface\n// ---------------------------------------------------------------------------\n\nexport type EnrichmentCostTier = \"free\" | \"cheap\" | \"expensive\";\n\nexport interface EnrichmentProviderConfig {\n  id: string;\n  enabled: boolean;\n  costTier: EnrichmentCostTier;\n  rateLimit?: { maxPerMinute: number; maxPerDay: number };\n}\n\nexport interface EnrichmentCandidate {\n  text: string;\n  source: string;\n  sourceUrl?: string;\n  confidence: number;\n  category: MemoryCategory;\n  tags?: string[];\n}\n\nexport interface EnrichmentProvider {\n  readonly id: string;\n  readonly costTier: EnrichmentCostTier;\n  enrich(entity: EntityEnrichmentInput): Promise<EnrichmentCandidate[]>;\n  isAvailable(): Promise<boolean>;\n}\n\n// ---------------------------------------------------------------------------\n// Entity enrichment input\n// ---------------------------------------------------------------------------\n\nexport interface EntityEnrichmentInput {\n  name: string;\n  type: string;\n  knownFacts: string[];\n  importanceLevel: ImportanceLevel;\n}\n\n// ---------------------------------------------------------------------------\n// Pipeline result\n// ---------------------------------------------------------------------------\n\nexport interface EnrichmentResult {\n  entityName: string;\n  provider: string;\n  candidatesFound: number;\n  candidatesAccepted: number;\n  candidatesRejected: number;\n  acceptedCandidates: EnrichmentCandidate[];\n  elapsed: number;\n}\n\n// ---------------------------------------------------------------------------\n// Pipeline config\n// ---------------------------------------------------------------------------\n\nexport interface EnrichmentPipelineConfig {\n  enabled: boolean;\n  providers: EnrichmentProviderConfig[];\n  importanceThresholds: {\n    critical: string[];\n    high: string[];\n    normal: string[];\n    low: string[];\n  };\n  maxCandidatesPerEntity: number;\n  autoEnrichOnCreate: boolean;\n  scheduleIntervalMs: number;\n}\n\n/**\n * Build a default (disabled) pipeline config. Every consumer that needs a\n * config object should call this rather than duplicating the defaults.\n */\nexport function defaultEnrichmentPipelineConfig(): EnrichmentPipelineConfig {\n  return {\n    enabled: false,\n    providers: [],\n    importanceThresholds: {\n      critical: [],\n      high: [],\n      normal: [],\n      low: [],\n    },\n    maxCandidatesPerEntity: 20,\n    autoEnrichOnCreate: false,\n    scheduleIntervalMs: 3_600_000,\n  };\n}\n","/**\n * Enrichment provider registry (issue #365).\n *\n * Central registry for enrichment providers. Providers register themselves\n * at startup; the pipeline queries the registry to determine which providers\n * to run for a given importance tier.\n */\n\nimport type { ImportanceLevel } from \"../types.js\";\nimport type {\n  EnrichmentPipelineConfig,\n  EnrichmentProvider,\n} from \"./types.js\";\n\nexport class EnrichmentProviderRegistry {\n  private readonly providers = new Map<string, EnrichmentProvider>();\n\n  /** Register a provider. Overwrites any existing provider with the same id. */\n  register(provider: EnrichmentProvider): void {\n    this.providers.set(provider.id, provider);\n  }\n\n  /** Look up a single provider by id. */\n  get(id: string): EnrichmentProvider | undefined {\n    return this.providers.get(id);\n  }\n\n  /**\n   * Return all registered providers whose id appears in the config's\n   * `providers` list with `enabled: true`.\n   */\n  listEnabled(config: EnrichmentPipelineConfig): EnrichmentProvider[] {\n    const enabledIds = new Set(\n      config.providers\n        .filter((p) => p.enabled)\n        .map((p) => p.id),\n    );\n    const result: EnrichmentProvider[] = [];\n    for (const [id, provider] of this.providers.entries()) {\n      if (enabledIds.has(id)) {\n        result.push(provider);\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Return providers that should run for a given importance level.\n   * Providers are resolved from `config.importanceThresholds[level]` and\n   * filtered to only those that are both registered and enabled.\n   */\n  getForImportance(\n    level: ImportanceLevel,\n    config: EnrichmentPipelineConfig,\n  ): EnrichmentProvider[] {\n    // \"trivial\" entities never get enrichment providers\n    if (level === \"trivial\") return [];\n\n    const thresholds = config.importanceThresholds;\n    const providerIds: string[] =\n      level === \"critical\"\n        ? thresholds.critical\n        : level === \"high\"\n          ? thresholds.high\n          : level === \"normal\"\n            ? thresholds.normal\n            : thresholds.low;\n\n    const enabledIds = new Set(\n      config.providers\n        .filter((p) => p.enabled)\n        .map((p) => p.id),\n    );\n\n    const result: EnrichmentProvider[] = [];\n    for (const id of providerIds) {\n      if (!enabledIds.has(id)) continue;\n      const provider = this.providers.get(id);\n      if (provider) {\n        result.push(provider);\n      }\n    }\n    return result;\n  }\n}\n","/**\n * Web search enrichment provider stub (issue #365).\n *\n * A basic provider backed by web search. Since this is opt-in and we do not\n * want to hard-code an API key, the provider accepts an optional `searchFn`\n * injection point. When no search function is configured it returns empty\n * results, making it safe to register unconditionally.\n */\n\nimport type {\n  EnrichmentCandidate,\n  EnrichmentCostTier,\n  EnrichmentProvider,\n  EntityEnrichmentInput,\n} from \"./types.js\";\n\nexport type WebSearchFn = (query: string) => Promise<string[]>;\n\nexport interface WebSearchProviderOptions {\n  /**\n   * Injected search function. Each returned string is treated as a raw\n   * snippet. When `undefined` the provider returns empty results.\n   */\n  searchFn?: WebSearchFn;\n}\n\nexport class WebSearchProvider implements EnrichmentProvider {\n  readonly id = \"web-search\";\n  readonly costTier: EnrichmentCostTier = \"cheap\";\n\n  private readonly searchFn: WebSearchFn | undefined;\n\n  constructor(options: WebSearchProviderOptions = {}) {\n    this.searchFn = options.searchFn;\n  }\n\n  async isAvailable(): Promise<boolean> {\n    return this.searchFn !== undefined;\n  }\n\n  async enrich(entity: EntityEnrichmentInput): Promise<EnrichmentCandidate[]> {\n    if (!this.searchFn) return [];\n\n    const query = `${entity.name} ${entity.type}`;\n    let snippets: string[];\n    try {\n      snippets = await this.searchFn(query);\n    } catch {\n      return [];\n    }\n\n    return snippets\n      .filter((s) => typeof s === \"string\" && s.trim().length > 0)\n      .map((snippet) => ({\n        text: snippet.trim(),\n        source: this.id,\n        sourceUrl: undefined,\n        confidence: 0.5,\n        category: \"fact\" as const,\n        tags: [\"web-search\"],\n      }));\n  }\n}\n","/**\n * Enrichment pipeline orchestrator (issue #365).\n *\n * For each entity, determines the importance tier, resolves the providers\n * to run, executes them in sequence (respecting rate limits), tags\n * candidates, and caps at `maxCandidatesPerEntity`.\n *\n * Accepted candidates are returned in each `EnrichmentResult` via the\n * `acceptedCandidates` field so that callers can persist them.\n */\n\nimport type { LoggerBackend } from \"../logger.js\";\nimport type { EnrichmentProviderRegistry } from \"./provider-registry.js\";\nimport type {\n  EnrichmentCandidate,\n  EnrichmentPipelineConfig,\n  EnrichmentProvider,\n  EnrichmentResult,\n  EntityEnrichmentInput,\n} from \"./types.js\";\n\n// ---------------------------------------------------------------------------\n// Rate-limit tracking\n// ---------------------------------------------------------------------------\n\ninterface RateLimitBucket {\n  minuteCount: number;\n  minuteReset: number;\n  dayCount: number;\n  dayReset: number;\n}\n\nfunction isRateLimited(\n  provider: EnrichmentProvider,\n  config: EnrichmentPipelineConfig,\n  buckets: Map<string, RateLimitBucket>,\n): boolean {\n  const providerCfg = config.providers.find((p) => p.id === provider.id);\n  if (!providerCfg?.rateLimit) return false;\n\n  const now = Date.now();\n  let bucket = buckets.get(provider.id);\n  if (!bucket) {\n    bucket = {\n      minuteCount: 0,\n      minuteReset: now + 60_000,\n      dayCount: 0,\n      dayReset: now + 86_400_000,\n    };\n    buckets.set(provider.id, bucket);\n  }\n\n  // Reset windows if expired\n  if (now >= bucket.minuteReset) {\n    bucket.minuteCount = 0;\n    bucket.minuteReset = now + 60_000;\n  }\n  if (now >= bucket.dayReset) {\n    bucket.dayCount = 0;\n    bucket.dayReset = now + 86_400_000;\n  }\n\n  const { maxPerMinute, maxPerDay } = providerCfg.rateLimit;\n  return bucket.minuteCount >= maxPerMinute || bucket.dayCount >= maxPerDay;\n}\n\nfunction recordCall(\n  providerId: string,\n  buckets: Map<string, RateLimitBucket>,\n): void {\n  const bucket = buckets.get(providerId);\n  if (bucket) {\n    bucket.minuteCount += 1;\n    bucket.dayCount += 1;\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Pipeline\n// ---------------------------------------------------------------------------\n\nexport async function runEnrichmentPipeline(\n  entities: EntityEnrichmentInput[],\n  registry: EnrichmentProviderRegistry,\n  config: EnrichmentPipelineConfig,\n  log: LoggerBackend,\n): Promise<EnrichmentResult[]> {\n  if (!config.enabled) return [];\n  if (entities.length === 0) return [];\n\n  const rateBuckets = new Map<string, RateLimitBucket>();\n  const results: EnrichmentResult[] = [];\n\n  for (const entity of entities) {\n    const providers = registry.getForImportance(entity.importanceLevel, config);\n\n    for (const provider of providers) {\n      const start = Date.now();\n\n      // Check availability\n      let available: boolean;\n      try {\n        available = await provider.isAvailable();\n      } catch {\n        available = false;\n      }\n\n      if (!available) {\n        log.debug?.(\n          `enrichment: skipping provider ${provider.id} for ${entity.name} — unavailable`,\n        );\n        results.push({\n          entityName: entity.name,\n          provider: provider.id,\n          candidatesFound: 0,\n          candidatesAccepted: 0,\n          candidatesRejected: 0,\n          acceptedCandidates: [],\n          elapsed: Date.now() - start,\n        });\n        continue;\n      }\n\n      // Check rate limit\n      if (isRateLimited(provider, config, rateBuckets)) {\n        log.debug?.(\n          `enrichment: skipping provider ${provider.id} for ${entity.name} — rate limited`,\n        );\n        results.push({\n          entityName: entity.name,\n          provider: provider.id,\n          candidatesFound: 0,\n          candidatesAccepted: 0,\n          candidatesRejected: 0,\n          acceptedCandidates: [],\n          elapsed: Date.now() - start,\n        });\n        continue;\n      }\n\n      // Run provider.\n      // Count every attempt toward rate-limit buckets — including failures —\n      // because the provider may have consumed external quota before throwing\n      // (PR #425 review finding 2).\n      let candidates: EnrichmentCandidate[];\n      try {\n        candidates = await provider.enrich(entity);\n      } catch (err) {\n        recordCall(provider.id, rateBuckets);\n        log.error?.(\n          `enrichment: provider ${provider.id} failed for ${entity.name}: ${err instanceof Error ? err.message : String(err)}`,\n        );\n        results.push({\n          entityName: entity.name,\n          provider: provider.id,\n          candidatesFound: 0,\n          candidatesAccepted: 0,\n          candidatesRejected: 0,\n          acceptedCandidates: [],\n          elapsed: Date.now() - start,\n        });\n        continue;\n      }\n      recordCall(provider.id, rateBuckets);\n\n      // Tag each candidate with provider id\n      for (const candidate of candidates) {\n        candidate.source = provider.id;\n      }\n\n      // Cap at maxCandidatesPerEntity.\n      // 0 means \"accept none\"; undefined/negative means \"no cap\".\n      const maxCandidates = config.maxCandidatesPerEntity;\n      let accepted: EnrichmentCandidate[];\n      if (maxCandidates === 0) {\n        accepted = [];\n      } else if (maxCandidates > 0 && candidates.length > maxCandidates) {\n        accepted = candidates.slice(0, maxCandidates);\n      } else {\n        accepted = candidates;\n      }\n      const rejected = candidates.length - accepted.length;\n\n      results.push({\n        entityName: entity.name,\n        provider: provider.id,\n        candidatesFound: candidates.length,\n        candidatesAccepted: accepted.length,\n        candidatesRejected: rejected,\n        acceptedCandidates: accepted,\n        elapsed: Date.now() - start,\n      });\n    }\n  }\n\n  return results;\n}\n","/**\n * Enrichment audit trail (issue #365).\n *\n * Append-only JSONL log for every enrichment candidate that was evaluated.\n * Each entry records whether the candidate was accepted or rejected, the\n * provider that produced it, and an optional reason string.\n */\n\nimport { mkdir, readFile, appendFile } from \"node:fs/promises\";\nimport { existsSync } from \"node:fs\";\nimport path from \"node:path\";\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\nexport interface EnrichmentAuditEntry {\n  timestamp: string;\n  entityName: string;\n  provider: string;\n  candidateText: string;\n  sourceUrl?: string;\n  accepted: boolean;\n  reason?: string;\n}\n\n// ---------------------------------------------------------------------------\n// File helpers\n// ---------------------------------------------------------------------------\n\nconst AUDIT_FILENAME = \"enrichment-audit.jsonl\";\n\nfunction auditFilePath(auditDir: string): string {\n  return path.join(auditDir, AUDIT_FILENAME);\n}\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\n/**\n * Append a single audit entry to the JSONL log. Creates the audit directory\n * and file if they do not exist.\n */\nexport async function appendAuditEntry(\n  auditDir: string,\n  entry: EnrichmentAuditEntry,\n): Promise<void> {\n  await mkdir(auditDir, { recursive: true });\n  const line = JSON.stringify(entry) + \"\\n\";\n  await appendFile(auditFilePath(auditDir), line, \"utf-8\");\n}\n\n/**\n * Read the audit log and return entries, optionally filtered to entries at\n * or after `since` (ISO 8601 timestamp, half-open interval).\n */\nexport async function readAuditLog(\n  auditDir: string,\n  since?: string,\n): Promise<EnrichmentAuditEntry[]> {\n  const filePath = auditFilePath(auditDir);\n  if (!existsSync(filePath)) return [];\n\n  const raw = await readFile(filePath, \"utf-8\");\n  const entries: EnrichmentAuditEntry[] = [];\n\n  for (const line of raw.split(\"\\n\")) {\n    const trimmed = line.trim();\n    if (trimmed.length === 0) continue;\n    try {\n      const parsed: unknown = JSON.parse(trimmed);\n      if (\n        typeof parsed === \"object\" &&\n        parsed !== null &&\n        \"timestamp\" in parsed &&\n        \"entityName\" in parsed\n      ) {\n        const entry = parsed as EnrichmentAuditEntry;\n        if (since && entry.timestamp < since) continue;\n        entries.push(entry);\n      }\n    } catch {\n      // Skip malformed lines\n    }\n  }\n\n  return entries;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-NJ3MJQZX.js

@@ -0,0 +1,46 @@
+// src/search/noop-backend.ts
+var NoopSearchBackend = class {
+  async probe() {
+    return false;
+  }
+  isAvailable() {
+    return false;
+  }
+  debugStatus() {
+    return "backend=noop";
+  }
+  async search(_query, _collection, _maxResults, _options, _execution) {
+    return [];
+  }
+  async searchGlobal(_query, _maxResults, _execution) {
+    return [];
+  }
+  async bm25Search(_query, _collection, _maxResults, _execution) {
+    return [];
+  }
+  async vectorSearch(_query, _collection, _maxResults, _execution) {
+    return [];
+  }
+  async hybridSearch(_query, _collection, _maxResults, _execution) {
+    return [];
+  }
+  async update(_execution) {
+  }
+  async updateCollection(_collection, _execution) {
+  }
+  updatesAllCollections() {
+    return false;
+  }
+  async embed() {
+  }
+  async embedCollection(_collection) {
+  }
+  async ensureCollection(_memoryDir) {
+    return "skipped";
+  }
+};
+
+export {
+  NoopSearchBackend
+};
+//# sourceMappingURL=chunk-NJ3MJQZX.js.map

package/dist/chunk-NJ3MJQZX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/search/noop-backend.ts"],"sourcesContent":["import type { SearchBackend, SearchExecutionOptions, SearchQueryOptions, SearchResult } from \"./port.js\";\n\n/**\n * No-op search backend for graceful degradation.\n * All searches return empty results; all maintenance is a no-op.\n */\nexport class NoopSearchBackend implements SearchBackend {\n  async probe(): Promise<boolean> {\n    return false;\n  }\n\n  isAvailable(): boolean {\n    return false;\n  }\n\n  debugStatus(): string {\n    return \"backend=noop\";\n  }\n\n  async search(\n    _query: string,\n    _collection?: string,\n    _maxResults?: number,\n    _options?: SearchQueryOptions,\n    _execution?: SearchExecutionOptions,\n  ): Promise<SearchResult[]> {\n    return [];\n  }\n\n  async searchGlobal(_query: string, _maxResults?: number, _execution?: SearchExecutionOptions): Promise<SearchResult[]> {\n    return [];\n  }\n\n  async bm25Search(_query: string, _collection?: string, _maxResults?: number, _execution?: SearchExecutionOptions): Promise<SearchResult[]> {\n    return [];\n  }\n\n  async vectorSearch(_query: string, _collection?: string, _maxResults?: number, _execution?: SearchExecutionOptions): Promise<SearchResult[]> {\n    return [];\n  }\n\n  async hybridSearch(_query: string, _collection?: string, _maxResults?: number, _execution?: SearchExecutionOptions): Promise<SearchResult[]> {\n    return [];\n  }\n\n  async update(_execution?: SearchExecutionOptions): Promise<void> {}\n  async updateCollection(_collection: string, _execution?: SearchExecutionOptions): Promise<void> {}\n  updatesAllCollections(): boolean {\n    return false;\n  }\n  async embed(): Promise<void> {}\n  async embedCollection(_collection: string): Promise<void> {}\n\n  async ensureCollection(_memoryDir: string): Promise<\"skipped\"> {\n    return \"skipped\";\n  }\n}\n"],"mappings":";AAMO,IAAM,oBAAN,MAAiD;AAAA,EACtD,MAAM,QAA0B;AAC9B,WAAO;AAAA,EACT;AAAA,EAEA,cAAuB;AACrB,WAAO;AAAA,EACT;AAAA,EAEA,cAAsB;AACpB,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,OACJ,QACA,aACA,aACA,UACA,YACyB;AACzB,WAAO,CAAC;AAAA,EACV;AAAA,EAEA,MAAM,aAAa,QAAgB,aAAsB,YAA8D;AACrH,WAAO,CAAC;AAAA,EACV;AAAA,EAEA,MAAM,WAAW,QAAgB,aAAsB,aAAsB,YAA8D;AACzI,WAAO,CAAC;AAAA,EACV;AAAA,EAEA,MAAM,aAAa,QAAgB,aAAsB,aAAsB,YAA8D;AAC3I,WAAO,CAAC;AAAA,EACV;AAAA,EAEA,MAAM,aAAa,QAAgB,aAAsB,aAAsB,YAA8D;AAC3I,WAAO,CAAC;AAAA,EACV;AAAA,EAEA,MAAM,OAAO,YAAoD;AAAA,EAAC;AAAA,EAClE,MAAM,iBAAiB,aAAqB,YAAoD;AAAA,EAAC;AAAA,EACjG,wBAAiC;AAC/B,WAAO;AAAA,EACT;AAAA,EACA,MAAM,QAAuB;AAAA,EAAC;AAAA,EAC9B,MAAM,gBAAgB,aAAoC;AAAA,EAAC;AAAA,EAE3D,MAAM,iBAAiB,YAAwC;AAC7D,WAAO;AAAA,EACT;AACF;","names":[]}