@remnic/core 10.0.92 → 10.0.93

package/dist/{chunk-B4QYQFGY.js → chunk-UBEKET2V.js}

@@ -11,6 +11,9 @@ import {
 import {
   parseLocationConfig
 } from "./chunk-QNJQCLI6.js";
+import {
+  parseCodingKnowledgeConfig
+} from "./chunk-FEHIOYML.js";
 import {
   PRE_ACTION_GATE_DEFAULT_TIMEOUT_MS,
   normalizeActionIntent,
@@ -18,7 +21,7 @@ import {
 } from "./chunk-CIEEYVUB.js";
 import {
   parseSubjectRuntimeConfig
-} from "./chunk-WYG5UNDY.js";
+} from "./chunk-3AUDELZL.js";
 import {
   parseRecallStandingBlock,
   parseStandingBlockFreshDays,
@@ -34,15 +37,24 @@ import {
   parseRecallRecognitionTier,
   parseRecognitionIndexMaxEntries
 } from "./chunk-4KQIWY4A.js";
+import {
+  parseRecallStateViews
+} from "./chunk-EH3HNCAM.js";
+import {
+  parseRecallNavigationConfig
+} from "./chunk-LVTT5AUG.js";
 import {
   parseRecallConcurrencyConfig
 } from "./chunk-6ZMAMSHS.js";
 import {
   parseProjectionRebuildScheduleConfig
 } from "./chunk-EWMRFW3F.js";
+import {
+  parseReplicaPeersConfig
+} from "./chunk-WNIUPHWV.js";
 import {
   parseLocalLlmConfig
-} from "./chunk-O6ZSWHVR.js";
+} from "./chunk-C2KE5DMD.js";
 import {
   parseGraphPathScoringConfig
 } from "./chunk-6ZN34ISG.js";
@@ -56,6 +68,9 @@ import {
 import {
   parseExternalWikiRoots
 } from "./chunk-NDNTNE3S.js";
+import {
+  parseExternalWikiRecallGuard
+} from "./chunk-JV3C2MNQ.js";
 import {
   resolveEmitLegacyTools,
   resolveNamespaceCatalogEnabled
@@ -63,6 +78,9 @@ import {
 import {
   parseDependencyPropagationConfig
 } from "./chunk-VUDMT5CP.js";
+import {
+  parseDeepRecallConfig
+} from "./chunk-IEEV27BC.js";
 import {
   parseContradictionLocalizationConfig,
   parseContradictionScanConfig
@@ -81,37 +99,6 @@ import {
 import {
   parseSecurityConfig
 } from "./chunk-G2XTGEGL.js";
-import {
-  parseBoundedJsonlStateConfig
-} from "./chunk-KFZY2OFH.js";
-import {
-  parseActiveContextFields
-} from "./chunk-B32WYRXX.js";
-import {
-  parseBackgroundGeneration
-} from "./chunk-27NO2KVB.js";
-import {
-  MEMORY_CATEGORIES,
-  parseCorrectionConfig
-} from "./chunk-ETSJD5IV.js";
-import {
-  parseCodingKnowledgeConfig
-} from "./chunk-FEHIOYML.js";
-import {
-  parseRecallStateViews
-} from "./chunk-EH3HNCAM.js";
-import {
-  parseRecallNavigationConfig
-} from "./chunk-LVTT5AUG.js";
-import {
-  parseReplicaPeersConfig
-} from "./chunk-WNIUPHWV.js";
-import {
-  parseExternalWikiRecallGuard
-} from "./chunk-JV3C2MNQ.js";
-import {
-  parseDeepRecallConfig
-} from "./chunk-IEEV27BC.js";
 import {
   parseSkillProjectionConfig
 } from "./chunk-236PXYG7.js";
@@ -128,12 +115,21 @@ import {
   normalizeRecallTokenSet,
   normalizeRecallTokens
 } from "./chunk-YCVB7X56.js";
+import {
+  parseBoundedJsonlStateConfig
+} from "./chunk-KFZY2OFH.js";
+import {
+  parseActiveContextFields
+} from "./chunk-B32WYRXX.js";
 import {
   coerceBool,
   coerceBooleanLike,
   coerceInstallExtension,
   coerceNumber
 } from "./chunk-PQVCH2AE.js";
+import {
+  parseBackgroundGeneration
+} from "./chunk-27NO2KVB.js";
 import {
   parseConvergeConfig
 } from "./chunk-EHHQJTAU.js";
@@ -142,10 +138,10 @@ import {
 } from "./chunk-7RJUVTVF.js";
 import {
   excludeSupportPassportPrivateMemories
-} from "./chunk-YCNIGRRF.js";
+} from "./chunk-NS7U4ZYU.js";
 import {
   STRUCTURED_ATTRIBUTE_LIMITS
-} from "./chunk-QEYTRFR3.js";
+} from "./chunk-X26YOFGS.js";
 import {
   parseOfflineSyncExcludes
 } from "./chunk-63LFM77Z.js";
@@ -172,6 +168,80 @@ import {
 // src/config.ts
 import path2 from "path";
 
+// src/correction/correction-config.ts
+var DEFAULT_CORRECTION_CLASSIFY_TIMEOUT_MS = 45e3;
+var MAX_CORRECTION_CLASSIFY_TIMEOUT_MS = 3e5;
+function parseCorrectionConfig(cfg) {
+  return {
+    correctionEnabled: (() => {
+      const nested = cfg.correction?.enabled;
+      const raw = nested !== void 0 ? nested : cfg.correctionEnabled;
+      if (raw === void 0 || raw === null) return true;
+      const value = coerceBool(raw);
+      if (value === void 0) {
+        throw new Error(`Invalid correction.enabled: expected a boolean, got ${JSON.stringify(raw)}`);
+      }
+      return value;
+    })(),
+    correctionApplyRequiresConfirm: (() => {
+      const nested = cfg.correction?.applyRequiresConfirm;
+      const raw = nested !== void 0 ? nested : cfg.correctionApplyRequiresConfirm;
+      if (raw === void 0 || raw === null) return true;
+      const value = coerceBool(raw);
+      if (value === void 0) {
+        throw new Error(`Invalid correction.applyRequiresConfirm: expected a boolean, got ${JSON.stringify(raw)}`);
+      }
+      return value;
+    })(),
+    correctionMaxAffected: (() => {
+      const rawNested = cfg.correction?.maxAffected;
+      const raw = rawNested !== void 0 ? rawNested : cfg.correctionMaxAffected;
+      if (raw === void 0 || raw === null) return 10;
+      const n = coerceNumber(raw);
+      if (n === void 0 || !Number.isFinite(n) || n < 1 || !Number.isInteger(n)) {
+        throw new Error(`Invalid correction.maxAffected: expected an integer >= 1, got ${JSON.stringify(raw)}`);
+      }
+      return n;
+    })(),
+    correctionPlanTtlHours: (() => {
+      const nested = cfg.correction?.planTtlHours;
+      const fromNested = nested !== void 0 ? coerceNumber(nested) : void 0;
+      if (fromNested !== void 0 && fromNested >= 1) return fromNested;
+      if (nested !== void 0 && fromNested === void 0) {
+        throw new Error(`Invalid correction.planTtlHours: expected a number >= 1, got ${JSON.stringify(nested)}`);
+      }
+      if (fromNested !== void 0 && fromNested < 1) {
+        throw new Error(`Invalid correction.planTtlHours: expected a number >= 1, got ${JSON.stringify(nested)}`);
+      }
+      const fromFlat = coerceNumber(cfg.correctionPlanTtlHours);
+      if (fromFlat !== void 0 && fromFlat >= 1) return fromFlat;
+      if (cfg.correctionPlanTtlHours !== void 0 && fromFlat === void 0) {
+        throw new Error(
+          `Invalid correction.planTtlHours: expected a number >= 1, got ${JSON.stringify(cfg.correctionPlanTtlHours)}`
+        );
+      }
+      if (fromFlat !== void 0 && fromFlat < 1) {
+        throw new Error(
+          `Invalid correction.planTtlHours: expected a number >= 1, got ${JSON.stringify(cfg.correctionPlanTtlHours)}`
+        );
+      }
+      return 24;
+    })(),
+    correctionClassifyTimeoutMs: (() => {
+      const nested = cfg.correction?.classifyTimeoutMs;
+      const raw = nested !== void 0 ? nested : cfg.correctionClassifyTimeoutMs;
+      if (raw === void 0 || raw === null) return DEFAULT_CORRECTION_CLASSIFY_TIMEOUT_MS;
+      const n = coerceNumber(raw);
+      if (n === void 0 || !Number.isInteger(n) || n < 1 || n > MAX_CORRECTION_CLASSIFY_TIMEOUT_MS) {
+        throw new Error(
+          `Invalid correction.classifyTimeoutMs: expected an integer from 1 to ${MAX_CORRECTION_CLASSIFY_TIMEOUT_MS}, got ${JSON.stringify(raw)}`
+        );
+      }
+      return n;
+    })()
+  };
+}
+
 // src/procedural/maintenance-config.ts
 function parseProceduralMaintenanceConfig(raw) {
   if (raw !== void 0 && (raw === null || typeof raw !== "object" || Array.isArray(raw))) {
@@ -1115,6 +1185,274 @@ async function applyNoveltyGate(opts) {
   }
 }
 
+// src/correction/correction-contract.ts
+var MEMORY_CATEGORIES = [
+  "fact",
+  "preference",
+  "correction",
+  "entity",
+  "decision",
+  "relationship",
+  "principle",
+  "commitment",
+  "moment",
+  "skill",
+  "rule",
+  "procedure",
+  "reasoning_trace"
+];
+var CORRECTION_ACTION_KINDS = [
+  "supersede",
+  "edit",
+  "retract",
+  "rescope",
+  "redaction_rule"
+];
+var CORRECTION_TEXT_MAX = 1e4;
+var REDACTION_PATTERN_MAX = 256;
+var CORRECTION_MEMORY_ID_MAX = 512;
+function validateCorrectionRequest(request) {
+  if (!request || typeof request !== "object") {
+    throw new CorrectionContractError("CorrectionRequest must be an object.");
+  }
+  const text = typeof request.text === "string" ? request.text.trim() : "";
+  if (text.length === 0) {
+    throw new CorrectionContractError("CorrectionRequest.text is required and must be non-empty.");
+  }
+  if (text.length > CORRECTION_TEXT_MAX) {
+    throw new CorrectionContractError(
+      `CorrectionRequest.text exceeds the ${CORRECTION_TEXT_MAX}-character limit (${text.length}).`
+    );
+  }
+  const targetIds = Array.isArray(request.targetIds) ? request.targetIds.filter((id) => typeof id === "string" && id.length > 0) : void 0;
+  const normalizedTargets = targetIds !== void 0 && targetIds.length === 0 ? void 0 : targetIds;
+  const duplicateOf = readDuplicateOf(request.duplicateOf);
+  if (duplicateOf) {
+    if (!normalizedTargets || normalizedTargets.length !== 1) {
+      throw new CorrectionContractError(
+        "CorrectionRequest.duplicateOf requires exactly one targetIds entry (the duplicate memory)."
+      );
+    }
+    if (normalizedTargets[0] === duplicateOf) {
+      throw new CorrectionContractError(
+        "CorrectionRequest.duplicateOf must be a different memory from targetIds."
+      );
+    }
+  }
+  return {
+    text,
+    ...normalizedTargets ? { targetIds: normalizedTargets } : {},
+    ...duplicateOf ? { duplicateOf } : {},
+    ...request.sessionKey ? { sessionKey: request.sessionKey } : {},
+    ...request.principal ? { principal: request.principal } : {},
+    ...request.namespace ? { namespace: request.namespace } : {}
+  };
+}
+function readDuplicateOf(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string") {
+    throw new CorrectionContractError("CorrectionRequest.duplicateOf must be a memory id string.");
+  }
+  const id = value.trim();
+  if (id.length === 0 || id !== value) {
+    throw new CorrectionContractError("CorrectionRequest.duplicateOf must be a non-empty memory id.");
+  }
+  if (id.length > CORRECTION_MEMORY_ID_MAX) {
+    throw new CorrectionContractError(
+      `CorrectionRequest.duplicateOf exceeds the ${CORRECTION_MEMORY_ID_MAX}-character limit (${id.length}).`
+    );
+  }
+  return id;
+}
+function validateRedactionPattern(pattern) {
+  if (typeof pattern !== "string") {
+    throw new CorrectionContractError("redaction_rule.pattern must be a string.");
+  }
+  const trimmed = pattern.trim();
+  if (trimmed.length === 0) {
+    throw new CorrectionContractError("redaction_rule.pattern is required.");
+  }
+  if (trimmed.length > REDACTION_PATTERN_MAX) {
+    throw new CorrectionContractError(
+      `redaction_rule.pattern exceeds the ${REDACTION_PATTERN_MAX}-character bound.`
+    );
+  }
+  if (isRegexLike(trimmed) && isUnsafeRedactionRegex(trimmed)) {
+    throw new CorrectionContractError(
+      "redaction_rule.pattern is unsafe \u2014 use a bounded literal or a regex without nested quantifiers / overlapping alternation."
+    );
+  }
+  if (isRegexLike(trimmed)) {
+    const regexBody = trimmed.slice(1, -1);
+    if (regexBody.length === 0) {
+      throw new CorrectionContractError("redaction_rule.pattern body is empty \u2014 use a non-empty regex.");
+    }
+    try {
+      if (new RegExp(regexBody).test("")) {
+        throw new CorrectionContractError(
+          "redaction_rule.pattern matches the empty string \u2014 it would withhold every fact."
+        );
+      }
+    } catch (e) {
+      if (e instanceof CorrectionContractError) throw e;
+    }
+  }
+  return trimmed;
+}
+function isRegexLike(pattern) {
+  return pattern.startsWith("/") && pattern.endsWith("/") && pattern.length >= 2;
+}
+function isUnsafeRedactionRegex(pattern) {
+  const body = pattern.startsWith("/") && pattern.endsWith("/") ? pattern.slice(1, -1) : pattern;
+  if (/(?:^|[^\\])\(\.\*\)|(?:^|[^\\])\.\*|(?:^|[^\\])\.\+|^\.([^*+]?)$/.test(body)) {
+    return true;
+  }
+  if (body.length > 512) return true;
+  for (let i = 0; i < body.length; i++) {
+    if (body[i] !== "(") continue;
+    let depth = 1;
+    let j = i + 1;
+    while (j < body.length && depth > 0) {
+      if (body[j] === "\\") {
+        j += 2;
+        continue;
+      }
+      if (body[j] === "(") depth++;
+      else if (body[j] === ")") depth--;
+      j++;
+    }
+    if (depth !== 0) continue;
+    const afterGroup = body[j];
+    if (afterGroup !== "+" && afterGroup !== "*" && afterGroup !== "{") continue;
+    const groupBody = body.slice(i + 1, j - 1);
+    if (/[+*?]$/.test(groupBody) || /\{\d+,?\d*\}[+*?]?$/.test(groupBody)) {
+      return true;
+    }
+    if (groupBody.includes("|")) {
+      const branches = groupBody.split("|");
+      if (branches.length >= 2) {
+        const firstChars = new Set(branches.map((b) => b[0]).filter(Boolean));
+        if (firstChars.size < branches.filter((b) => b.length > 0).length) {
+          return true;
+        }
+      }
+    }
+    i = j;
+  }
+  return false;
+}
+function validateCorrectionAction(action) {
+  if (!action || typeof action !== "object") {
+    throw new CorrectionContractError("CorrectionAction must be an object.");
+  }
+  const a = action;
+  if (typeof a.kind !== "string" || !CORRECTION_ACTION_KINDS.includes(a.kind)) {
+    throw new CorrectionContractError(
+      `CorrectionAction.kind must be one of: ${CORRECTION_ACTION_KINDS.join(", ")}.`
+    );
+  }
+  switch (a.kind) {
+    case "supersede":
+      if (typeof a.loserId !== "string" || a.loserId.length === 0) {
+        throw new CorrectionContractError("supersede.loserId is required.");
+      }
+      {
+        const hasReplacement = a.replacement !== void 0 && a.replacement !== null;
+        const hasWinner = a.winnerId !== void 0 && a.winnerId !== null;
+        if (hasWinner) {
+          if (typeof a.winnerId !== "string" || a.winnerId.trim().length === 0 || a.winnerId !== a.winnerId.trim()) {
+            throw new CorrectionContractError("supersede.winnerId must be a non-empty memory id.");
+          }
+          if (a.winnerId === a.loserId) {
+            throw new CorrectionContractError("supersede.winnerId must differ from loserId.");
+          }
+          if (hasReplacement) {
+            throw new CorrectionContractError("supersede.winnerId cannot be combined with a replacement draft.");
+          }
+        }
+        if (hasReplacement) validateMemoryDraft(a.replacement);
+      }
+      break;
+    case "edit":
+      if (typeof a.memoryId !== "string" || a.memoryId.length === 0) {
+        throw new CorrectionContractError("edit.memoryId is required.");
+      }
+      if (typeof a.patch !== "string" || a.patch.length === 0) {
+        throw new CorrectionContractError("edit.patch is required and must be non-empty.");
+      }
+      break;
+    case "retract":
+      if (typeof a.memoryId !== "string" || a.memoryId.length === 0) {
+        throw new CorrectionContractError("retract.memoryId is required.");
+      }
+      break;
+    case "rescope":
+      if (typeof a.memoryId !== "string" || a.memoryId.length === 0) {
+        throw new CorrectionContractError("rescope.memoryId is required.");
+      }
+      if (typeof a.toNamespace !== "string" || a.toNamespace.trim().length === 0) {
+        throw new CorrectionContractError("rescope.toNamespace is required.");
+      }
+      break;
+    case "redaction_rule":
+      if (typeof a.pattern !== "string") {
+        throw new CorrectionContractError("redaction_rule.pattern is required.");
+      }
+      validateRedactionPattern(a.pattern);
+      break;
+  }
+}
+function validateMemoryDraft(draft) {
+  if (!draft || typeof draft !== "object") {
+    throw new CorrectionContractError("MemoryDraft must be an object.");
+  }
+  const d = draft;
+  if (typeof d.content !== "string" || d.content.trim().length === 0) {
+    throw new CorrectionContractError("MemoryDraft.content is required and must be non-empty.");
+  }
+  if (d.category !== void 0) {
+    if (typeof d.category !== "string" || !MEMORY_CATEGORIES.includes(d.category)) {
+      throw new CorrectionContractError(
+        `MemoryDraft.category must be one of: ${MEMORY_CATEGORIES.join(", ")}.`
+      );
+    }
+  }
+  if (d.confidence !== void 0 && (typeof d.confidence !== "number" || d.confidence < 0 || d.confidence > 1)) {
+    throw new CorrectionContractError("MemoryDraft.confidence must be a number in [0, 1].");
+  }
+  if (d.tags !== void 0 && !Array.isArray(d.tags)) {
+    throw new CorrectionContractError("MemoryDraft.tags must be an array.");
+  }
+  if (d.structuredAttributes !== void 0 && (typeof d.structuredAttributes !== "object" || d.structuredAttributes === null)) {
+    throw new CorrectionContractError("MemoryDraft.structuredAttributes must be an object.");
+  }
+}
+function deterministicFallbackPlan(args) {
+  return {
+    planId: newPlanId(),
+    request: args.request,
+    namespace: args.namespace,
+    affected: args.affected,
+    classification: "outdated",
+    actions: [],
+    diff: "",
+    confidence: 0,
+    warnings: [...args.warnings, "planner LLM unavailable \u2014 manual action selection required"],
+    createdAt: args.createdAt,
+    expiresAt: args.expiresAt,
+    status: "pending"
+  };
+}
+function newPlanId() {
+  return `corr-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+var CorrectionContractError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CorrectionContractError";
+  }
+};
+
 // src/dedup/merge-min-score.ts
 function describeValue(value) {
   try {
@@ -5469,6 +5807,15 @@ function parseTrustScoreWeights(value) {
 }
 
 export {
+  CORRECTION_TEXT_MAX,
+  validateCorrectionRequest,
+  validateRedactionPattern,
+  validateCorrectionAction,
+  deterministicFallbackPlan,
+  newPlanId,
+  CorrectionContractError,
+  DEFAULT_CORRECTION_CLASSIFY_TIMEOUT_MS,
+  MAX_CORRECTION_CLASSIFY_TIMEOUT_MS,
   DRIFT_DETECTION_DEFAULTS,
   parseDriftDetectionConfig,
   buildMergeFrontmatterUpdate,
@@ -5507,4 +5854,4 @@ export {
   VALID_MEMORY_CATEGORIES,
   parseConfig
 };
-//# sourceMappingURL=chunk-B4QYQFGY.js.map
+//# sourceMappingURL=chunk-UBEKET2V.js.map