@remnic/core 9.69.50 → 9.69.52

package/dist/{chunk-OLJYDGGP.js → chunk-UVZBDIJX.js}

@@ -16,14 +16,14 @@ import {
   normalizeActionIntent,
   sanitizePayloadString
 } from "./chunk-IWO6QXWJ.js";
+import {
+  parseSubjectRuntimeConfig
+} from "./chunk-WIKO4SCR.js";
 import {
   parseRecallStandingBlock,
   parseStandingBlockFreshDays,
   parseStandingBlockMaxChars
 } from "./chunk-LI4APB6M.js";
-import {
-  parseSubjectRuntimeConfig
-} from "./chunk-WIKO4SCR.js";
 import {
   cloneDefaultSessionObserverBands
 } from "./chunk-Z5LAYHGJ.js";
@@ -111,18 +111,30 @@ import {
 import {
   normalizeEntitySchemas
 } from "./chunk-ZIKENA2C.js";
+import {
+  normalizeRecallTokens
+} from "./chunk-YCVB7X56.js";
 import {
   coerceBool,
   coerceBooleanLike,
   coerceInstallExtension,
   coerceNumber
 } from "./chunk-PQVCH2AE.js";
+import {
+  STRUCTURED_ATTRIBUTE_LIMITS
+} from "./chunk-GDYU6VF4.js";
 import {
   parseConvergeConfig
 } from "./chunk-6MINUTGJ.js";
 import {
   isActiveMemoryStatus
 } from "./chunk-7RJUVTVF.js";
+import {
+  excludeSupportPassportPrivateMemories
+} from "./chunk-PWPIERBM.js";
+import {
+  stripAttributesSuffix
+} from "./chunk-JDSVLVCG.js";
 import {
   sanitizeMemoryContent
 } from "./chunk-5GKPFL3S.js";
@@ -323,6 +335,201 @@ function parseSessionExperienceConfig(raw) {
   };
 }
 
