@remnic/belief-ledger 9.3.596

package/dist/index.js

@@ -0,0 +1,1679 @@
+// openclaw-engram: Local-first memory plugin
+
+// src/schema.ts
+var LEDGER_TAG = "belief-ledger";
+var LEDGER_SCHEMA_VERSION = "1";
+var KIND_VALUES = /* @__PURE__ */ new Set(["claim", "prediction", "opinion"]);
+var STANCE_VALUES = /* @__PURE__ */ new Set(["for", "against", "uncertain", "neutral"]);
+var STATUS_VALUES = /* @__PURE__ */ new Set(["active", "superseded", "resolved", "snoozed", "ignored"]);
+var JUDGE_VALUES = /* @__PURE__ */ new Set(["contradiction", "evolution", "refinement", "unrelated"]);
+var VERDICT_VALUES = /* @__PURE__ */ new Set(["true", "false", "mixed", "unknown"]);
+var HIDDEN_REMNIC_STATUSES = /* @__PURE__ */ new Set([
+  "forgotten",
+  "pending_review",
+  "quarantined",
+  "rejected"
+]);
+function normalizeClaimDraft(draft, options) {
+  const now = normalizeIsoTimestamp("now", options.now);
+  const statement = cleanRequiredString("statement", draft.statement, 5e3);
+  const deadline = draft.deadline === void 0 ? void 0 : normalizeIsoTimestamp("deadline", draft.deadline);
+  const kind = normalizeKind(draft.kind ?? (deadline ? "prediction" : "claim"));
+  const stance = normalizeStance(draft.stance);
+  const confidence = normalizeUnitInterval("confidence", draft.confidence);
+  const scope = normalizeScope(draft.scope);
+  return {
+    statement,
+    kind,
+    stance,
+    confidence,
+    scope,
+    deadline,
+    evidenceLinks: normalizeStringList("evidenceLinks", draft.evidenceLinks ?? [], 100, 2048),
+    status: "active",
+    createdAt: now,
+    updatedAt: now,
+    parentIds: [],
+    ...options.sourceText ? { sourceText: options.sourceText } : {}
+  };
+}
+function normalizeJudgeResult(raw, priorClaimId) {
+  if (!isRecord(raw)) {
+    throw new Error("judge result must be an object");
+  }
+  const classification = normalizeJudgeClassification(raw.classification);
+  return {
+    priorClaimId,
+    classification,
+    confidence: normalizeUnitInterval("judge confidence", raw.confidence ?? 0.5),
+    rationale: cleanRequiredString("judge rationale", raw.rationale ?? "", 2e3)
+  };
+}
+function normalizeChallenge(raw, priorClaimIds) {
+  if (!isRecord(raw)) {
+    throw new Error("challenge must be an object");
+  }
+  const question = cleanRequiredString("challenge question", raw.question, 2e3);
+  const parsedPriorIds = normalizeStringList(
+    "challenge priorClaimIds",
+    Array.isArray(raw.priorClaimIds) ? raw.priorClaimIds : priorClaimIds,
+    50,
+    256
+  );
+  const allowedPriorIds = new Set(priorClaimIds);
+  const safePriorIds = parsedPriorIds.filter((id) => allowedPriorIds.has(id));
+  const suggestedActions = Array.isArray(raw.suggestedActions) ? raw.suggestedActions.filter(
+    (value) => value === "supersede" || value === "split" || value === "resolve" || value === "ignore"
+  ) : [];
+  return {
+    question,
+    priorClaimIds: safePriorIds.length > 0 ? safePriorIds : priorClaimIds,
+    suggestedActions: suggestedActions.length > 0 ? [...new Set(suggestedActions)] : ["supersede", "split", "ignore"]
+  };
+}
+function normalizePredictionGrade(raw) {
+  if (!isRecord(raw)) {
+    throw new Error("prediction grade must be an object");
+  }
+  return {
+    verdict: normalizePredictionVerdict(raw.verdict),
+    actualConfidence: normalizeUnitInterval("actualConfidence", raw.actualConfidence),
+    rationale: cleanRequiredString("grade rationale", raw.rationale ?? "", 2e3),
+    ...typeof raw.source === "string" && raw.source.trim() ? { source: raw.source.trim().slice(0, 2048) } : {}
+  };
+}
+function createResolution(input) {
+  const actualConfidence = normalizeUnitInterval("actualConfidence", input.actualConfidence);
+  const predictedConfidence = normalizeUnitInterval("predictedConfidence", input.predictedConfidence);
+  const resolvedAt = normalizeIsoTimestamp("resolvedAt", input.resolvedAt);
+  return {
+    verdict: normalizePredictionVerdict(input.verdict),
+    actualConfidence,
+    resolvedAt,
+    ...input.source ? { source: cleanRequiredString("source", input.source, 2048) } : {},
+    ...input.notes ? { notes: cleanRequiredString("notes", input.notes, 5e3) } : {},
+    brierScore: computeBrierScore(predictedConfidence, actualConfidence)
+  };
+}
+function computeBrierScore(predictedConfidence, actualConfidence) {
+  const predicted = normalizeUnitInterval("predictedConfidence", predictedConfidence);
+  const actual = normalizeUnitInterval("actualConfidence", actualConfidence);
+  return roundMetric((predicted - actual) ** 2);
+}
+function roundMetric(value) {
+  if (!Number.isFinite(value)) {
+    throw new Error(`metric must be finite, got ${String(value)}`);
+  }
+  return Math.round(value * 1e6) / 1e6;
+}
+function claimToStructuredAttributes(claim) {
+  const attrs = {
+    "ledger.schemaVersion": LEDGER_SCHEMA_VERSION,
+    "ledger.kind": claim.kind,
+    "ledger.stance": claim.stance,
+    "ledger.confidence": String(claim.confidence),
+    "ledger.entities": JSON.stringify(claim.scope.entities),
+    "ledger.status": claim.status,
+    "ledger.createdAt": claim.createdAt,
+    "ledger.updatedAt": claim.updatedAt,
+    "ledger.parentIds": JSON.stringify(claim.parentIds)
+  };
+  if (claim.scope.domain) attrs["ledger.domain"] = claim.scope.domain;
+  if (claim.scope.timeWindow?.start) attrs["ledger.timeWindowStart"] = claim.scope.timeWindow.start;
+  if (claim.scope.timeWindow?.end) attrs["ledger.timeWindowEnd"] = claim.scope.timeWindow.end;
+  if (claim.deadline) attrs["ledger.deadline"] = claim.deadline;
+  if (claim.evidenceLinks.length > 0) attrs["ledger.evidenceLinks"] = JSON.stringify(claim.evidenceLinks);
+  if (claim.supersedes) attrs["ledger.supersedes"] = claim.supersedes;
+  if (claim.supersededBy) attrs["ledger.supersededBy"] = claim.supersededBy;
+  if (claim.snoozedUntil) attrs["ledger.snoozedUntil"] = claim.snoozedUntil;
+  if (claim.ignoredAt) attrs["ledger.ignoredAt"] = claim.ignoredAt;
+  if (claim.ignoredReason) attrs["ledger.ignoredReason"] = claim.ignoredReason;
+  if (claim.sourceText) attrs["ledger.sourceText"] = claim.sourceText.slice(0, 5e3);
+  if (claim.resolution) {
+    attrs["ledger.verdict"] = claim.resolution.verdict;
+    attrs["ledger.actualConfidence"] = String(claim.resolution.actualConfidence);
+    attrs["ledger.resolvedAt"] = claim.resolution.resolvedAt;
+    if (claim.resolution.source) attrs["ledger.resolutionSource"] = claim.resolution.source;
+    if (claim.resolution.notes) attrs["ledger.resolutionNotes"] = claim.resolution.notes;
+    if (claim.resolution.brierScore !== void 0) attrs["ledger.brierScore"] = String(claim.resolution.brierScore);
+  }
+  return attrs;
+}
+function claimTags(claim) {
+  const tags = [LEDGER_TAG, `${LEDGER_TAG}:${claim.kind}`, `${LEDGER_TAG}:status:${claim.status}`];
+  if (claim.scope.domain) {
+    tags.push(`${LEDGER_TAG}:domain:${slugTagValue(claim.scope.domain)}`);
+  }
+  if (claim.deadline) tags.push(`${LEDGER_TAG}:deadline`);
+  return [...new Set(tags)];
+}
+function serializeClaimBody(claim) {
+  const lines = [
+    "# Belief Ledger Claim",
+    "",
+    claim.statement,
+    "",
+    `Kind: ${claim.kind}`,
+    `Stance: ${claim.stance}`,
+    `Confidence: ${claim.confidence}`,
+    `Status: ${claim.status}`
+  ];
+  if (claim.scope.domain) lines.push(`Domain: ${claim.scope.domain}`);
+  if (claim.scope.entities.length > 0) lines.push(`Entities: ${claim.scope.entities.join(", ")}`);
+  if (claim.deadline) lines.push(`Deadline: ${claim.deadline}`);
+  if (claim.resolution) {
+    lines.push(`Verdict: ${claim.resolution.verdict}`);
+    lines.push(`Actual confidence: ${claim.resolution.actualConfidence}`);
+    if (claim.resolution.brierScore !== void 0) {
+      lines.push(`Brier score: ${claim.resolution.brierScore}`);
+    }
+  }
+  if (claim.evidenceLinks.length > 0) {
+    lines.push("", "Evidence:");
+    for (const link of claim.evidenceLinks) {
+      lines.push(`- ${link}`);
+    }
+  }
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+function claimFromMemory(memory) {
+  const attrs = normalizeStructuredAttributes(memory.frontmatter.structuredAttributes);
+  const tags = memory.frontmatter.tags ?? [];
+  if (!tags.includes(LEDGER_TAG) && attrs["ledger.schemaVersion"] !== LEDGER_SCHEMA_VERSION) {
+    return null;
+  }
+  if (isHiddenRemnicStatus(memory.frontmatter.status)) {
+    return null;
+  }
+  const storedStatus = normalizeStatus(attrs["ledger.status"] ?? "active");
+  if (memory.frontmatter.status === "archived" && storedStatus === "active") {
+    return null;
+  }
+  const statement = extractStatement(memory.content);
+  if (!statement) return null;
+  const entities = parseStringArrayAttribute("ledger.entities", attrs["ledger.entities"]);
+  const entityRef = memory.frontmatter.entityRef?.trim();
+  if (entityRef && !entities.includes(entityRef)) {
+    entities.unshift(entityRef);
+  }
+  const resolution = parseResolution(attrs);
+  const status = memory.frontmatter.status === "superseded" ? "superseded" : storedStatus;
+  const claim = {
+    id: memory.frontmatter.id,
+    memoryId: memory.frontmatter.id,
+    statement,
+    kind: normalizeKind(attrs["ledger.kind"] ?? "claim"),
+    stance: normalizeStance(attrs["ledger.stance"] ?? "uncertain"),
+    confidence: normalizeUnitInterval("confidence", attrs["ledger.confidence"] ?? memory.frontmatter.confidence),
+    scope: {
+      entities,
+      ...attrs["ledger.domain"] ? { domain: attrs["ledger.domain"] } : {},
+      ...parseTimeWindow(attrs)
+    },
+    ...attrs["ledger.deadline"] ? { deadline: normalizeIsoTimestamp("deadline", attrs["ledger.deadline"]) } : {},
+    evidenceLinks: parseStringArrayAttribute("ledger.evidenceLinks", attrs["ledger.evidenceLinks"]),
+    status,
+    createdAt: normalizeIsoTimestamp(
+      "createdAt",
+      attrs["ledger.createdAt"] ?? memory.frontmatter.valid_at ?? memory.frontmatter.created
+    ),
+    updatedAt: normalizeIsoTimestamp("updatedAt", attrs["ledger.updatedAt"] ?? memory.frontmatter.updated),
+    ...memory.frontmatter.supersedes || attrs["ledger.supersedes"] ? { supersedes: attrs["ledger.supersedes"] ?? memory.frontmatter.supersedes } : {},
+    ...memory.frontmatter.supersededBy || attrs["ledger.supersededBy"] ? { supersededBy: attrs["ledger.supersededBy"] ?? memory.frontmatter.supersededBy } : {},
+    parentIds: parseStringArrayAttribute("ledger.parentIds", attrs["ledger.parentIds"]).concat(
+      memory.frontmatter.lineage ?? []
+    ),
+    ...attrs["ledger.snoozedUntil"] ? { snoozedUntil: normalizeIsoTimestamp("snoozedUntil", attrs["ledger.snoozedUntil"]) } : {},
+    ...attrs["ledger.ignoredAt"] ? { ignoredAt: normalizeIsoTimestamp("ignoredAt", attrs["ledger.ignoredAt"]) } : {},
+    ...attrs["ledger.ignoredReason"] ? { ignoredReason: attrs["ledger.ignoredReason"] } : {},
+    ...resolution ? { resolution } : {},
+    ...attrs["ledger.sourceText"] ? { sourceText: attrs["ledger.sourceText"] } : {},
+    sourceMemory: memory
+  };
+  claim.parentIds = [...new Set(claim.parentIds.filter((value) => value !== claim.id))];
+  return claim;
+}
+function isHiddenRemnicStatus(status) {
+  return status !== void 0 && HIDDEN_REMNIC_STATUSES.has(status);
+}
+function mergeClaimPatch(claim, patch, now) {
+  const updated = {
+    ...claim,
+    ...patch,
+    scope: patch.scope ? normalizeScope(patch.scope) : claim.scope,
+    evidenceLinks: patch.evidenceLinks ? normalizeStringList("evidenceLinks", patch.evidenceLinks, 100, 2048) : claim.evidenceLinks,
+    parentIds: patch.parentIds ? normalizeStringList("parentIds", patch.parentIds, 100, 256) : claim.parentIds,
+    createdAt: normalizeIsoTimestamp("createdAt", patch.createdAt ?? claim.createdAt),
+    updatedAt: normalizeIsoTimestamp("updatedAt", patch.updatedAt ?? now)
+  };
+  updated.statement = cleanRequiredString("statement", updated.statement, 5e3);
+  updated.kind = normalizeKind(updated.kind);
+  updated.stance = normalizeStance(updated.stance);
+  updated.confidence = normalizeUnitInterval("confidence", updated.confidence);
+  updated.status = normalizeStatus(updated.status);
+  if (updated.resolution) updated.resolution = normalizeResolutionPatch(updated.resolution, updated.confidence);
+  if (updated.deadline) updated.deadline = normalizeIsoTimestamp("deadline", updated.deadline);
+  if (updated.snoozedUntil) updated.snoozedUntil = normalizeIsoTimestamp("snoozedUntil", updated.snoozedUntil);
+  if (updated.ignoredAt) updated.ignoredAt = normalizeIsoTimestamp("ignoredAt", updated.ignoredAt);
+  return updated;
+}
+function normalizeResolutionPatch(value, predictedConfidence) {
+  if (!isRecord(value)) {
+    throw new Error("resolution must be an object");
+  }
+  if (value.source !== void 0 && typeof value.source !== "string") {
+    throw new Error("resolution source must be a string");
+  }
+  if (value.notes !== void 0 && typeof value.notes !== "string") {
+    throw new Error("resolution notes must be a string");
+  }
+  return createResolution({
+    verdict: value.verdict,
+    actualConfidence: value.actualConfidence,
+    resolvedAt: value.resolvedAt,
+    source: value.source,
+    notes: value.notes,
+    predictedConfidence
+  });
+}
+function memoryFrontmatterPatchForClaim(claim) {
+  return {
+    updated: claim.updatedAt,
+    confidence: claim.confidence,
+    tags: claimTags(claim),
+    entityRef: claim.scope.entities[0],
+    supersedes: claim.supersedes,
+    lineage: claim.parentIds.length > 0 ? claim.parentIds : void 0,
+    status: remnicMemoryStatusForClaim(claim),
+    supersededBy: claim.supersededBy,
+    supersededAt: claim.status === "superseded" ? claim.updatedAt : void 0,
+    structuredAttributes: claimToStructuredAttributes(claim)
+  };
+}
+function remnicMemoryStatusForClaim(claim) {
+  switch (claim.status) {
+    case "active":
+      return "active";
+    case "superseded":
+      return "superseded";
+    case "ignored":
+    case "resolved":
+    case "snoozed":
+      return "archived";
+  }
+}
+function normalizeIsoTimestamp(field, value) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${field} must be a non-empty ISO timestamp string`);
+  }
+  const trimmed = value.trim();
+  validateIsoTimestampComponents(field, trimmed);
+  const time = Date.parse(trimmed);
+  if (!Number.isFinite(time)) {
+    throw new Error(`${field} must be a valid ISO timestamp, got ${JSON.stringify(value)}`);
+  }
+  const date = new Date(time);
+  if (!Number.isFinite(date.getTime())) {
+    throw new Error(`${field} must be within JavaScript Date bounds`);
+  }
+  return date.toISOString();
+}
+function validateIsoTimestampComponents(field, value) {
+  if (value.length < 10 || value[4] !== "-" || value[7] !== "-") {
+    throw new Error(`${field} must be a valid ISO timestamp, got ${JSON.stringify(value)}`);
+  }
+  const year = readFixedDigits(value, 0, 4);
+  const month = readFixedDigits(value, 5, 2);
+  const day = readFixedDigits(value, 8, 2);
+  if (year === void 0 || month === void 0 || day === void 0) {
+    throw new Error(`${field} must be a valid ISO timestamp, got ${JSON.stringify(value)}`);
+  }
+  if (value.length === 10) {
+    assertValidCalendarParts(field, value, year, month, day, 0, 0, 0, 0);
+    return;
+  }
+  const separator = value[10];
+  if (separator !== "T" && separator !== "t" && separator !== " ") {
+    throw new Error(`${field} must be a valid ISO timestamp, got ${JSON.stringify(value)}`);
+  }
+  const timeText = stripAndValidateTimeZone(field, value, value.slice(11));
+  const timeParts = parseIsoTimeParts(field, value, timeText);
+  assertValidCalendarParts(
+    field,
+    value,
+    year,
+    month,
+    day,
+    timeParts.hour,
+    timeParts.minute,
+    timeParts.second,
+    timeParts.millisecond
+  );
+}
+function stripAndValidateTimeZone(field, original, rawTime) {
+  if (!rawTime) {
+    throw new Error(`${field} must be a valid ISO timestamp, got ${JSON.stringify(original)}`);
+  }
+  const lastChar = rawTime[rawTime.length - 1];
+  if (lastChar === "Z" || lastChar === "z") {
+    return rawTime.slice(0, -1);
+  }
+  const offsetStart = rawTime.length - 6;
+  const sign = offsetStart > 0 ? rawTime[offsetStart] : void 0;
+  if ((sign === "+" || sign === "-") && rawTime[offsetStart + 3] === ":") {
+    const offsetHour = readFixedDigits(rawTime, offsetStart + 1, 2);
+    const offsetMinute = readFixedDigits(rawTime, offsetStart + 4, 2);
+    if (offsetHour === void 0 || offsetMinute === void 0 || offsetHour > 23 || offsetMinute > 59) {
+      throw new Error(`${field} must be a valid ISO timestamp, got ${JSON.stringify(original)}`);
+    }
+    return rawTime.slice(0, offsetStart);
+  }
+  throw new Error(`${field} must be a valid ISO timestamp, got ${JSON.stringify(original)}`);
+}
+function parseIsoTimeParts(field, original, value) {
+  if (value.length < 5 || value[2] !== ":") {
+    throw new Error(`${field} must be a valid ISO timestamp, got ${JSON.stringify(original)}`);
+  }
+  const hour = readFixedDigits(value, 0, 2);
+  const minute = readFixedDigits(value, 3, 2);
+  if (hour === void 0 || minute === void 0 || hour > 23 || minute > 59) {
+    throw new Error(`${field} must be a valid ISO timestamp, got ${JSON.stringify(original)}`);
+  }
+  if (value.length === 5) {
+    return { hour, minute, second: 0, millisecond: 0 };
+  }
+  if (value[5] !== ":") {
+    throw new Error(`${field} must be a valid ISO timestamp, got ${JSON.stringify(original)}`);
+  }
+  const second = readFixedDigits(value, 6, 2);
+  if (second === void 0 || second > 59) {
+    throw new Error(`${field} must be a valid ISO timestamp, got ${JSON.stringify(original)}`);
+  }
+  if (value.length === 8) {
+    return { hour, minute, second, millisecond: 0 };
+  }
+  if (value[8] !== ".") {
+    throw new Error(`${field} must be a valid ISO timestamp, got ${JSON.stringify(original)}`);
+  }
+  const fraction = value.slice(9);
+  if (fraction.length === 0 || fraction.length > 3 || !isAllDigits(fraction)) {
+    throw new Error(`${field} must be a valid ISO timestamp, got ${JSON.stringify(original)}`);
+  }
+  return {
+    hour,
+    minute,
+    second,
+    millisecond: Number(fraction.padEnd(3, "0"))
+  };
+}
+function assertValidCalendarParts(field, original, year, month, day, hour, minute, second, millisecond) {
+  const time = Date.UTC(year, month - 1, day, hour, minute, second, millisecond);
+  const date = new Date(time);
+  if (!Number.isFinite(time) || date.getUTCFullYear() !== year || date.getUTCMonth() !== month - 1 || date.getUTCDate() !== day || date.getUTCHours() !== hour || date.getUTCMinutes() !== minute || date.getUTCSeconds() !== second || date.getUTCMilliseconds() !== millisecond) {
+    throw new Error(`${field} must be a valid ISO timestamp, got ${JSON.stringify(original)}`);
+  }
+}
+function readFixedDigits(value, start, length) {
+  const end = start + length;
+  if (end > value.length) return void 0;
+  const slice = value.slice(start, end);
+  return isAllDigits(slice) ? Number(slice) : void 0;
+}
+function isAllDigits(value) {
+  if (!value) return false;
+  for (const char of value) {
+    const code = char.charCodeAt(0);
+    if (code < 48 || code > 57) return false;
+  }
+  return true;
+}
+function normalizeUnitInterval(field, value) {
+  const num = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : NaN;
+  if (!Number.isFinite(num)) {
+    throw new Error(`${field} must be a finite number in [0, 1], got ${String(value)}`);
+  }
+  if (num < 0 || num > 1) {
+    throw new Error(`${field} must be in [0, 1], got ${num}`);
+  }
+  return num;
+}
+function normalizeScope(value) {
+  const scope = value ?? {};
+  const entities = normalizeStringList("entities", scope.entities ?? [], 50, 256);
+  const domain = typeof scope.domain === "string" && scope.domain.trim().length > 0 ? scope.domain.trim().slice(0, 256) : void 0;
+  const timeWindow = scope.timeWindow ? normalizeTimeWindow(scope.timeWindow) : void 0;
+  return {
+    entities,
+    ...domain ? { domain } : {},
+    ...timeWindow ? { timeWindow } : {}
+  };
+}
+function normalizeTimeWindow(value) {
+  const start = value.start === void 0 ? void 0 : normalizeIsoTimestamp("timeWindow.start", value.start);
+  const end = value.end === void 0 ? void 0 : normalizeIsoTimestamp("timeWindow.end", value.end);
+  if (start && end && Date.parse(start) >= Date.parse(end)) {
+    throw new Error("timeWindow.start must be before timeWindow.end");
+  }
+  return start || end ? { ...start ? { start } : {}, ...end ? { end } : {} } : void 0;
+}
+function parseTimeWindow(attrs) {
+  const start = attrs["ledger.timeWindowStart"];
+  const end = attrs["ledger.timeWindowEnd"];
+  const timeWindow = normalizeTimeWindow({ start, end });
+  return timeWindow ? { timeWindow } : {};
+}
+function normalizeKind(value) {
+  if (typeof value !== "string" || !KIND_VALUES.has(value)) {
+    throw new Error(`kind must be one of ${[...KIND_VALUES].join(", ")}`);
+  }
+  return value;
+}
+function normalizeStance(value) {
+  if (typeof value !== "string" || !STANCE_VALUES.has(value)) {
+    throw new Error(`stance must be one of ${[...STANCE_VALUES].join(", ")}`);
+  }
+  return value;
+}
+function normalizeStatus(value) {
+  if (typeof value !== "string" || !STATUS_VALUES.has(value)) {
+    throw new Error(`status must be one of ${[...STATUS_VALUES].join(", ")}`);
+  }
+  return value;
+}
+function normalizeJudgeClassification(value) {
+  if (typeof value !== "string" || !JUDGE_VALUES.has(value)) {
+    throw new Error(`classification must be one of ${[...JUDGE_VALUES].join(", ")}`);
+  }
+  return value;
+}
+function normalizePredictionVerdict(value) {
+  if (typeof value !== "string" || !VERDICT_VALUES.has(value)) {
+    throw new Error(`verdict must be one of ${[...VERDICT_VALUES].join(", ")}`);
+  }
+  return value;
+}
+function parseResolution(attrs) {
+  if (!attrs["ledger.verdict"]) return void 0;
+  const actualConfidence = normalizeUnitInterval("actualConfidence", attrs["ledger.actualConfidence"]);
+  const verdict = normalizePredictionVerdict(attrs["ledger.verdict"]);
+  const resolvedAt = normalizeIsoTimestamp("resolvedAt", attrs["ledger.resolvedAt"]);
+  return {
+    verdict,
+    actualConfidence,
+    resolvedAt,
+    ...attrs["ledger.resolutionSource"] ? { source: attrs["ledger.resolutionSource"] } : {},
+    ...attrs["ledger.resolutionNotes"] ? { notes: attrs["ledger.resolutionNotes"] } : {},
+    ...attrs["ledger.brierScore"] !== void 0 ? { brierScore: roundMetric(Number(attrs["ledger.brierScore"])) } : {}
+  };
+}
+function normalizeStructuredAttributes(value) {
+  if (!isRecord(value)) return {};
+  const result = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (typeof raw === "string") {
+      result[key] = raw;
+    } else if (typeof raw === "number" || typeof raw === "boolean") {
+      result[key] = String(raw);
+    }
+  }
+  return result;
+}
+function parseStringArrayAttribute(field, value) {
+  if (value === void 0 || value.trim() === "") return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    throw new Error(`${field} must be a JSON array`);
+  }
+  return normalizeStringList(field, parsed, 100, 2048);
+}
+function normalizeStringList(field, value, maxItems, maxLength) {
+  if (!Array.isArray(value)) {
+    throw new Error(`${field} must be an array`);
+  }
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of value) {
+    if (typeof item !== "string") {
+      throw new Error(`${field} entries must be strings`);
+    }
+    const trimmed = item.trim();
+    if (!trimmed) continue;
+    const clipped = trimmed.slice(0, maxLength);
+    if (seen.has(clipped)) continue;
+    seen.add(clipped);
+    result.push(clipped);
+    if (result.length > maxItems) {
+      throw new Error(`${field} must contain at most ${maxItems} entries`);
+    }
+  }
+  return result;
+}
+function cleanRequiredString(field, value, maxLength) {
+  if (typeof value !== "string") {
+    throw new Error(`${field} must be a string`);
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error(`${field} must not be empty`);
+  }
+  if (trimmed.length > maxLength) {
+    throw new Error(`${field} must be at most ${maxLength} characters`);
+  }
+  return trimmed;
+}
+function extractStatement(content) {
+  const normalized = content.replace(/\r\n/g, "\n").trim();
+  const lines = normalized.split("\n");
+  const titleIndex = lines.findIndex((line) => line.trim() === "# Belief Ledger Claim");
+  if (titleIndex >= 0) {
+    const statementLines = [];
+    let started = false;
+    for (let i = titleIndex + 1; i < lines.length; i += 1) {
+      const line = lines[i] ?? "";
+      const trimmed = line.trim();
+      if (!started && !trimmed) continue;
+      if (isClaimMetadataLine(trimmed)) {
+        break;
+      }
+      started = true;
+      statementLines.push(line.trimEnd());
+    }
+    const statement = statementLines.join("\n").trim();
+    if (statement) {
+      return statement;
+    }
+  }
+  const first = lines.find((line) => line.trim() && !line.trim().startsWith("#"));
+  return first?.trim() ?? "";
+}
+function isClaimMetadataLine(line) {
+  return CLAIM_METADATA_PREFIXES.some((prefix) => line.startsWith(prefix));
+}
+var CLAIM_METADATA_PREFIXES = [
+  "Kind:",
+  "Stance:",
+  "Confidence:",
+  "Status:",
+  "Domain:",
+  "Entities:",
+  "Deadline:",
+  "Verdict:",
+  "Actual confidence:",
+  "Brier score:"
+];
+function slugTagValue(value) {
+  let slug = "";
+  let pendingDash = false;
+  for (const char of value.toLowerCase()) {
+    const code = char.charCodeAt(0);
+    const isAsciiLetter = code >= 97 && code <= 122;
+    const isDigit = code >= 48 && code <= 57;
+    if (isAsciiLetter || isDigit) {
+      if (pendingDash && slug) slug += "-";
+      slug += char;
+      pendingDash = false;
+    } else if (slug) {
+      pendingDash = true;
+    }
+  }
+  return slug || "unknown";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/reflection.ts
+var DEFAULT_DORMANT_AFTER_DAYS = 60;
+function buildReflectionReport(claims, options = {}) {
+  const nowIso = normalizeIsoTimestamp("reflection.now", options.now ?? (/* @__PURE__ */ new Date()).toISOString());
+  const now = Date.parse(nowIso);
+  if (!Number.isFinite(now)) {
+    throw new Error(`reflection now must be a valid ISO timestamp, got ${String(options.now)}`);
+  }
+  const resolvedPredictions = claims.filter(
+    (claim) => claim.kind === "prediction" && claim.resolution?.brierScore !== void 0
+  );
+  const brierScore = resolvedPredictions.length > 0 ? roundMetric(mean(resolvedPredictions.map((claim) => claim.resolution?.brierScore ?? 0))) : void 0;
+  return {
+    generatedAt: new Date(now).toISOString(),
+    totalClaims: claims.length,
+    activeClaims: claims.filter((claim) => claim.status === "active").length,
+    resolvedPredictions: resolvedPredictions.length,
+    ...brierScore !== void 0 ? { brierScore } : {},
+    calibrationBins: buildCalibrationBins(resolvedPredictions),
+    domains: buildDomainCalibration(resolvedPredictions),
+    flippedClaims: buildFlippedClaims(claims),
+    dormantTopics: buildDormantTopics(claims, now, options.dormantAfterDays ?? DEFAULT_DORMANT_AFTER_DAYS)
+  };
+}
+function buildCalibrationBins(claims) {
+  const bins = [
+    { minConfidence: 0, maxConfidence: 0.2 },
+    { minConfidence: 0.2, maxConfidence: 0.4 },
+    { minConfidence: 0.4, maxConfidence: 0.6 },
+    { minConfidence: 0.6, maxConfidence: 0.8 },
+    { minConfidence: 0.8, maxConfidence: 1.000001 }
+  ];
+  return bins.map((bin) => {
+    const members = claims.filter(
+      (claim) => claim.confidence >= bin.minConfidence && claim.confidence < bin.maxConfidence
+    );
+    if (members.length === 0) return null;
+    const predicted = mean(members.map((claim) => claim.confidence));
+    const actual = mean(members.map((claim) => claim.resolution?.actualConfidence ?? 0.5));
+    return {
+      minConfidence: bin.minConfidence,
+      maxConfidence: bin.maxConfidence > 1 ? 1 : bin.maxConfidence,
+      count: members.length,
+      meanPredictedConfidence: roundMetric(predicted),
+      meanActualConfidence: roundMetric(actual),
+      calibrationError: roundMetric(predicted - actual)
+    };
+  }).filter((bin) => bin !== null);
+}
+function buildDomainCalibration(claims) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const claim of claims) {
+    const domain = claim.scope.domain?.trim() || "uncategorized";
+    grouped.set(domain, [...grouped.get(domain) ?? [], claim]);
+  }
+  return [...grouped.entries()].map(([domain, members]) => {
+    const predicted = mean(members.map((claim) => claim.confidence));
+    const actual = mean(members.map((claim) => claim.resolution?.actualConfidence ?? 0.5));
+    const error = predicted - actual;
+    const tendency = Math.abs(error) <= 0.1 ? "well_calibrated" : error > 0 ? "overconfident" : "underconfident";
+    return {
+      domain,
+      count: members.length,
+      brierScore: roundMetric(mean(members.map((claim) => claim.resolution?.brierScore ?? 0))),
+      meanPredictedConfidence: roundMetric(predicted),
+      meanActualConfidence: roundMetric(actual),
+      tendency
+    };
+  }).sort((a, b) => {
+    const countOrder = b.count - a.count;
+    if (countOrder !== 0) return countOrder;
+    return a.domain.localeCompare(b.domain);
+  });
+}
+function buildFlippedClaims(claims) {
+  const byId = new Map(claims.map((claim) => [claim.id, claim]));
+  const groups = /* @__PURE__ */ new Map();
+  for (const claim of claims) {
+    const root = findRootClaimId(claim, byId);
+    groups.set(root, [...groups.get(root) ?? [], claim]);
+  }
+  return [...groups.entries()].map(([rootClaimId, members]) => {
+    const sorted = [...members].sort((a, b) => {
+      const createdOrder = Date.parse(a.createdAt) - Date.parse(b.createdAt);
+      if (createdOrder !== 0) return createdOrder;
+      return a.id.localeCompare(b.id);
+    });
+    let flipCount = 0;
+    for (let i = 1; i < sorted.length; i += 1) {
+      if (sorted[i - 1]?.stance !== sorted[i]?.stance) flipCount += 1;
+    }
+    if (flipCount === 0) return null;
+    return {
+      rootClaimId,
+      claimIds: sorted.map((claim) => claim.id),
+      statements: sorted.map((claim) => claim.statement),
+      flipCount
+    };
+  }).filter((item) => item !== null).sort((a, b) => {
+    const flipOrder = b.flipCount - a.flipCount;
+    if (flipOrder !== 0) return flipOrder;
+    return a.rootClaimId.localeCompare(b.rootClaimId);
+  });
+}
+function findRootClaimId(claim, byId) {
+  const seen = /* @__PURE__ */ new Set();
+  let cursor = claim;
+  while (cursor) {
+    if (seen.has(cursor.id)) return cursor.id;
+    seen.add(cursor.id);
+    const parentId = cursor.supersedes ?? cursor.parentIds[0];
+    if (!parentId) return cursor.id;
+    const parent = byId.get(parentId);
+    if (!parent) return parentId;
+    cursor = parent;
+  }
+  return claim.id;
+}
+function buildDormantTopics(claims, nowMs, dormantAfterDays) {
+  if (!Number.isFinite(dormantAfterDays) || dormantAfterDays < 0) {
+    throw new Error(`dormantAfterDays must be a non-negative number, got ${String(dormantAfterDays)}`);
+  }
+  const topics = /* @__PURE__ */ new Map();
+  for (const claim of claims) {
+    const activityAt = claimActivityAt(claim);
+    for (const topic of claimTopics(claim)) {
+      const existing = topics.get(topic);
+      if (!existing || Date.parse(activityAt) > Date.parse(existing.lastClaimAt)) {
+        topics.set(topic, {
+          lastClaimAt: activityAt,
+          claimCount: (existing?.claimCount ?? 0) + 1
+        });
+      } else {
+        existing.claimCount += 1;
+      }
+    }
+  }
+  return [...topics.entries()].map(([topic, entry]) => {
+    const ageDays = (nowMs - Date.parse(entry.lastClaimAt)) / (24 * 60 * 60 * 1e3);
+    return {
+      topic,
+      lastClaimAt: entry.lastClaimAt,
+      daysSilent: Math.max(0, Math.floor(ageDays)),
+      claimCount: entry.claimCount
+    };
+  }).filter((topic) => topic.daysSilent >= dormantAfterDays).sort((a, b) => {
+    const daysOrder = b.daysSilent - a.daysSilent;
+    if (daysOrder !== 0) return daysOrder;
+    return a.topic.localeCompare(b.topic);
+  });
+}
+function claimActivityAt(claim) {
+  return Date.parse(claim.updatedAt) >= Date.parse(claim.createdAt) ? claim.updatedAt : claim.createdAt;
+}
+function claimTopics(claim) {
+  const seen = /* @__PURE__ */ new Set();
+  const topics = [];
+  for (const topic of [...claim.scope.domain ? [claim.scope.domain] : [], ...claim.scope.entities]) {
+    const trimmed = topic.trim();
+    if (!trimmed) continue;
+    const key = trimmed.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    topics.push(trimmed);
+  }
+  return topics;
+}
+function mean(values) {
+  if (values.length === 0) return 0;
+  return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+
+// src/remnic-store.ts
+import { sanitizeMemoryContent } from "@remnic/core/sanitize";
+import { ContentHashIndex, normalizeAttributePairs } from "@remnic/core/storage";
+function serializeClaimMemoryContent(claim) {
+  const attributes = normalizeAttributePairs(claimToStructuredAttributes(claim));
+  return `${serializeClaimBody(claim)}
+[Attributes: ${attributes}]`;
+}
+var RemnicLedgerStore = class {
+  storage;
+  now;
+  source;
+  shouldWriteEntityLinks;
+  constructor(storage, options = {}) {
+    this.storage = storage;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.source = options.source ?? "belief-ledger";
+    this.shouldWriteEntityLinks = options.writeEntityLinks ?? true;
+  }
+  async createClaim(input) {
+    const pending = {
+      ...input,
+      id: "pending",
+      memoryId: "pending"
+    };
+    const memoryId = await this.storage.writeMemory("fact", serializeClaimBody(pending), {
+      actor: this.source,
+      confidence: pending.confidence,
+      tags: claimTags(pending),
+      entityRef: pending.scope.entities[0],
+      source: this.source,
+      supersedes: pending.supersedes,
+      lineage: pending.parentIds.length > 0 ? pending.parentIds : void 0,
+      memoryKind: "note",
+      validAt: pending.createdAt,
+      structuredAttributes: claimToStructuredAttributes(pending),
+      status: remnicMemoryStatusForClaim(pending)
+    });
+    const claim = await this.getClaim(memoryId);
+    if (!claim) {
+      throw new Error(`created claim ${memoryId} could not be read back`);
+    }
+    await this.writeEntityLinksBestEffort(claim);
+    return claim;
+  }
+  async getClaim(id) {
+    const memory = await this.getLedgerMemoryById(id);
+    return memory ? this.claimFromMemorySafely(memory) : null;
+  }
+  async listClaims(filter = {}) {
+    const memories = await this.readAllLedgerCandidateMemories();
+    const statuses = filter.statuses ? new Set(filter.statuses) : null;
+    const kinds = filter.kinds ? new Set(filter.kinds) : null;
+    return memories.map((memory) => this.claimFromMemorySafely(memory)).filter((claim) => claim !== null).filter((claim) => !statuses || statuses.has(claim.status)).filter((claim) => !kinds || kinds.has(claim.kind)).sort((a, b) => {
+      const updatedOrder = Date.parse(b.updatedAt) - Date.parse(a.updatedAt);
+      if (updatedOrder !== 0) return updatedOrder;
+      return a.id.localeCompare(b.id);
+    });
+  }
+  async updateClaim(id, patch) {
+    const memory = await this.getLedgerMemoryById(id);
+    const existing = this.claimFromMemorySafely(memory);
+    if (!existing) {
+      throw new Error(`claim ${id} not found`);
+    }
+    const updated = mergeClaimPatch(existing, patch, this.now().toISOString());
+    const contentUpdated = await this.writeClaimMemory(memory, updated, { actor: this.source });
+    if (!contentUpdated) {
+      throw new Error(`claim ${id} content update failed`);
+    }
+    const reread = await this.getClaim(id);
+    if (!reread) {
+      throw new Error(`claim ${id} could not be read after update`);
+    }
+    await this.writeEntityLinksBestEffort(reread);
+    return reread;
+  }
+  async supersedeClaim(priorId, newId, reason) {
+    const cleanReason = reason.trim();
+    if (!cleanReason) {
+      throw new Error("supersede reason must not be empty");
+    }
+    const prior = await this.getClaim(priorId);
+    const next = await this.getClaim(newId);
+    if (!prior || !next) return false;
+    const parentIds = [.../* @__PURE__ */ new Set([...next.parentIds, priorId])];
+    await this.updateClaim(newId, {
+      supersedes: priorId,
+      parentIds,
+      updatedAt: this.now().toISOString()
+    });
+    try {
+      await this.updateClaim(priorId, {
+        status: "superseded",
+        supersededBy: newId,
+        updatedAt: this.now().toISOString()
+      });
+    } catch (error) {
+      const restored = await this.restoreClaimBestEffort(next);
+      if (!restored) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`claim ${newId} rollback failed after prior supersession update failed: ${message}`);
+      }
+      throw error;
+    }
+    await this.writeSupersessionCorrectionBestEffort(prior, next, cleanReason);
+    return true;
+  }
+  async getLedgerMemoryById(id) {
+    const memories = await this.readAllLedgerCandidateMemories();
+    return memories.find((memory) => memory.frontmatter.id === id) ?? null;
+  }
+  async readAllLedgerCandidateMemories() {
+    const [hot, cold, archived] = await Promise.all([
+      this.storage.readAllMemories(),
+      this.storage.readAllColdMemories(),
+      this.storage.readArchivedMemories()
+    ]);
+    const byId = /* @__PURE__ */ new Map();
+    for (const memory of [...hot, ...cold, ...archived]) {
+      if (!byId.has(memory.frontmatter.id)) {
+        byId.set(memory.frontmatter.id, memory);
+      }
+    }
+    return [...byId.values()];
+  }
+  async writeClaimMemory(memory, claim, options) {
+    if (!memory) return false;
+    const sanitized = sanitizeMemoryContent(serializeClaimMemoryContent(claim));
+    const relatedMemoryIds = [
+      ...claim.supersedes ? [claim.supersedes] : [],
+      ...claim.supersededBy ? [claim.supersededBy] : [],
+      ...claim.parentIds
+    ];
+    return this.storage.writeMemoryFrontmatter(
+      { ...memory, content: sanitized.text },
+      {
+        ...memoryFrontmatterPatchForClaim(claim),
+        contentHash: ContentHashIndex.computeHash(sanitized.text)
+      },
+      {
+        actor: options.actor,
+        reasonCode: "belief-ledger-update",
+        relatedMemoryIds
+      }
+    );
+  }
+  async restoreClaimBestEffort(claim) {
+    try {
+      return await this.writeClaimMemory(claim.sourceMemory ?? await this.getLedgerMemoryById(claim.id), claim, {
+        actor: this.source
+      });
+    } catch {
+      return false;
+    }
+  }
+  async writeSupersessionCorrectionBestEffort(prior, next, reason) {
+    try {
+      await this.storage.writeMemory(
+        "correction",
+        `Superseded: ${prior.statement}
+
+Replacement: ${next.statement}
+
+Reason: ${reason}`,
+        {
+          actor: this.source,
+          confidence: 1,
+          tags: ["belief-ledger:audit", "supersession", "auto-resolved"],
+          source: this.source,
+          lineage: [prior.id, next.id]
+        }
+      );
+    } catch {
+    }
+  }
+  claimFromMemorySafely(memory) {
+    if (!memory) return null;
+    try {
+      return claimFromMemory(memory);
+    } catch {
+      return null;
+    }
+  }
+  async writeEntityLinksBestEffort(claim) {
+    if (!this.shouldWriteEntityLinks) return;
+    try {
+      await this.writeEntityLinks(claim);
+    } catch {
+    }
+  }
+  async writeEntityLinks(claim) {
+    const timestamp = normalizeIsoTimestamp("createdAt", claim.createdAt);
+    for (const entity of claim.scope.entities) {
+      await this.storage.writeEntity(entity, "topic", [], {
+        timestamp,
+        source: this.source,
+        structuredSections: [
+          {
+            key: "belief-ledger",
+            title: "Belief Ledger",
+            facts: beliefLedgerEntityFacts(claim)
+          }
+        ]
+      });
+    }
+  }
+};
+function beliefLedgerEntityFacts(claim) {
+  const prefix = `claim=${claim.id}; status=${claim.status}; updatedAt=${claim.updatedAt}`;
+  return [
+    `${prefix}; ${claim.kind}: ${claim.statement}`,
+    `${prefix}; stance=${claim.stance}; confidence=${claim.confidence}`
+  ];
+}
+
+// src/retrieval.ts
+var DEFAULT_LIMIT = 8;
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "by",
+  "for",
+  "from",
+  "has",
+  "have",
+  "i",
+  "in",
+  "is",
+  "it",
+  "of",
+  "on",
+  "or",
+  "that",
+  "the",
+  "this",
+  "to",
+  "was",
+  "were",
+  "will",
+  "with"
+]);
+async function retrievePriorClaims(query, store, options = {}) {
+  const limit = normalizeLimit(options.limit);
+  const referenceTimeMs = Date.parse(normalizeIsoTimestamp("retrieval.now", options.now ?? query.createdAt));
+  const includeStatuses = options.includeStatuses ?? ["active", "snoozed"];
+  const claims = (await store.listClaims({ statuses: includeStatuses })).filter((claim) => claim.id !== query.id).filter((claim) => isRetrievableAt(claim, referenceTimeMs));
+  const semanticScores = options.semantic ? await collectSemanticScores(query, claims, limit, options) : /* @__PURE__ */ new Map();
+  const candidates = claims.map((claim) => scoreCandidate(query, claim, semanticScores.get(claim.id), referenceTimeMs)).filter((candidate) => candidate.score > 0).sort(compareCandidates);
+  const sliced = candidates.slice(0, limit);
+  if (!options.reranker) return sliced;
+  const reranked = await options.reranker.rerank({ query, candidates: sliced, limit });
+  return reranked.slice(0, limit);
+}
+function isRetrievableAt(claim, referenceTimeMs) {
+  if (claim.status !== "snoozed" || !claim.snoozedUntil) return true;
+  return Date.parse(claim.snoozedUntil) <= referenceTimeMs;
+}
+function scoreCandidate(query, claim, semanticScore, referenceTimeMs) {
+  let score = 0;
+  let hasTopicalMatch = false;
+  const reasons = [];
+  const lexical = jaccard(tokenize(query.statement), tokenize(claim.statement));
+  if (lexical > 0) {
+    hasTopicalMatch = true;
+    const lexicalScore = lexical * 4;
+    score += lexicalScore;
+    reasons.push(`lexical:${round(lexicalScore)}`);
+  }
+  const entityOverlap = overlap(query.scope.entities.map(normalizeText), claim.scope.entities.map(normalizeText));
+  if (entityOverlap > 0) {
+    hasTopicalMatch = true;
+    const entityScore = entityOverlap * 3;
+    score += entityScore;
+    reasons.push(`entity:${entityOverlap}`);
+  }
+  if (query.scope.domain && claim.scope.domain && normalizeText(query.scope.domain) === normalizeText(claim.scope.domain)) {
+    hasTopicalMatch = true;
+    score += 2;
+    reasons.push("domain");
+  }
+  if (query.stance !== claim.stance && query.stance !== "uncertain" && claim.stance !== "uncertain") {
+    score += 1;
+    reasons.push("stance-diff");
+  }
+  const recency = recencyScore(claim.updatedAt, referenceTimeMs);
+  if (recency > 0) {
+    score += recency;
+    reasons.push(`recency:${round(recency)}`);
+  }
+  if (semanticScore !== void 0) {
+    const semantic = Math.max(0, Math.min(1, semanticScore)) * 5;
+    if (semantic > 0) hasTopicalMatch = true;
+    score += semantic;
+    reasons.push(`semantic:${round(semantic)}`);
+  }
+  return { claim, score: hasTopicalMatch ? round(score) : 0, reasons };
+}
+function compareCandidates(a, b) {
+  const scoreOrder = b.score - a.score;
+  if (scoreOrder !== 0) return scoreOrder;
+  const updatedOrder = Date.parse(b.claim.updatedAt) - Date.parse(a.claim.updatedAt);
+  if (updatedOrder !== 0) return updatedOrder;
+  return a.claim.id.localeCompare(b.claim.id);
+}
+async function collectSemanticScores(query, candidates, limit, options) {
+  const result = /* @__PURE__ */ new Map();
+  if (!options.semantic || candidates.length === 0) return result;
+  const scored = await options.semantic.scoreClaims({ query, candidates, limit });
+  for (const item of scored) {
+    if (!item.claimId.trim()) continue;
+    if (!Number.isFinite(item.score)) continue;
+    result.set(item.claimId, Math.max(0, Math.min(1, item.score)));
+  }
+  return result;
+}
+function normalizeLimit(value) {
+  if (value === void 0) return DEFAULT_LIMIT;
+  if (!Number.isInteger(value) || value < 1 || value > 100) {
+    throw new Error(`retrieval limit must be an integer in [1, 100], got ${String(value)}`);
+  }
+  return value;
+}
+function tokenize(value) {
+  return normalizeText(value).split(/\s+/).filter((token) => token.length >= 2).filter((token) => !STOPWORDS.has(token));
+}
+function normalizeText(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+function jaccard(left, right) {
+  if (left.length === 0 || right.length === 0) return 0;
+  const leftSet = new Set(left);
+  const rightSet = new Set(right);
+  let intersection = 0;
+  for (const token of leftSet) {
+    if (rightSet.has(token)) intersection += 1;
+  }
+  const union = (/* @__PURE__ */ new Set([...leftSet, ...rightSet])).size;
+  return union === 0 ? 0 : intersection / union;
+}
+function overlap(left, right) {
+  const rightSet = new Set(right.filter(Boolean));
+  let count = 0;
+  for (const item of new Set(left.filter(Boolean))) {
+    if (rightSet.has(item)) count += 1;
+  }
+  return count;
+}
+function recencyScore(updatedAt, referenceTimeMs) {
+  const ageMs = referenceTimeMs - Date.parse(updatedAt);
+  if (!Number.isFinite(ageMs) || ageMs < 0) return 0;
+  const ageDays = ageMs / (24 * 60 * 60 * 1e3);
+  if (ageDays > 365) return 0;
+  return (365 - ageDays) / 365;
+}
+function round(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+
+// src/ledger.ts
+var BeliefLedger = class _BeliefLedger {
+  store;
+  llm;
+  retrieval;
+  now;
+  constructor(options) {
+    this.store = options.store;
+    this.llm = options.llm;
+    this.retrieval = options.retrieval ?? {};
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  static fromStorage(storage, options) {
+    return new _BeliefLedger({
+      store: new RemnicLedgerStore(storage, options),
+      llm: options.llm,
+      retrieval: options.retrieval,
+      now: options.now
+    });
+  }
+  async capture(input) {
+    const now = normalizeIsoTimestamp("now", input.now ?? this.now().toISOString());
+    const draft = await this.llm.extractClaim({ ...input, now });
+    const normalized = normalizeClaimDraft(draft, { now, sourceText: input.text });
+    const claim = await this.store.createClaim(normalized);
+    const examination = await this.crossExamine(claim, { now });
+    return { ...examination, claim };
+  }
+  async crossExamine(claimOrId, options = {}) {
+    const claim = typeof claimOrId === "string" ? await this.requireClaim(claimOrId) : claimOrId;
+    const retrievalOptions = {
+      ...this.retrieval,
+      ...options,
+      now: options.now ?? this.retrieval.now ?? this.now().toISOString()
+    };
+    const candidates = await retrievePriorClaims(claim, this.store, retrievalOptions);
+    const judgments = [];
+    for (const candidate of candidates) {
+      const judgment = await this.llm.judgeClaimPair({
+        current: claim,
+        prior: candidate.claim
+      });
+      judgments.push({
+        ...judgment,
+        priorClaimId: candidate.claim.id
+      });
+    }
+    const contradictions = judgments.map((judgment) => ({
+      judgment,
+      claim: candidates.find((candidate) => candidate.claim.id === judgment.priorClaimId)?.claim
+    })).filter(
+      (item) => item.claim !== void 0 && item.judgment.classification === "contradiction"
+    );
+    const challenge = contradictions.length > 0 ? await this.llm.draftSocraticChallenge({
+      current: claim,
+      contradictions
+    }) : void 0;
+    return {
+      claim,
+      candidates,
+      judgments,
+      ...challenge ? { challenge } : {},
+      stats: buildCrossExaminationStats(judgments)
+    };
+  }
+  async supersede(priorId, newId, reason) {
+    return this.store.supersedeClaim(priorId, newId, reason);
+  }
+  async split(priorId, parts, reason = "split into narrower claims") {
+    if (parts.length === 0) {
+      throw new Error("split requires at least one part");
+    }
+    const prior = await this.requireClaim(priorId);
+    const now = this.now().toISOString();
+    const normalizedParts = parts.map((part) => ({
+      ...normalizeClaimDraft(part, {
+        now,
+        sourceText: prior.sourceText ?? prior.statement
+      }),
+      parentIds: [priorId]
+    }));
+    const created = [];
+    try {
+      for (const part of normalizedParts) {
+        created.push(await this.store.createClaim(part));
+      }
+    } catch (error) {
+      await rollbackCreatedSplitClaims(this.store, created, now, `split creation failed for ${priorId}`);
+      throw error;
+    }
+    const firstReplacement = created[0];
+    let didSupersede = false;
+    try {
+      didSupersede = await this.store.supersedeClaim(priorId, firstReplacement.id, reason);
+    } catch (error) {
+      await rollbackCreatedSplitClaims(this.store, created, now, `split supersession failed for ${priorId}`);
+      throw error;
+    }
+    if (!didSupersede) {
+      await rollbackCreatedSplitClaims(this.store, created, now, `split supersession failed for ${priorId}`);
+      throw new Error(`split could not supersede prior claim ${priorId} with ${firstReplacement.id}`);
+    }
+    const linkedFirst = await this.store.getClaim(firstReplacement.id);
+    if (!linkedFirst) {
+      throw new Error(`split replacement claim ${firstReplacement.id} disappeared after supersession`);
+    }
+    created[0] = linkedFirst;
+    return created;
+  }
+  async resolve(claimId, input) {
+    const claim = await this.requireClaim(claimId);
+    const resolvedAt = normalizeIsoTimestamp("resolvedAt", input.resolvedAt ?? this.now().toISOString());
+    const resolution = createResolution({
+      verdict: input.verdict,
+      actualConfidence: input.actualConfidence,
+      resolvedAt,
+      source: input.source,
+      notes: input.notes,
+      predictedConfidence: claim.confidence
+    });
+    return this.store.updateClaim(claimId, {
+      status: "resolved",
+      resolution,
+      updatedAt: resolvedAt
+    });
+  }
+  async snooze(claimId, until) {
+    const snoozedUntil = normalizeIsoTimestamp("snoozedUntil", until);
+    return this.store.updateClaim(claimId, {
+      status: "snoozed",
+      snoozedUntil,
+      updatedAt: this.now().toISOString()
+    });
+  }
+  async ignore(claimId, reason) {
+    const ignoredAt = this.now().toISOString();
+    return this.store.updateClaim(claimId, {
+      status: "ignored",
+      ignoredAt,
+      ...reason?.trim() ? { ignoredReason: reason.trim() } : {},
+      updatedAt: ignoredAt
+    });
+  }
+  async scoreDuePredictions(options = {}) {
+    const now = normalizeIsoTimestamp("now", options.now ?? this.now().toISOString());
+    const limit = normalizeLimit2(options.limit);
+    const verdictSources = options.verdictSources ?? {};
+    const due = (await this.store.listClaims({ kinds: ["prediction"], statuses: ["active", "snoozed"] })).filter((claim) => isDueForScoring(claim, now)).sort(compareDuePredictions).slice(0, limit);
+    const results = [];
+    for (const claim of due) {
+      const verdictSource = verdictSources[claim.id];
+      if (!verdictSource?.trim()) {
+        results.push({
+          claim,
+          status: "needs_user_verdict",
+          prompt: `Prediction deadline passed: "${claim.statement}". What actually happened?`
+        });
+        continue;
+      }
+      if (!this.llm.gradePrediction) {
+        results.push({
+          claim,
+          status: "needs_user_verdict",
+          prompt: `Prediction deadline passed: "${claim.statement}". Provide a verdict because no grader is configured.`
+        });
+        continue;
+      }
+      try {
+        const grade = await this.llm.gradePrediction({ claim, verdictSource, now });
+        if (!grade) {
+          results.push({
+            claim,
+            status: "needs_user_verdict",
+            prompt: `Prediction deadline passed: "${claim.statement}". The verdict source was not enough to grade it.`
+          });
+          continue;
+        }
+        const resolution = createResolution({
+          verdict: grade.verdict,
+          actualConfidence: grade.actualConfidence,
+          resolvedAt: now,
+          source: grade.source ?? verdictSource,
+          notes: grade.rationale,
+          predictedConfidence: claim.confidence
+        });
+        const updated = await this.store.updateClaim(claim.id, {
+          status: "resolved",
+          resolution,
+          updatedAt: now
+        });
+        results.push({
+          claim: updated,
+          status: "resolved",
+          resolution
+        });
+      } catch (error) {
+        results.push({
+          claim,
+          status: "skipped",
+          reason: `prediction scoring failed: ${errorMessage(error)}`
+        });
+      }
+    }
+    return results;
+  }
+  async reflect(options = {}) {
+    const claims = await this.store.listClaims();
+    return buildReflectionReport(claims, {
+      ...options,
+      now: options.now ?? this.now().toISOString()
+    });
+  }
+  async requireClaim(id) {
+    const claim = await this.store.getClaim(id);
+    if (!claim) {
+      throw new Error(`claim ${id} not found`);
+    }
+    return claim;
+  }
+};
+function buildCrossExaminationStats(judgments) {
+  const judged = judgments.length;
+  const contradictions = judgments.filter((judgment) => judgment.classification === "contradiction").length;
+  const unrelated = judgments.filter((judgment) => judgment.classification === "unrelated").length;
+  return {
+    candidatesConsidered: judged,
+    judged,
+    contradictions,
+    unrelated,
+    observableFalsePositiveRate: judged === 0 ? 0 : unrelated / judged
+  };
+}
+async function rollbackCreatedSplitClaims(store, claims, now, ignoredReason) {
+  for (const claim of claims) {
+    try {
+      await store.updateClaim(claim.id, {
+        status: "ignored",
+        ignoredAt: now,
+        ignoredReason,
+        updatedAt: now
+      });
+    } catch {
+    }
+  }
+}
+function isDueForScoring(claim, nowIso) {
+  if (!claim.deadline) return false;
+  if (claim.resolution) return false;
+  if (claim.status === "snoozed" && claim.snoozedUntil && Date.parse(claim.snoozedUntil) > Date.parse(nowIso)) {
+    return false;
+  }
+  return Date.parse(claim.deadline) <= Date.parse(nowIso);
+}
+function compareDuePredictions(a, b) {
+  const aDeadline = a.deadline ? Date.parse(a.deadline) : Number.POSITIVE_INFINITY;
+  const bDeadline = b.deadline ? Date.parse(b.deadline) : Number.POSITIVE_INFINITY;
+  const deadlineOrder = aDeadline - bDeadline;
+  if (deadlineOrder !== 0) return deadlineOrder;
+  const updatedOrder = Date.parse(a.updatedAt) - Date.parse(b.updatedAt);
+  if (updatedOrder !== 0) return updatedOrder;
+  return a.id.localeCompare(b.id);
+}
+function normalizeLimit2(value) {
+  if (value === void 0) return 100;
+  if (!Number.isInteger(value) || value < 1 || value > 1e3) {
+    throw new Error(`limit must be an integer in [1, 1000], got ${String(value)}`);
+  }
+  return value;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/llm.ts
+function createFallbackLlmLedgerAdapter(client, options = {}) {
+  const baseOptions = { ...options };
+  return {
+    async extractClaim(request) {
+      const parsed = await client.parseWithSchema(
+        [
+          { role: "system", content: EXTRACT_PROMPT },
+          {
+            role: "user",
+            content: [
+              `Current time: ${request.now}`,
+              request.sessionKey ? `Session: ${request.sessionKey}` : "",
+              "User text:",
+              request.text
+            ].filter(Boolean).join("\n")
+          }
+        ],
+        {
+          parse: (data) => normalizeExtractedDraft(data, request.now, request.text)
+        },
+        { ...baseOptions, temperature: baseOptions.temperature ?? 0.1, maxTokens: baseOptions.maxTokens ?? 1200 }
+      );
+      if (!parsed) {
+        throw new Error("belief-ledger extraction LLM did not return a valid claim");
+      }
+      return parsed;
+    },
+    async judgeClaimPair(request) {
+      const parsed = await client.parseWithSchema(
+        [
+          { role: "system", content: JUDGE_PROMPT },
+          { role: "user", content: formatJudgeInput(request.current, request.prior) }
+        ],
+        {
+          parse: (data) => normalizeJudgeResult(data, request.prior.id)
+        },
+        { ...baseOptions, temperature: baseOptions.temperature ?? 0.1, maxTokens: baseOptions.maxTokens ?? 800 }
+      );
+      if (!parsed) {
+        throw new Error("belief-ledger judge LLM did not return a valid verdict");
+      }
+      return parsed;
+    },
+    async draftSocraticChallenge(request) {
+      const priorClaimIds = request.contradictions.map((item) => item.claim.id);
+      const parsed = await client.parseWithSchema(
+        [
+          { role: "system", content: CHALLENGE_PROMPT },
+          {
+            role: "user",
+            content: [
+              "Current claim:",
+              formatClaim(request.current),
+              "",
+              "Contradicting prior claims:",
+              ...request.contradictions.map(
+                (item) => `${formatClaim(item.claim)}
+Judge rationale: ${item.judgment.rationale}`
+              )
+            ].join("\n")
+          }
+        ],
+        {
+          parse: (data) => normalizeChallenge(data, priorClaimIds)
+        },
+        { ...baseOptions, temperature: baseOptions.temperature ?? 0.2, maxTokens: baseOptions.maxTokens ?? 800 }
+      );
+      if (!parsed) {
+        throw new Error("belief-ledger challenge LLM did not return a valid prompt");
+      }
+      return parsed;
+    },
+    async gradePrediction(request) {
+      if (!request.verdictSource?.trim()) return null;
+      const parsed = await client.parseWithSchema(
+        [
+          { role: "system", content: GRADE_PROMPT },
+          {
+            role: "user",
+            content: [
+              `Current time: ${request.now}`,
+              "Prediction:",
+              formatClaim(request.claim),
+              "",
+              "Verdict source:",
+              request.verdictSource
+            ].join("\n")
+          }
+        ],
+        {
+          parse: (data) => normalizePredictionGrade(data)
+        },
+        { ...baseOptions, temperature: baseOptions.temperature ?? 0.1, maxTokens: baseOptions.maxTokens ?? 800 }
+      );
+      return parsed;
+    }
+  };
+}
+var EXTRACT_PROMPT = `Extract one belief-ledger claim from the user's text.
+
+Return JSON only:
+{
+  "statement": "single clear claim or prediction",
+  "kind": "claim" | "prediction" | "opinion",
+  "stance": "for" | "against" | "uncertain" | "neutral",
+  "confidence": 0.0,
+  "scope": {
+    "entities": ["entity names"],
+    "domain": "optional topic",
+    "timeWindow": { "start": "optional ISO", "end": "optional ISO" }
+  },
+  "deadline": "optional ISO timestamp for predictions",
+  "evidenceLinks": ["optional source URLs or identifiers"]
+}
+
+Use the user's stated confidence when present. If no confidence is stated, estimate conservatively.`;
+var JUDGE_PROMPT = `Classify how the current claim relates to the prior claim.
+
+Return JSON only:
+{
+  "classification": "contradiction" | "evolution" | "refinement" | "unrelated",
+  "confidence": 0.0,
+  "rationale": "brief reason"
+}
+
+Use "contradiction" only when both claims cannot comfortably be true at the same time under their stated scope.`;
+var CHALLENGE_PROMPT = `Draft one concise Socratic challenge for the user.
+
+Return JSON only:
+{
+  "question": "one question asking the user to reconcile the conflict",
+  "priorClaimIds": ["ids involved"],
+  "suggestedActions": ["supersede", "split", "resolve", "ignore"]
+}
+
+Do not agree with the user by default. Ask for a reconciliation decision.`;
+var GRADE_PROMPT = `Grade whether the prediction came true from the supplied verdict source.
+
+Return JSON only:
+{
+  "verdict": "true" | "false" | "mixed" | "unknown",
+  "actualConfidence": 0.0,
+  "rationale": "brief reason",
+  "source": "short source label"
+}
+
+Use actualConfidence 1 for true, 0 for false, a fractional value for mixed, and 0.5 for unknown.`;
+function normalizeExtractedDraft(data, now, sourceText) {
+  if (!isRecord2(data)) {
+    throw new Error("claim extraction result must be an object");
+  }
+  const scope = isRecord2(data.scope) ? data.scope : {};
+  const rawTimeWindow = isRecord2(scope.timeWindow) ? scope.timeWindow : isRecord2(scope.time_window) ? scope.time_window : void 0;
+  const draft = {
+    statement: asString(data.statement),
+    kind: optionalString(data.kind),
+    stance: asString(data.stance),
+    confidence: asNumber(data.confidence),
+    scope: {
+      entities: Array.isArray(scope.entities) ? scope.entities.filter((value) => typeof value === "string") : [],
+      ...typeof scope.domain === "string" ? { domain: scope.domain } : {},
+      ...rawTimeWindow ? {
+        timeWindow: {
+          ...typeof rawTimeWindow.start === "string" ? { start: rawTimeWindow.start } : {},
+          ...typeof rawTimeWindow.end === "string" ? { end: rawTimeWindow.end } : {}
+        }
+      } : {}
+    },
+    ...typeof data.deadline === "string" && data.deadline.trim() ? { deadline: data.deadline } : {},
+    evidenceLinks: Array.isArray(data.evidenceLinks) ? data.evidenceLinks.filter((value) => typeof value === "string") : Array.isArray(data.evidence_links) ? data.evidence_links.filter((value) => typeof value === "string") : []
+  };
+  const normalized = normalizeClaimDraft(draft, { now, sourceText });
+  return {
+    statement: normalized.statement,
+    kind: normalized.kind,
+    stance: normalized.stance,
+    confidence: normalized.confidence,
+    scope: normalized.scope,
+    ...normalized.deadline ? { deadline: normalized.deadline } : {},
+    evidenceLinks: normalized.evidenceLinks
+  };
+}
+function formatJudgeInput(current, prior) {
+  return ["Current claim:", formatClaim(current), "", "Prior claim:", formatClaim(prior)].join("\n");
+}
+function formatClaim(claim) {
+  return [
+    `id: ${claim.id}`,
+    `created: ${claim.createdAt}`,
+    `statement: ${claim.statement}`,
+    `kind: ${claim.kind}`,
+    `stance: ${claim.stance}`,
+    `confidence: ${claim.confidence}`,
+    `domain: ${claim.scope.domain ?? ""}`,
+    `entities: ${claim.scope.entities.join(", ")}`,
+    `timeWindow.start: ${claim.scope.timeWindow?.start ?? ""}`,
+    `timeWindow.end: ${claim.scope.timeWindow?.end ?? ""}`,
+    `deadline: ${claim.deadline ?? ""}`,
+    `status: ${claim.status}`
+  ].join("\n");
+}
+function asString(value) {
+  if (typeof value !== "string") {
+    throw new Error("expected string");
+  }
+  return value;
+}
+function optionalString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function asNumber(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string" && value.trim()) return Number(value);
+  throw new Error("expected number");
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export {
+  BeliefLedger,
+  LEDGER_SCHEMA_VERSION,
+  LEDGER_TAG,
+  RemnicLedgerStore,
+  buildReflectionReport,
+  claimFromMemory,
+  claimTags,
+  claimToStructuredAttributes,
+  computeBrierScore,
+  createFallbackLlmLedgerAdapter,
+  createResolution,
+  memoryFrontmatterPatchForClaim,
+  normalizeChallenge,
+  normalizeClaimDraft,
+  normalizeIsoTimestamp,
+  normalizeJudgeResult,
+  normalizePredictionGrade,
+  remnicMemoryStatusForClaim,
+  retrievePriorClaims,
+  roundMetric,
+  serializeClaimBody
+};
+//# sourceMappingURL=index.js.map