@remnic/core 10.0.4 → 10.0.6

package/dist/chunk-QLK3SL7Q.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/correction/correction-contract.ts"],"sourcesContent":["/**\n * correction/correction-contract.ts — Types for the Correction Contract\n * (issue #1580).\n *\n * The Correction Contract is the SINGLE plan/apply pipeline every memory\n * correction flows through: supersession, invalidation, tombstone, edit,\n * rescope, redaction. A correction arrives as a plain-language statement\n * (\"we migrated to MySQL in March\"); the planner turns it into a structured\n * {@link CorrectionPlan}; the executor applies the plan in non-destructive\n * order through the existing storage/orchestrator chokepoints.\n *\n * This module is PURE types + validation helpers — no I/O, no side effects.\n * The planner and executor live in sibling modules and inject their own\n * collaborators so the contract is testable in isolation (rule 33).\n *\n * Design rules honored (issue #1580 design section):\n *   - Plans are per-request state on disk, never module-level (rules 11/47).\n *   - Caller-supplied namespaces are NEVER trusted raw — the service\n *     resolves them through the normal namespace policy (rule 42).\n *   - Bulk operations refuse past maxAffected (no silent truncation, §39).\n *   - `never_store` redaction patterns must be bounded and safe (§34).\n */\n\nimport type { MemoryCategory, MemoryFrontmatter } from \"../types.js\";\n\n// ---------------------------------------------------------------------------\n// Request\n// ---------------------------------------------------------------------------\n\n/**\n * The user-facing input: a plain-language correction plus optional explicit\n * targets. This is what every surface (MCP / HTTP / CLI) collects before\n * handing off to the planner.\n */\nexport interface CorrectionRequest {\n  /** Natural-language correction statement. Required, non-empty. */\n  text: string;\n  /**\n   * Explicit target memory ids (or handles via #1582). When present the\n   * planner resolves these directly; an unknown id is an explicit error\n   * (rule 34), never a silent empty plan. When absent the planner searches.\n   */\n  targetIds?: string[];\n  /** Session key for namespace/principal resolution. */\n  sessionKey?: string;\n  /** Authenticated principal (resolved by the service, never trusted raw). */\n  principal?: string;\n  /**\n   * Caller-suggested namespace. ALWAYS re-resolved through the namespace\n   * policy by the service before reaching the planner (rule 42). The\n   * planner only sees the ALREADY-AUTHORIZED namespace.\n   */\n  namespace?: string;\n}\n\n// ---------------------------------------------------------------------------\n// Classification + actions\n// ---------------------------------------------------------------------------\n\nexport type CorrectionClassification =\n  | \"wrong\"\n  | \"outdated\"\n  | \"incomplete\"\n  | \"wrong_scope\"\n  | \"never_store\";\n\nexport const CORRECTION_CLASSIFICATIONS: readonly CorrectionClassification[] = [\n  \"wrong\",\n  \"outdated\",\n  \"incomplete\",\n  \"wrong_scope\",\n  \"never_store\",\n];\n\n/**\n * A draft for a replacement memory (supersede action). Mirrors the subset of\n * {@link MemoryFrontmatter} a correction caller may legitimately set; the\n * executor fills in id/created/updated/source.\n */\nexport interface MemoryDraft {\n  content: string;\n  category?: MemoryCategory;\n  confidence?: number;\n  tags?: string[];\n  entityRef?: string;\n  /** Optional event-time anchor for bi-temporal supersession (#1578). */\n  validAt?: string;\n  /** Optional observed-at anchor for bi-temporal supersession (#1578). */\n  observedAt?: string;\n  structuredAttributes?: Record<string, string>;\n}\n\n/**\n * The known {@link MemoryCategory} values. A replacement/rescope category must\n * be one of these — rejecting path-like or unexpected strings before they reach\n * `StorageManager.writeMemory`, which incorporates the category into the\n * generated memory id/path (review thread Of-XJ).\n */\nexport const MEMORY_CATEGORIES: readonly MemoryCategory[] = [\n  \"fact\", \"preference\", \"correction\", \"entity\", \"decision\",\n  \"relationship\", \"principle\", \"commitment\", \"moment\",\n  \"skill\", \"rule\", \"procedure\", \"reasoning_trace\",\n];\n\nexport type CorrectionAction =\n  /** Outdated: a new fact replaces the loser. */\n  | { kind: \"supersede\"; loserId: string; replacement?: MemoryDraft }\n  /** Incomplete / minor-wrong: a versioned edit to an existing memory. */\n  | { kind: \"edit\"; memoryId: string; patch: string }\n  /** Wrong: retire + tombstone. */\n  | { kind: \"retract\"; memoryId: string }\n  /** Wrong scope: move to a different namespace. */\n  | { kind: \"rescope\"; memoryId: string; toNamespace: string }\n  /** Never-store: a future-extraction redaction rule. */\n  | { kind: \"redaction_rule\"; pattern: string };\n\nexport const CORRECTION_ACTION_KINDS: readonly CorrectionAction[\"kind\"][] = [\n  \"supersede\",\n  \"edit\",\n  \"retract\",\n  \"rescope\",\n  \"redaction_rule\",\n];\n\n// ---------------------------------------------------------------------------\n// Plan + outcome\n// ---------------------------------------------------------------------------\n\n/**\n * One affected memory in a plan: where it lives, an excerpt, why it is\n * affected, and (when available) the source quote that supports the\n * correction (#1575 provenance).\n */\nexport interface CorrectionAffectedEntry {\n  memoryId: string;\n  /** File path relative to the storage dir, for diff rendering. */\n  path: string;\n  excerpt: string;\n  why: string;\n  sourceQuote?: string;\n}\n\n/**\n * A persisted, expiring correction plan. Read-only artifact produced by the\n * planner; consumed (once) by the executor.\n */\nexport interface CorrectionPlan {\n  planId: string;\n  request: CorrectionRequest;\n  /** Authorized namespace the plan is scoped to (resolved by the service). */\n  namespace: string;\n  affected: CorrectionAffectedEntry[];\n  classification: CorrectionClassification;\n  actions: CorrectionAction[];\n  /** Human-readable diff preview rendered via page-versioning. */\n  diff: string;\n  /** Planner confidence in [0, 1]. `0` means manual selection required. */\n  confidence: number;\n  warnings: string[];\n  createdAt: string;\n  /** ISO timestamp after which apply rejects the plan as expired. */\n  expiresAt: string;\n  /**\n   * Lifecycle: `pending` → `applying` → `applied`|`partial` (or `discarded`).\n   * The executor flips a plan to `applying` BEFORE running any mutation\n   * (review thread OgIqt): if the process dies mid-apply, the plan stays\n   * `applying` and is NOT silently retryable — a partially-applied plan must\n   * never be re-applied wholesale (it would duplicate succeeded actions).\n   */\n  status?: \"pending\" | \"applying\" | \"applied\" | \"discarded\" | \"partial\";\n  /**\n   * ISO timestamp recorded when the plan transitioned to `applying` (#1713\n   * Item 2). Startup recovery uses this to detect plans stuck in `applying`\n   * past the stale-applying TTL (process died mid-apply) and discard+scrub\n   * them. Absent on plans that never entered `applying`.\n   */\n  applyingAt?: string;\n}\n\n/**\n * Per-action outcome recorded by the executor. An action whose new-state\n * write failed is `failed`; the executor never destroys old state for a\n * failed action (rule 25 / checklist §14).\n */\nexport interface CorrectionActionResult {\n  action: CorrectionAction;\n  status: \"applied\" | \"failed\" | \"skipped\";\n  /** For supersede: the new memory id. For edit: the memory id. */\n  memoryId?: string;\n  /** For supersede/retract: the emitted tombstone id (if any). */\n  tombstoneId?: string;\n  error?: string;\n}\n\nexport interface CorrectionOutcome {\n  planId: string;\n  status: \"applied\" | \"partial\";\n  results: CorrectionActionResult[];\n  /** Audit-record memory id (corrections are themselves memories). */\n  auditMemoryId: string;\n  /** ISO timestamp of the apply. */\n  appliedAt: string;\n}\n\n// ---------------------------------------------------------------------------\n// Validation helpers (pure) — shared by planner, executor, and surface tests\n// ---------------------------------------------------------------------------\n\n/** Maximum supported `text` length. Surfaces bound this earlier; the planner\n *  re-validates so a direct-service caller cannot bypass. */\nexport const CORRECTION_TEXT_MAX = 10_000;\n\n/** Maximum supported redaction pattern length (§34 — bounded patterns). */\nexport const REDACTION_PATTERN_MAX = 256;\n\n/**\n * Validate a {@link CorrectionRequest}'s invariants. Returns the cleaned\n * request or throws with a field-specific message (rule 51 — list valid\n * options, never silently default).\n */\nexport function validateCorrectionRequest(request: CorrectionRequest): CorrectionRequest {\n  if (!request || typeof request !== \"object\") {\n    throw new CorrectionContractError(\"CorrectionRequest must be an object.\");\n  }\n  const text = typeof request.text === \"string\" ? request.text.trim() : \"\";\n  if (text.length === 0) {\n    throw new CorrectionContractError(\"CorrectionRequest.text is required and must be non-empty.\");\n  }\n  if (text.length > CORRECTION_TEXT_MAX) {\n    throw new CorrectionContractError(\n      `CorrectionRequest.text exceeds the ${CORRECTION_TEXT_MAX}-character limit (${text.length}).`,\n    );\n  }\n  const targetIds = Array.isArray(request.targetIds)\n    ? request.targetIds.filter((id): id is string => typeof id === \"string\" && id.length > 0)\n    : undefined;\n  if (targetIds !== undefined && targetIds.length === 0) {\n    // An empty array is treated as \"not provided\" so callers can forward\n    // optional fields without a separate presence flag.\n    return {\n      text,\n      ...(request.sessionKey ? { sessionKey: request.sessionKey } : {}),\n      ...(request.principal ? { principal: request.principal } : {}),\n      ...(request.namespace ? { namespace: request.namespace } : {}),\n    };\n  }\n  return {\n    text,\n    ...(targetIds ? { targetIds } : {}),\n    ...(request.sessionKey ? { sessionKey: request.sessionKey } : {}),\n    ...(request.principal ? { principal: request.principal } : {}),\n    ...(request.namespace ? { namespace: request.namespace } : {}),\n  };\n}\n\n/**\n * Validate a redaction pattern (§34 — bounded, literal-or-safe-regex; reject\n * catastrophic patterns). Returns the cleaned pattern or throws.\n */\nexport function validateRedactionPattern(pattern: string): string {\n  if (typeof pattern !== \"string\") {\n    throw new CorrectionContractError(\"redaction_rule.pattern must be a string.\");\n  }\n  const trimmed = pattern.trim();\n  if (trimmed.length === 0) {\n    throw new CorrectionContractError(\"redaction_rule.pattern is required.\");\n  }\n  if (trimmed.length > REDACTION_PATTERN_MAX) {\n    throw new CorrectionContractError(\n      `redaction_rule.pattern exceeds the ${REDACTION_PATTERN_MAX}-character bound.`,\n    );\n  }\n  // Reject patterns that could match an unbounded string (overly-broad) OR\n  // exhibit catastrophic backtracking (nested quantifiers like `(a+)+`). We do\n  // NOT execute the regex (that would be ReDoS itself); we only inspect shape.\n  if (isRegexLike(trimmed) && isUnsafeRedactionRegex(trimmed)) {\n    throw new CorrectionContractError(\n      \"redaction_rule.pattern is unsafe — use a bounded literal or a regex without nested quantifiers / overlapping alternation.\",\n    );\n  }\n  // #1669 P2: reject zero-width regex (empty body or matches empty string)\n  // that would withhold every fact.\n  if (isRegexLike(trimmed)) {\n    const regexBody = trimmed.slice(1, -1);\n    if (regexBody.length === 0) {\n      throw new CorrectionContractError(\"redaction_rule.pattern body is empty — use a non-empty regex.\");\n    }\n    try {\n      if (new RegExp(regexBody).test(\"\")) {\n        throw new CorrectionContractError(\n          \"redaction_rule.pattern matches the empty string — it would withhold every fact.\",\n        );\n      }\n    } catch (e) {\n      if (e instanceof CorrectionContractError) throw e;\n      // Compilation failed — the extraction-time defense handles it.\n    }\n  }\n  return trimmed;\n}\n\n/** Only `/.../`-wrapped patterns are treated as regex; everything else is a\n *  literal (review thread P1 — consistent with extraction-redaction-rules.ts). */\nfunction isRegexLike(pattern: string): boolean {\n  return pattern.startsWith(\"/\") && pattern.endsWith(\"/\") && pattern.length >= 2;\n}\n\n/**\n * Reject a regex that would either match an arbitrary-length run of any\n * character (overly-broad) OR exhibit catastrophic backtracking (ReDoS).\n * Mirrors the safe-regex heuristic in extraction-redaction-rules.ts so the\n * apply-time chokepoint and the extraction-time defense agree on what is\n * pathological — intentionally not imported to keep the two modules decoupled\n * (contract owns validation; extraction owns consultation).\n */\nfunction isUnsafeRedactionRegex(pattern: string): boolean {\n  const body = pattern.startsWith(\"/\") && pattern.endsWith(\"/\")\n    ? pattern.slice(1, -1)\n    : pattern;\n  // `.*`, `.+`, `.`, or `(.*)` etc. anywhere → overly broad.\n  if (/(?:^|[^\\\\])\\(\\.\\*\\)|(?:^|[^\\\\])\\.\\*|(?:^|[^\\\\])\\.\\+|^\\.([^*+]?)$/.test(body)) {\n    return true;\n  }\n  // Nested quantifier: a group (...) whose body ends with a quantifier and\n  // which is itself quantified → exponential blowup on near-miss inputs\n  // (classic ReDoS shapes: (a+)+, (a*)*, (a?)+). Also catches overlapping\n  // alternation under repetition: (a|a)+ where branches share a prefix.\n  if (body.length > 512) return true;\n  for (let i = 0; i < body.length; i++) {\n    if (body[i] !== \"(\") continue;\n    let depth = 1;\n    let j = i + 1;\n    while (j < body.length && depth > 0) {\n      if (body[j] === \"\\\\\") { j += 2; continue; }\n      if (body[j] === \"(\") depth++;\n      else if (body[j] === \")\") depth--;\n      j++;\n    }\n    if (depth !== 0) continue;\n    const afterGroup = body[j];\n    if (afterGroup !== \"+\" && afterGroup !== \"*\" && afterGroup !== \"{\") continue;\n    const groupBody = body.slice(i + 1, j - 1);\n    if (/[+*?]$/.test(groupBody) || /\\{\\d+,?\\d*\\}[+*?]?$/.test(groupBody)) {\n      return true;\n    }\n    if (groupBody.includes(\"|\")) {\n      const branches = groupBody.split(\"|\");\n      if (branches.length >= 2) {\n        const firstChars = new Set(branches.map((b) => b[0]).filter(Boolean));\n        if (firstChars.size < branches.filter((b) => b.length > 0).length) {\n          return true;\n        }\n      }\n    }\n    i = j;\n  }\n  return false;\n}\n\n/**\n * Validate the shape of a {@link CorrectionAction}. Used by the executor\n * before applying and by the surface layer to reject malformed client input\n * (rule 51 — list valid kinds).\n */\nexport function validateCorrectionAction(action: unknown): asserts action is CorrectionAction {\n  if (!action || typeof action !== \"object\") {\n    throw new CorrectionContractError(\"CorrectionAction must be an object.\");\n  }\n  const a = action as Record<string, unknown>;\n  if (typeof a.kind !== \"string\" || !CORRECTION_ACTION_KINDS.includes(a.kind as CorrectionAction[\"kind\"])) {\n    throw new CorrectionContractError(\n      `CorrectionAction.kind must be one of: ${CORRECTION_ACTION_KINDS.join(\", \")}.`,\n    );\n  }\n  switch (a.kind) {\n    case \"supersede\":\n      if (typeof a.loserId !== \"string\" || a.loserId.length === 0) {\n        throw new CorrectionContractError(\"supersede.loserId is required.\");\n      }\n      if (a.replacement !== undefined && a.replacement !== null) {\n        validateMemoryDraft(a.replacement);\n      }\n      break;\n    case \"edit\":\n      if (typeof a.memoryId !== \"string\" || a.memoryId.length === 0) {\n        throw new CorrectionContractError(\"edit.memoryId is required.\");\n      }\n      if (typeof a.patch !== \"string\" || a.patch.length === 0) {\n        throw new CorrectionContractError(\"edit.patch is required and must be non-empty.\");\n      }\n      break;\n    case \"retract\":\n      if (typeof a.memoryId !== \"string\" || a.memoryId.length === 0) {\n        throw new CorrectionContractError(\"retract.memoryId is required.\");\n      }\n      break;\n    case \"rescope\":\n      if (typeof a.memoryId !== \"string\" || a.memoryId.length === 0) {\n        throw new CorrectionContractError(\"rescope.memoryId is required.\");\n      }\n      if (typeof a.toNamespace !== \"string\" || a.toNamespace.trim().length === 0) {\n        throw new CorrectionContractError(\"rescope.toNamespace is required.\");\n      }\n      break;\n    case \"redaction_rule\":\n      if (typeof a.pattern !== \"string\") {\n        throw new CorrectionContractError(\"redaction_rule.pattern is required.\");\n      }\n      validateRedactionPattern(a.pattern);\n      break;\n  }\n}\n\n/** Validate a {@link MemoryDraft}. Throws on invalid shape. */\nexport function validateMemoryDraft(draft: unknown): asserts draft is MemoryDraft {\n  if (!draft || typeof draft !== \"object\") {\n    throw new CorrectionContractError(\"MemoryDraft must be an object.\");\n  }\n  const d = draft as Record<string, unknown>;\n  if (typeof d.content !== \"string\" || d.content.trim().length === 0) {\n    throw new CorrectionContractError(\"MemoryDraft.content is required and must be non-empty.\");\n  }\n  if (d.category !== undefined) {\n    if (typeof d.category !== \"string\" || !(MEMORY_CATEGORIES as readonly string[]).includes(d.category)) {\n      throw new CorrectionContractError(\n        `MemoryDraft.category must be one of: ${MEMORY_CATEGORIES.join(\", \")}.`,\n      );\n    }\n  }\n  if (d.confidence !== undefined && (typeof d.confidence !== \"number\" || d.confidence < 0 || d.confidence > 1)) {\n    throw new CorrectionContractError(\"MemoryDraft.confidence must be a number in [0, 1].\");\n  }\n  if (d.tags !== undefined && !Array.isArray(d.tags)) {\n    throw new CorrectionContractError(\"MemoryDraft.tags must be an array.\");\n  }\n  if (d.structuredAttributes !== undefined && (typeof d.structuredAttributes !== \"object\" || d.structuredAttributes === null)) {\n    throw new CorrectionContractError(\"MemoryDraft.structuredAttributes must be an object.\");\n  }\n}\n\n/**\n * Deterministic fallback plan (rule 13): when the planner's LLM is\n * unavailable, the plan degrades to a search result, never an error page.\n * Classification `outdated`, confidence `0`, actions empty.\n */\nexport function deterministicFallbackPlan(args: {\n  request: CorrectionRequest;\n  namespace: string;\n  affected: CorrectionAffectedEntry[];\n  warnings: string[];\n  createdAt: string;\n  expiresAt: string;\n}): CorrectionPlan {\n  return {\n    planId: newPlanId(),\n    request: args.request,\n    namespace: args.namespace,\n    affected: args.affected,\n    classification: \"outdated\",\n    actions: [],\n    diff: \"\",\n    confidence: 0,\n    warnings: [...args.warnings, \"planner LLM unavailable — manual action selection required\"],\n    createdAt: args.createdAt,\n    expiresAt: args.expiresAt,\n    status: \"pending\",\n  };\n}\n\n/** Generate a stable plan id. Exposed for tests + deterministic fallback. */\nexport function newPlanId(): string {\n  return `corr-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;\n}\n\n/** Error class for contract violations. Surfaces map it to a 400 / input error. */\nexport class CorrectionContractError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"CorrectionContractError\";\n  }\n}\n"],"mappings":"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","names":[]}