+// src/lifecycle/seed-graduation.ts
+var SEED_GRADUATION_DEFAULTS = {
+  enabled: false,
+  minCorroborations: 2
+};
+var SEED_GRADUATION_MAX_CORROBORATIONS = 50;
+var BOOLEAN_LIKE = {
+  true: true,
+  "1": true,
+  yes: true,
+  on: true,
+  false: false,
+  "0": false,
+  no: false,
+  off: false
+};
+function parseFlag3(src, key, fallback) {
+  const raw = src[key];
+  if (raw === void 0 || raw === null) return fallback;
+  if (typeof raw === "boolean") return raw;
+  const coerced = BOOLEAN_LIKE[String(raw).toLowerCase()];
+  if (coerced === void 0) {
+    throw new Error(
+      `seedGraduation.${key} must be a boolean or one of "true"/"false"/"1"/"0"/"yes"/"no"/"on"/"off" (got ${JSON.stringify(raw)}).`
+    );
+  }
+  return coerced;
+}
+function parseSeedGraduationConfig(raw) {
+  if (raw === void 0 || raw === null) return { ...SEED_GRADUATION_DEFAULTS };
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(
+      `seedGraduation must be an object (got ${JSON.stringify(raw)}). Omit the key to keep seed graduation disabled (issue #2974).`
+    );
+  }
+  const src = raw;
+  const rawMin = src.minCorroborations;
+  let minCorroborations = SEED_GRADUATION_DEFAULTS.minCorroborations;
+  if (rawMin !== void 0 && rawMin !== null) {
+    const n = typeof rawMin === "number" ? rawMin : Number(rawMin);
+    if (!Number.isInteger(n) || n < 1 || n > SEED_GRADUATION_MAX_CORROBORATIONS) {
+      throw new Error(
+        `seedGraduation.minCorroborations must be an integer in [1, ${SEED_GRADUATION_MAX_CORROBORATIONS}] (got ${JSON.stringify(rawMin)}). Use enabled: false to disable graduation.`
+      );
+    }
+    minCorroborations = n;
+  }
+  return {
+    enabled: parseFlag3(src, "enabled", SEED_GRADUATION_DEFAULTS.enabled),
+    minCorroborations
+  };
+}
+var SEED_CORROBORATION_COVERAGE = 0.7;
+var MIN_SEED_TOKENS = 4;
+var SESSION_ANCHOR_KEY = "sessionKey";
+function sessionAnchor(frontmatter) {
+  const value = frontmatter.structuredAttributes?.[SESSION_ANCHOR_KEY];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function createdMs(memory) {
+  const ms2 = Date.parse(memory.frontmatter.created);
+  return Number.isFinite(ms2) ? ms2 : Number.NaN;
+}
+function isEvidenceStatus(status) {
+  return status === void 0 || status === "active" || status === "pending_review";
+}
+function hasLineageLink(seed, evidence) {
+  const seedLineage = seed.frontmatter.lineage;
+  if (seedLineage !== void 0 && seedLineage.includes(evidence.frontmatter.id)) return true;
+  const evidenceLineage = evidence.frontmatter.lineage;
+  if (evidenceLineage !== void 0 && evidenceLineage.includes(seed.frontmatter.id)) return true;
+  return false;
+}
+function isIndependentProvenance(seed, evidence) {
+  if (hasLineageLink(seed, evidence)) return false;
+  const seedSession = sessionAnchor(seed.frontmatter);
+  const evidenceSession = sessionAnchor(evidence.frontmatter);
+  if (seedSession !== void 0 && evidenceSession !== void 0) {
+    return seedSession !== evidenceSession;
+  }
+  return evidence.frontmatter.source !== seed.frontmatter.source;
+}
+function coverageOf(seedTokens, evidence) {
+  if (seedTokens.size === 0) return 0;
+  const evidenceTokens = new Set(normalizeRecallTokens(stripAttributesSuffix(evidence.content)));
+  let matches = 0;
+  for (const token of seedTokens) {
+    if (evidenceTokens.has(token)) matches += 1;
+  }
+  return matches / seedTokens.size;
+}
+function evaluateSeedGraduation(seed, evidence, options = {}) {
+  const config = options.config ?? SEED_GRADUATION_DEFAULTS;
+  if (!config.enabled) {
+    return {
+      decision: "hold",
+      corroborationCount: 0,
+      corroborating: [],
+      echoSuppressedCount: 0,
+      reasons: ["seed-graduation-disabled"]
+    };
+  }
+  const seedTokens = new Set(normalizeRecallTokens(stripAttributesSuffix(seed.content)));
+  if (seedTokens.size < MIN_SEED_TOKENS) {
+    return {
+      decision: "hold",
+      corroborationCount: 0,
+      corroborating: [],
+      echoSuppressedCount: 0,
+      reasons: ["seed-too-short-for-deterministic-corroboration"]
+    };
+  }
+  const seedCreated = createdMs(seed);
+  const corroborating = [];
+  const reasons = [];
+  let echoSuppressedCount = 0;
+  for (const candidate of evidence) {
+    if (candidate.frontmatter.id === seed.frontmatter.id) continue;
+    const candidateCreated = createdMs(candidate);
+    if (!Number.isFinite(seedCreated) || !Number.isFinite(candidateCreated)) continue;
+    if (candidateCreated <= seedCreated) continue;
+    if (!isEvidenceStatus(candidate.frontmatter.status)) continue;
+    if (coverageOf(seedTokens, candidate) < SEED_CORROBORATION_COVERAGE) continue;
+    if (!isIndependentProvenance(seed, candidate)) {
+      echoSuppressedCount += 1;
+      continue;
+    }
+    const evidenceSession = sessionAnchor(candidate.frontmatter);
+    if (options.recalledBySession !== void 0 && evidenceSession !== void 0 && options.recalledBySession(evidenceSession).some((recalledIds) => recalledIds.includes(seed.frontmatter.id))) {
+      echoSuppressedCount += 1;
+      continue;
+    }
+    corroborating.push({ memoryId: candidate.frontmatter.id, source: candidate.frontmatter.source });
+  }
+  if (echoSuppressedCount > 0) reasons.push(`echo-suppressed:${echoSuppressedCount}`);
+  if (corroborating.length >= config.minCorroborations) {
+    return {
+      decision: "promote",
+      corroborationCount: corroborating.length,
+      corroborating,
+      echoSuppressedCount,
+      reasons
+    };
+  }
+  reasons.push(`corroboration-below-min:${corroborating.length}/${config.minCorroborations}`);
+  return {
+    decision: "hold",
+    corroborationCount: corroborating.length,
+    corroborating,
+    echoSuppressedCount,
+    reasons
+  };
+}
+function graduationAttributes(evaluation) {
+  const ids = evaluation.corroborating.map((entry) => entry.memoryId).join(",").slice(0, STRUCTURED_ATTRIBUTE_LIMITS.maxValueLength);
+  return {
+    graduatedBy: "independent-corroboration",
+    corroborationCount: String(evaluation.corroborationCount),
+    corroboratingMemoryIds: ids
+  };
+}
+async function runSeedGraduationPass(input) {
+  const config = input.config ?? SEED_GRADUATION_DEFAULTS;
+  if (!config.enabled) {
+    return { evaluated: 0, promoted: 0, held: 0, echoSuppressed: 0, disabled: true };
+  }
+  const corpus = excludeSupportPassportPrivateMemories(input.memories);
+  const evidencePool = corpus.filter((memory) => isEvidenceStatus(memory.frontmatter.status));
+  let promoted = 0;
+  let held = 0;
+  let echoSuppressed = 0;
+  let evaluated = 0;
+  for (const seed of corpus) {
+    if (seed.frontmatter.status !== "pending_review") continue;
+    if (seed.frontmatter.blockedBy !== void 0) continue;
+    evaluated += 1;
+    const evaluation = evaluateSeedGraduation(seed, evidencePool, {
+      config,
+      recalledBySession: input.recalledBySession
+    });
+    echoSuppressed += evaluation.echoSuppressedCount;
+    if (evaluation.decision === "hold") {
+      held += 1;
+      continue;
+    }
+    const wrote = await input.storage.promoteWearableMemory(
+      seed.frontmatter.id,
+      graduationAttributes(evaluation)
+    );
+    if (wrote) promoted += 1;
+    else held += 1;
+  }
+  return { evaluated, promoted, held, echoSuppressed, disabled: false };
+}
+
 // src/dedup/connector-scope.ts
 function normalizeConnectorScope(value) {
   if (typeof value !== "string") return void 0;
@@ -2354,6 +2561,7 @@ var MEMORY_OS_PRESETS = {
     // explicitly.
     procedural: { enabled: false },
     sessionExperience: { enabled: false },
+    seedGraduation: { enabled: false },
     recallNavigation: { enabled: false }
   },
   balanced: {
@@ -3001,6 +3209,7 @@ function parseConfig(raw, rawOperatorConfig, runtimeSet) {
     recallNavigation: parseRecallNavigationConfig(cfg.recallNavigation),
     // Session-end experience extraction (issue #2979) — default off.
     sessionExperience: parseSessionExperienceConfig(cfg.sessionExperience),
+    seedGraduation: parseSeedGraduationConfig(cfg.seedGraduation),
     dependencyPropagation: parseDependencyPropagationConfig(cfg),
     // Temporal Supersession (issue #375)
     temporalSupersessionEnabled: cfg.temporalSupersessionEnabled !== false,
@@ -4820,6 +5029,7 @@ function parseTrustScoreWeights(value) {
 export {
   DRIFT_DETECTION_DEFAULTS,
   parseDriftDetectionConfig,
+  runSeedGraduationPass,
   normalizeConnectorScope,
   connectorMatchesScope,
   embeddingsFromCosineHits,
@@ -4852,4 +5062,4 @@ export {
   VALID_MEMORY_CATEGORIES,
   parseConfig
 };
-//# sourceMappingURL=chunk-OLJYDGGP.js.map
+//# sourceMappingURL=chunk-UVZBDIJX.js.map