@remnic/core 1.1.11 → 1.1.13

package/dist/chunk-AC5LO7IU.js

@@ -0,0 +1,308 @@
+import {
+  isUserBoundaryScope,
+  normalizeUserContextScope
+} from "./chunk-SOAU2OE2.js";
+
+// src/memory-provenance.ts
+var MEMORY_STATUS_VALUES = [
+  "active",
+  "pending_review",
+  "rejected",
+  "quarantined",
+  "superseded",
+  "archived",
+  "forgotten"
+];
+var LIFECYCLE_STATE_VALUES = [
+  "candidate",
+  "validated",
+  "active",
+  "stale",
+  "archived"
+];
+var VERIFICATION_STATE_VALUES = [
+  "unverified",
+  "user_confirmed",
+  "system_inferred",
+  "disputed"
+];
+var POLICY_CLASS_VALUES = [
+  "ephemeral",
+  "durable",
+  "protected"
+];
+var SAFETY_VALUES = [
+  "safe",
+  "requires-review",
+  "blocked"
+];
+var CORRECTION_STATE_VALUES = [
+  "none",
+  "correction",
+  "superseded",
+  "disputed",
+  "forgotten"
+];
+function buildRetrievedMemoryProvenance(memory, options = {}) {
+  const frontmatter = memory.frontmatter;
+  const nowMs = safeNow(options.now);
+  const namespace = nonEmptyString(options.namespace);
+  const scope = nonEmptyString(options.scope) ?? (namespace ? `namespace:${namespace}` : nonEmptyString(memory.path) ?? "unknown");
+  const userContextScopes = inferUserContextScopes(frontmatter);
+  const currentContextScopes = normalizeScopeList(options.currentContextScopes);
+  const stale = isStale(frontmatter, nowMs);
+  const correctionState = inferCorrectionState(frontmatter);
+  const corrected = correctionState !== "none";
+  const safetyReasons = inferSafetyReasons({
+    frontmatter,
+    stale,
+    userContextScopes,
+    currentContextScopes
+  });
+  const safety = inferSafety(safetyReasons);
+  const provenance = {
+    source: nonEmptyString(frontmatter.source) ?? "unknown",
+    scope,
+    userContextScopes,
+    retrievalReason: nonEmptyString(options.retrievalReason) ?? "retrieved",
+    confidence: clamp01(frontmatter.confidence),
+    stale,
+    corrected,
+    correctionState,
+    safeToUse: safety === "safe",
+    safety,
+    safetyReasons
+  };
+  assignString(provenance, "created", frontmatter.created);
+  assignString(provenance, "updated", frontmatter.updated);
+  assignString(provenance, "namespace", namespace);
+  assignStatus(provenance, "status", frontmatter.status);
+  assignLifecycleState(provenance, "lifecycleState", frontmatter.lifecycleState);
+  assignVerificationState(provenance, "verificationState", frontmatter.verificationState);
+  assignPolicyClass(provenance, "policyClass", frontmatter.policyClass);
+  assignString(provenance, "sourceMemoryId", frontmatter.sourceMemoryId);
+  assignString(provenance, "sourceTurnId", frontmatter.sourceTurnId);
+  assignString(provenance, "validAt", frontmatter.valid_at);
+  assignString(provenance, "invalidAt", frontmatter.invalid_at);
+  assignString(provenance, "forgottenAt", frontmatter.forgottenAt);
+  assignString(provenance, "forgottenReason", frontmatter.forgottenReason);
+  if (Array.isArray(frontmatter.derived_from) && frontmatter.derived_from.length > 0) {
+    provenance.derivedFrom = stringList(frontmatter.derived_from);
+  }
+  if (frontmatter.derived_via !== void 0) {
+    provenance.derivedVia = frontmatter.derived_via;
+  }
+  return provenance;
+}
+function normalizeRetrievedMemoryProvenance(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const raw = value;
+  const source = nonEmptyString(raw.source) ?? "unknown";
+  const scope = nonEmptyString(raw.scope) ?? "unknown";
+  const retrievalReason = nonEmptyString(raw.retrievalReason) ?? "retrieved";
+  let safety = isRetrievedMemorySafety(raw.safety) ? raw.safety : raw.safeToUse === false ? "requires-review" : "safe";
+  if (raw.safeToUse === false && safety === "safe") {
+    safety = "requires-review";
+  }
+  const correctionState = isRetrievedMemoryCorrectionState(raw.correctionState) ? raw.correctionState : raw.corrected === true ? "correction" : "none";
+  const safetyReasons = stringList(raw.safetyReasons);
+  const provenance = {
+    source,
+    scope,
+    userContextScopes: normalizeScopeList(raw.userContextScopes),
+    retrievalReason,
+    confidence: clamp01(raw.confidence),
+    stale: raw.stale === true,
+    corrected: raw.corrected === true || correctionState !== "none",
+    correctionState,
+    safeToUse: safety === "safe",
+    safety,
+    safetyReasons
+  };
+  assignString(provenance, "created", raw.created);
+  assignString(provenance, "updated", raw.updated);
+  assignString(provenance, "namespace", raw.namespace);
+  assignStatus(provenance, "status", raw.status);
+  assignLifecycleState(provenance, "lifecycleState", raw.lifecycleState);
+  assignVerificationState(provenance, "verificationState", raw.verificationState);
+  assignPolicyClass(provenance, "policyClass", raw.policyClass);
+  assignString(provenance, "sourceMemoryId", raw.sourceMemoryId);
+  assignString(provenance, "sourceTurnId", raw.sourceTurnId);
+  assignString(provenance, "validAt", raw.validAt);
+  assignString(provenance, "invalidAt", raw.invalidAt);
+  assignString(provenance, "forgottenAt", raw.forgottenAt);
+  assignString(provenance, "forgottenReason", raw.forgottenReason);
+  const derivedFrom = stringList(raw.derivedFrom);
+  if (derivedFrom.length > 0) provenance.derivedFrom = derivedFrom;
+  if (raw.derivedVia === "split" || raw.derivedVia === "merge" || raw.derivedVia === "update" || raw.derivedVia === "pattern-reinforcement") {
+    provenance.derivedVia = raw.derivedVia;
+  }
+  return provenance;
+}
+function summarizeRetrievedMemoryProvenance(provenance) {
+  return [
+    `source=${provenance.source}`,
+    `created=${provenance.created ?? "unknown"}`,
+    `scope=${provenance.scope}`,
+    `confidence=${provenance.confidence.toFixed(2)}`,
+    `stale=${provenance.stale ? "true" : "false"}`,
+    `corrected=${provenance.corrected ? provenance.correctionState : "false"}`,
+    `safe=${provenance.safeToUse ? "true" : "false"}`
+  ].join(" ");
+}
+function inferUserContextScopes(frontmatter) {
+  const scoped = frontmatter;
+  return normalizeScopeList([
+    ...Array.isArray(scoped.userContextScopes) ? scoped.userContextScopes : [],
+    ...Array.isArray(frontmatter.tags) ? frontmatter.tags : []
+  ]);
+}
+function normalizeScopeList(values) {
+  const input = Array.isArray(values) ? values : [];
+  const seen = /* @__PURE__ */ new Set();
+  const normalized = [];
+  for (const value of input) {
+    const scope = normalizeUserContextScope(value);
+    if (!scope || seen.has(scope)) continue;
+    seen.add(scope);
+    normalized.push(scope);
+  }
+  return normalized;
+}
+function isStale(frontmatter, nowMs) {
+  if (frontmatter.status === "superseded" || frontmatter.status === "archived" || frontmatter.status === "forgotten") {
+    return true;
+  }
+  if (frontmatter.lifecycleState === "stale" || frontmatter.lifecycleState === "archived") {
+    return true;
+  }
+  const expiresAtMs = parseEpochMs(frontmatter.expiresAt);
+  if (expiresAtMs !== null && expiresAtMs <= nowMs) return true;
+  const invalidAtMs = parseEpochMs(frontmatter.invalid_at);
+  if (invalidAtMs !== null && invalidAtMs <= nowMs) return true;
+  return false;
+}
+function inferCorrectionState(frontmatter) {
+  if (frontmatter.status === "forgotten") return "forgotten";
+  if (frontmatter.status === "superseded" || frontmatter.supersededBy || frontmatter.supersededAt) {
+    return "superseded";
+  }
+  if (frontmatter.verificationState === "disputed") return "disputed";
+  if (frontmatter.category === "correction" || frontmatter.supersedes) {
+    return "correction";
+  }
+  return "none";
+}
+function inferSafetyReasons(input) {
+  const reasons = [];
+  const { frontmatter, stale, userContextScopes, currentContextScopes } = input;
+  if (frontmatter.status === "forgotten") reasons.push("status=forgotten");
+  if (frontmatter.status === "rejected") reasons.push("status=rejected");
+  if (frontmatter.status === "quarantined") reasons.push("status=quarantined");
+  if (frontmatter.status === "pending_review") reasons.push("status=pending_review");
+  if (frontmatter.status === "superseded") reasons.push("status=superseded");
+  if (frontmatter.status === "archived") reasons.push("status=archived");
+  if (frontmatter.verificationState === "disputed") {
+    reasons.push("verification=disputed");
+  }
+  if (stale) reasons.push("stale=true");
+  const boundaryScopes = userContextScopes.filter(isUserBoundaryScope);
+  if (boundaryScopes.length > 0) {
+    const current = new Set(currentContextScopes);
+    const hasMatchingBoundary = boundaryScopes.some((scope) => current.has(scope));
+    if (!hasMatchingBoundary) {
+      const joined = boundaryScopes.join(",");
+      if (boundaryScopes.includes("do-not-use-outside-this-context")) {
+        reasons.push(`boundary-blocked=${joined}`);
+      } else {
+        reasons.push(`boundary-review=${joined}`);
+      }
+    }
+  }
+  return uniqueStrings(reasons);
+}
+function inferSafety(reasons) {
+  if (reasons.some(
+    (reason) => reason === "status=forgotten" || reason === "status=rejected" || reason === "status=quarantined" || reason.startsWith("boundary-blocked=")
+  )) {
+    return "blocked";
+  }
+  return reasons.length > 0 ? "requires-review" : "safe";
+}
+function safeNow(now) {
+  const value = now ? now() : Date.now();
+  return Number.isFinite(value) ? value : Date.now();
+}
+function parseEpochMs(value) {
+  if (typeof value !== "string" || value.trim().length === 0) return null;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function clamp01(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+  return Math.min(1, Math.max(0, value));
+}
+function nonEmptyString(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function stringList(value) {
+  if (!Array.isArray(value)) return [];
+  return uniqueStrings(
+    value.filter((item) => typeof item === "string").map((item) => item.trim()).filter((item) => item.length > 0)
+  );
+}
+function uniqueStrings(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of values) {
+    if (seen.has(value)) continue;
+    seen.add(value);
+    out.push(value);
+  }
+  return out;
+}
+function assignString(target, key, value) {
+  const normalized = nonEmptyString(value);
+  if (normalized !== void 0) {
+    target[key] = normalized;
+  }
+}
+function assignStatus(target, key, value) {
+  if (isMemoryStatus(value)) target[key] = value;
+}
+function assignLifecycleState(target, key, value) {
+  if (isLifecycleState(value)) target[key] = value;
+}
+function assignVerificationState(target, key, value) {
+  if (isVerificationState(value)) target[key] = value;
+}
+function assignPolicyClass(target, key, value) {
+  if (isPolicyClass(value)) target[key] = value;
+}
+function isMemoryStatus(value) {
+  return typeof value === "string" && MEMORY_STATUS_VALUES.includes(value);
+}
+function isLifecycleState(value) {
+  return typeof value === "string" && LIFECYCLE_STATE_VALUES.includes(value);
+}
+function isVerificationState(value) {
+  return typeof value === "string" && VERIFICATION_STATE_VALUES.includes(value);
+}
+function isPolicyClass(value) {
+  return typeof value === "string" && POLICY_CLASS_VALUES.includes(value);
+}
+function isRetrievedMemorySafety(value) {
+  return typeof value === "string" && SAFETY_VALUES.includes(value);
+}
+function isRetrievedMemoryCorrectionState(value) {
+  return typeof value === "string" && CORRECTION_STATE_VALUES.includes(value);
+}
+
+export {
+  buildRetrievedMemoryProvenance,
+  normalizeRetrievedMemoryProvenance,
+  summarizeRetrievedMemoryProvenance
+};
+//# sourceMappingURL=chunk-AC5LO7IU.js.map

package/dist/chunk-AC5LO7IU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/memory-provenance.ts"],"sourcesContent":["import type {\n  LifecycleState,\n  MemoryFile,\n  MemoryFrontmatter,\n  MemoryStatus,\n  PolicyClass,\n  VerificationState,\n} from \"./types.js\";\nimport {\n  isUserBoundaryScope,\n  normalizeUserContextScope,\n  type UserContextScope,\n} from \"./user-model.js\";\n\nexport type RetrievedMemoryCorrectionState =\n  | \"none\"\n  | \"correction\"\n  | \"superseded\"\n  | \"disputed\"\n  | \"forgotten\";\n\nexport type RetrievedMemorySafety = \"safe\" | \"requires-review\" | \"blocked\";\n\nexport interface RetrievedMemoryProvenance {\n  /** Frontmatter source, for example conversation, artifact, import, or consolidation. */\n  source: string;\n  /** ISO timestamp the memory was created, when known. */\n  created?: string;\n  /** ISO timestamp the memory was last updated, when known. */\n  updated?: string;\n  /** Namespace that produced the result, when known. */\n  namespace?: string;\n  /** Concrete retrieval scope. Defaults to namespace:<name> or the storage path. */\n  scope: string;\n  /** User-aware context scopes inferred from explicit scope metadata or tags. */\n  userContextScopes: UserContextScope[];\n  /** Why this memory was retrieved for the current response. */\n  retrievalReason: string;\n  /** Memory confidence clamped into [0, 1]. */\n  confidence: number;\n  /** Whether lifecycle, validity, or expiry metadata says this memory is stale now. */\n  stale: boolean;\n  /** Whether this result represents, has, or is affected by a user/system correction. */\n  corrected: boolean;\n  correctionState: RetrievedMemoryCorrectionState;\n  /** Whether the memory is safe to use in the current context without asking first. */\n  safeToUse: boolean;\n  safety: RetrievedMemorySafety;\n  safetyReasons: string[];\n  status?: MemoryStatus;\n  lifecycleState?: LifecycleState;\n  verificationState?: VerificationState;\n  policyClass?: PolicyClass;\n  sourceMemoryId?: string;\n  sourceTurnId?: string;\n  derivedFrom?: string[];\n  derivedVia?: MemoryFrontmatter[\"derived_via\"];\n  validAt?: string;\n  invalidAt?: string;\n  forgottenAt?: string;\n  forgottenReason?: string;\n}\n\nexport interface BuildRetrievedMemoryProvenanceOptions {\n  namespace?: string;\n  scope?: string;\n  retrievalReason?: string;\n  currentContextScopes?: readonly unknown[];\n  now?: () => number;\n}\n\nconst MEMORY_STATUS_VALUES: readonly MemoryStatus[] = [\n  \"active\",\n  \"pending_review\",\n  \"rejected\",\n  \"quarantined\",\n  \"superseded\",\n  \"archived\",\n  \"forgotten\",\n];\n\nconst LIFECYCLE_STATE_VALUES: readonly LifecycleState[] = [\n  \"candidate\",\n  \"validated\",\n  \"active\",\n  \"stale\",\n  \"archived\",\n];\n\nconst VERIFICATION_STATE_VALUES: readonly VerificationState[] = [\n  \"unverified\",\n  \"user_confirmed\",\n  \"system_inferred\",\n  \"disputed\",\n];\n\nconst POLICY_CLASS_VALUES: readonly PolicyClass[] = [\n  \"ephemeral\",\n  \"durable\",\n  \"protected\",\n];\n\nconst SAFETY_VALUES: readonly RetrievedMemorySafety[] = [\n  \"safe\",\n  \"requires-review\",\n  \"blocked\",\n];\n\nconst CORRECTION_STATE_VALUES: readonly RetrievedMemoryCorrectionState[] = [\n  \"none\",\n  \"correction\",\n  \"superseded\",\n  \"disputed\",\n  \"forgotten\",\n];\n\nexport function buildRetrievedMemoryProvenance(\n  memory: MemoryFile,\n  options: BuildRetrievedMemoryProvenanceOptions = {},\n): RetrievedMemoryProvenance {\n  const frontmatter = memory.frontmatter;\n  const nowMs = safeNow(options.now);\n  const namespace = nonEmptyString(options.namespace);\n  const scope =\n    nonEmptyString(options.scope) ??\n    (namespace ? `namespace:${namespace}` : nonEmptyString(memory.path) ?? \"unknown\");\n  const userContextScopes = inferUserContextScopes(frontmatter);\n  const currentContextScopes = normalizeScopeList(options.currentContextScopes);\n  const stale = isStale(frontmatter, nowMs);\n  const correctionState = inferCorrectionState(frontmatter);\n  const corrected = correctionState !== \"none\";\n  const safetyReasons = inferSafetyReasons({\n    frontmatter,\n    stale,\n    userContextScopes,\n    currentContextScopes,\n  });\n  const safety = inferSafety(safetyReasons);\n  const provenance: RetrievedMemoryProvenance = {\n    source: nonEmptyString(frontmatter.source) ?? \"unknown\",\n    scope,\n    userContextScopes,\n    retrievalReason: nonEmptyString(options.retrievalReason) ?? \"retrieved\",\n    confidence: clamp01(frontmatter.confidence),\n    stale,\n    corrected,\n    correctionState,\n    safeToUse: safety === \"safe\",\n    safety,\n    safetyReasons,\n  };\n\n  assignString(provenance, \"created\", frontmatter.created);\n  assignString(provenance, \"updated\", frontmatter.updated);\n  assignString(provenance, \"namespace\", namespace);\n  assignStatus(provenance, \"status\", frontmatter.status);\n  assignLifecycleState(provenance, \"lifecycleState\", frontmatter.lifecycleState);\n  assignVerificationState(provenance, \"verificationState\", frontmatter.verificationState);\n  assignPolicyClass(provenance, \"policyClass\", frontmatter.policyClass);\n  assignString(provenance, \"sourceMemoryId\", frontmatter.sourceMemoryId);\n  assignString(provenance, \"sourceTurnId\", frontmatter.sourceTurnId);\n  assignString(provenance, \"validAt\", frontmatter.valid_at);\n  assignString(provenance, \"invalidAt\", frontmatter.invalid_at);\n  assignString(provenance, \"forgottenAt\", frontmatter.forgottenAt);\n  assignString(provenance, \"forgottenReason\", frontmatter.forgottenReason);\n  if (Array.isArray(frontmatter.derived_from) && frontmatter.derived_from.length > 0) {\n    provenance.derivedFrom = stringList(frontmatter.derived_from);\n  }\n  if (frontmatter.derived_via !== undefined) {\n    provenance.derivedVia = frontmatter.derived_via;\n  }\n\n  return provenance;\n}\n\nexport function normalizeRetrievedMemoryProvenance(\n  value: unknown,\n): RetrievedMemoryProvenance | undefined {\n  if (!value || typeof value !== \"object\") return undefined;\n  const raw = value as Record<string, unknown>;\n  const source = nonEmptyString(raw.source) ?? \"unknown\";\n  const scope = nonEmptyString(raw.scope) ?? \"unknown\";\n  const retrievalReason = nonEmptyString(raw.retrievalReason) ?? \"retrieved\";\n  let safety = isRetrievedMemorySafety(raw.safety)\n    ? raw.safety\n    : raw.safeToUse === false\n      ? \"requires-review\"\n      : \"safe\";\n  if (raw.safeToUse === false && safety === \"safe\") {\n    safety = \"requires-review\";\n  }\n  const correctionState = isRetrievedMemoryCorrectionState(raw.correctionState)\n    ? raw.correctionState\n    : raw.corrected === true\n      ? \"correction\"\n      : \"none\";\n  const safetyReasons = stringList(raw.safetyReasons);\n  const provenance: RetrievedMemoryProvenance = {\n    source,\n    scope,\n    userContextScopes: normalizeScopeList(raw.userContextScopes),\n    retrievalReason,\n    confidence: clamp01(raw.confidence),\n    stale: raw.stale === true,\n    corrected: raw.corrected === true || correctionState !== \"none\",\n    correctionState,\n    safeToUse: safety === \"safe\",\n    safety,\n    safetyReasons,\n  };\n\n  assignString(provenance, \"created\", raw.created);\n  assignString(provenance, \"updated\", raw.updated);\n  assignString(provenance, \"namespace\", raw.namespace);\n  assignStatus(provenance, \"status\", raw.status);\n  assignLifecycleState(provenance, \"lifecycleState\", raw.lifecycleState);\n  assignVerificationState(provenance, \"verificationState\", raw.verificationState);\n  assignPolicyClass(provenance, \"policyClass\", raw.policyClass);\n  assignString(provenance, \"sourceMemoryId\", raw.sourceMemoryId);\n  assignString(provenance, \"sourceTurnId\", raw.sourceTurnId);\n  assignString(provenance, \"validAt\", raw.validAt);\n  assignString(provenance, \"invalidAt\", raw.invalidAt);\n  assignString(provenance, \"forgottenAt\", raw.forgottenAt);\n  assignString(provenance, \"forgottenReason\", raw.forgottenReason);\n  const derivedFrom = stringList(raw.derivedFrom);\n  if (derivedFrom.length > 0) provenance.derivedFrom = derivedFrom;\n  if (\n    raw.derivedVia === \"split\" ||\n    raw.derivedVia === \"merge\" ||\n    raw.derivedVia === \"update\" ||\n    raw.derivedVia === \"pattern-reinforcement\"\n  ) {\n    provenance.derivedVia = raw.derivedVia;\n  }\n  return provenance;\n}\n\nexport function summarizeRetrievedMemoryProvenance(\n  provenance: RetrievedMemoryProvenance,\n): string {\n  return [\n    `source=${provenance.source}`,\n    `created=${provenance.created ?? \"unknown\"}`,\n    `scope=${provenance.scope}`,\n    `confidence=${provenance.confidence.toFixed(2)}`,\n    `stale=${provenance.stale ? \"true\" : \"false\"}`,\n    `corrected=${provenance.corrected ? provenance.correctionState : \"false\"}`,\n    `safe=${provenance.safeToUse ? \"true\" : \"false\"}`,\n  ].join(\" \");\n}\n\nfunction inferUserContextScopes(frontmatter: MemoryFrontmatter): UserContextScope[] {\n  const scoped = frontmatter as MemoryFrontmatter & {\n    userContextScopes?: readonly unknown[];\n  };\n  return normalizeScopeList([\n    ...(Array.isArray(scoped.userContextScopes) ? scoped.userContextScopes : []),\n    ...(Array.isArray(frontmatter.tags) ? frontmatter.tags : []),\n  ]);\n}\n\nfunction normalizeScopeList(values: unknown): UserContextScope[] {\n  const input = Array.isArray(values) ? values : [];\n  const seen = new Set<UserContextScope>();\n  const normalized: UserContextScope[] = [];\n  for (const value of input) {\n    const scope = normalizeUserContextScope(value);\n    if (!scope || seen.has(scope)) continue;\n    seen.add(scope);\n    normalized.push(scope);\n  }\n  return normalized;\n}\n\nfunction isStale(frontmatter: MemoryFrontmatter, nowMs: number): boolean {\n  if (\n    frontmatter.status === \"superseded\" ||\n    frontmatter.status === \"archived\" ||\n    frontmatter.status === \"forgotten\"\n  ) {\n    return true;\n  }\n  if (\n    frontmatter.lifecycleState === \"stale\" ||\n    frontmatter.lifecycleState === \"archived\"\n  ) {\n    return true;\n  }\n  const expiresAtMs = parseEpochMs(frontmatter.expiresAt);\n  if (expiresAtMs !== null && expiresAtMs <= nowMs) return true;\n  const invalidAtMs = parseEpochMs(frontmatter.invalid_at);\n  if (invalidAtMs !== null && invalidAtMs <= nowMs) return true;\n  return false;\n}\n\nfunction inferCorrectionState(\n  frontmatter: MemoryFrontmatter,\n): RetrievedMemoryCorrectionState {\n  if (frontmatter.status === \"forgotten\") return \"forgotten\";\n  if (\n    frontmatter.status === \"superseded\" ||\n    frontmatter.supersededBy ||\n    frontmatter.supersededAt\n  ) {\n    return \"superseded\";\n  }\n  if (frontmatter.verificationState === \"disputed\") return \"disputed\";\n  if (frontmatter.category === \"correction\" || frontmatter.supersedes) {\n    return \"correction\";\n  }\n  return \"none\";\n}\n\nfunction inferSafetyReasons(input: {\n  frontmatter: MemoryFrontmatter;\n  stale: boolean;\n  userContextScopes: UserContextScope[];\n  currentContextScopes: UserContextScope[];\n}): string[] {\n  const reasons: string[] = [];\n  const { frontmatter, stale, userContextScopes, currentContextScopes } = input;\n  if (frontmatter.status === \"forgotten\") reasons.push(\"status=forgotten\");\n  if (frontmatter.status === \"rejected\") reasons.push(\"status=rejected\");\n  if (frontmatter.status === \"quarantined\") reasons.push(\"status=quarantined\");\n  if (frontmatter.status === \"pending_review\") reasons.push(\"status=pending_review\");\n  if (frontmatter.status === \"superseded\") reasons.push(\"status=superseded\");\n  if (frontmatter.status === \"archived\") reasons.push(\"status=archived\");\n  if (frontmatter.verificationState === \"disputed\") {\n    reasons.push(\"verification=disputed\");\n  }\n  if (stale) reasons.push(\"stale=true\");\n\n  const boundaryScopes = userContextScopes.filter(isUserBoundaryScope);\n  if (boundaryScopes.length > 0) {\n    const current = new Set(currentContextScopes);\n    const hasMatchingBoundary = boundaryScopes.some((scope) => current.has(scope));\n    if (!hasMatchingBoundary) {\n      const joined = boundaryScopes.join(\",\");\n      if (boundaryScopes.includes(\"do-not-use-outside-this-context\")) {\n        reasons.push(`boundary-blocked=${joined}`);\n      } else {\n        reasons.push(`boundary-review=${joined}`);\n      }\n    }\n  }\n  return uniqueStrings(reasons);\n}\n\nfunction inferSafety(reasons: readonly string[]): RetrievedMemorySafety {\n  if (\n    reasons.some((reason) =>\n      reason === \"status=forgotten\" ||\n      reason === \"status=rejected\" ||\n      reason === \"status=quarantined\" ||\n      reason.startsWith(\"boundary-blocked=\"),\n    )\n  ) {\n    return \"blocked\";\n  }\n  return reasons.length > 0 ? \"requires-review\" : \"safe\";\n}\n\nfunction safeNow(now: (() => number) | undefined): number {\n  const value = now ? now() : Date.now();\n  return Number.isFinite(value) ? value : Date.now();\n}\n\nfunction parseEpochMs(value: unknown): number | null {\n  if (typeof value !== \"string\" || value.trim().length === 0) return null;\n  const parsed = Date.parse(value);\n  return Number.isFinite(parsed) ? parsed : null;\n}\n\nfunction clamp01(value: unknown): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value)) return 0;\n  return Math.min(1, Math.max(0, value));\n}\n\nfunction nonEmptyString(value: unknown): string | undefined {\n  if (typeof value !== \"string\") return undefined;\n  const trimmed = value.trim();\n  return trimmed.length > 0 ? trimmed : undefined;\n}\n\nfunction stringList(value: unknown): string[] {\n  if (!Array.isArray(value)) return [];\n  return uniqueStrings(\n    value\n      .filter((item): item is string => typeof item === \"string\")\n      .map((item) => item.trim())\n      .filter((item) => item.length > 0),\n  );\n}\n\nfunction uniqueStrings(values: readonly string[]): string[] {\n  const seen = new Set<string>();\n  const out: string[] = [];\n  for (const value of values) {\n    if (seen.has(value)) continue;\n    seen.add(value);\n    out.push(value);\n  }\n  return out;\n}\n\ntype RetrievedMemoryProvenanceStringField =\n  | \"created\"\n  | \"updated\"\n  | \"namespace\"\n  | \"sourceMemoryId\"\n  | \"sourceTurnId\"\n  | \"validAt\"\n  | \"invalidAt\"\n  | \"forgottenAt\"\n  | \"forgottenReason\";\n\nfunction assignString(\n  target: RetrievedMemoryProvenance,\n  key: RetrievedMemoryProvenanceStringField,\n  value: unknown,\n): void {\n  const normalized = nonEmptyString(value);\n  if (normalized !== undefined) {\n    target[key] = normalized;\n  }\n}\n\nfunction assignStatus(\n  target: RetrievedMemoryProvenance,\n  key: \"status\",\n  value: unknown,\n): void {\n  if (isMemoryStatus(value)) target[key] = value;\n}\n\nfunction assignLifecycleState(\n  target: RetrievedMemoryProvenance,\n  key: \"lifecycleState\",\n  value: unknown,\n): void {\n  if (isLifecycleState(value)) target[key] = value;\n}\n\nfunction assignVerificationState(\n  target: RetrievedMemoryProvenance,\n  key: \"verificationState\",\n  value: unknown,\n): void {\n  if (isVerificationState(value)) target[key] = value;\n}\n\nfunction assignPolicyClass(\n  target: RetrievedMemoryProvenance,\n  key: \"policyClass\",\n  value: unknown,\n): void {\n  if (isPolicyClass(value)) target[key] = value;\n}\n\nfunction isMemoryStatus(value: unknown): value is MemoryStatus {\n  return typeof value === \"string\" && MEMORY_STATUS_VALUES.includes(value as MemoryStatus);\n}\n\nfunction isLifecycleState(value: unknown): value is LifecycleState {\n  return typeof value === \"string\" && LIFECYCLE_STATE_VALUES.includes(value as LifecycleState);\n}\n\nfunction isVerificationState(value: unknown): value is VerificationState {\n  return typeof value === \"string\" && VERIFICATION_STATE_VALUES.includes(value as VerificationState);\n}\n\nfunction isPolicyClass(value: unknown): value is PolicyClass {\n  return typeof value === \"string\" && POLICY_CLASS_VALUES.includes(value as PolicyClass);\n}\n\nfunction isRetrievedMemorySafety(value: unknown): value is RetrievedMemorySafety {\n  return typeof value === \"string\" && SAFETY_VALUES.includes(value as RetrievedMemorySafety);\n}\n\nfunction isRetrievedMemoryCorrectionState(\n  value: unknown,\n): value is RetrievedMemoryCorrectionState {\n  return typeof value === \"string\" && CORRECTION_STATE_VALUES.includes(value as RetrievedMemoryCorrectionState);\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-AGZQD76C.js

@@ -0,0 +1,201 @@
+// src/transfer/fs-utils.ts
+import { createHash } from "crypto";
+import {
+  lstat,
+  mkdir,
+  readdir,
+  readFile,
+  realpath,
+  stat,
+  writeFile
+} from "fs/promises";
+import path from "path";
+var fatalUtf8Decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+async function sha256File(filePath) {
+  const buf = await readFile(filePath);
+  const sha256 = createHash("sha256").update(buf).digest("hex");
+  return { sha256, bytes: buf.byteLength };
+}
+function sha256Bytes(content) {
+  const buf = Buffer.from(content);
+  const sha256 = createHash("sha256").update(buf).digest("hex");
+  return { sha256, bytes: buf.byteLength };
+}
+function sha256String(content) {
+  return sha256Bytes(Buffer.from(content, "utf-8"));
+}
+async function readUtf8FileStrict(filePath) {
+  const buf = await readFile(filePath);
+  let content;
+  try {
+    content = fatalUtf8Decoder.decode(buf);
+  } catch {
+    throw new Error(`transfer export requires UTF-8 text files: ${filePath}`);
+  }
+  return { content, ...sha256Bytes(buf) };
+}
+async function writeJsonFile(filePath, value) {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, JSON.stringify(value, null, 2) + "\n", "utf-8");
+}
+async function readJsonFile(filePath) {
+  const raw = await readFile(filePath, "utf-8");
+  return JSON.parse(raw);
+}
+async function listFilesRecursive(rootDir) {
+  const out = [];
+  async function walk(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const ent of entries) {
+      const fp = path.join(dir, ent.name);
+      if (ent.isDirectory()) {
+        await walk(fp);
+      } else if (ent.isFile()) {
+        out.push(fp);
+      }
+    }
+  }
+  await walk(rootDir);
+  return out.sort();
+}
+async function ensureDirExists(dirPath) {
+  await mkdir(dirPath, { recursive: true });
+}
+async function fileExists(filePath) {
+  try {
+    await stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function toPosixRelPath(absPath, rootDir) {
+  const rel = path.relative(rootDir, absPath);
+  return rel.split(path.sep).join("/");
+}
+function fromPosixRelPath(relPath) {
+  return relPath.split("/").join(path.sep);
+}
+async function prepareSafeArchiveRoot(absPath, errorPrefix, argName) {
+  const rootAbs = path.resolve(absPath);
+  await assertIsDirectoryNotSymlink(rootAbs, errorPrefix, argName);
+  return {
+    abs: rootAbs,
+    real: await realpath(rootAbs),
+    errorPrefix,
+    argName
+  };
+}
+function validateArchiveRelativePath(relPath, errorPrefix) {
+  if (relPath.length === 0) {
+    throw new Error(`${errorPrefix}: record path must not be empty`);
+  }
+  if (relPath.includes("\\")) {
+    throw new Error(
+      `${errorPrefix}: record path must use POSIX separators: ${relPath}`
+    );
+  }
+  if (path.posix.isAbsolute(relPath)) {
+    throw new Error(
+      `${errorPrefix}: record path must be relative: ${relPath}`
+    );
+  }
+  const segments = relPath.split("/");
+  if (segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
+    throw new Error(
+      `${errorPrefix}: record path contains unsafe segments: ${relPath}`
+    );
+  }
+  const normalized = path.posix.normalize(relPath);
+  if (normalized === "." || normalized === ".." || normalized.startsWith("../") || path.posix.isAbsolute(normalized)) {
+    throw new Error(
+      `${errorPrefix}: record path escapes target root: ${relPath}`
+    );
+  }
+  return normalized;
+}
+async function resolveSafeArchiveTarget(root, relPath) {
+  const safeRelPath = validateArchiveRelativePath(relPath, root.errorPrefix);
+  const targetAbs = path.resolve(root.abs, fromPosixRelPath(safeRelPath));
+  if (!isPathInsideRoot(root.abs, targetAbs)) {
+    throw new Error(
+      `${root.errorPrefix}: record path escapes target root: ${relPath}`
+    );
+  }
+  const targetStat = await lstat(targetAbs).catch((error) => {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  });
+  if (targetStat?.isSymbolicLink()) {
+    throw new Error(
+      `${root.errorPrefix}: record path targets a symlink: ${relPath}`
+    );
+  }
+  await assertRealpathInsideRoot(
+    root.real,
+    targetAbs,
+    relPath,
+    root.errorPrefix
+  );
+  return targetAbs;
+}
+function isPathInsideRoot(rootReal, absPath) {
+  const rel = path.relative(rootReal, absPath);
+  if (rel === "") return true;
+  if (rel === "..") return false;
+  if (rel.startsWith(`..${path.sep}`)) return false;
+  if (path.isAbsolute(rel)) return false;
+  return true;
+}
+async function assertIsDirectoryNotSymlink(absPath, errorPrefix, argName) {
+  const st = await stat(absPath).catch(() => null);
+  if (!st || !st.isDirectory()) {
+    throw new Error(
+      `${errorPrefix}: '${argName}' must be an existing directory: ${absPath}`
+    );
+  }
+  const lst = await lstat(absPath).catch(() => null);
+  if (lst && lst.isSymbolicLink()) {
+    throw new Error(
+      `${errorPrefix}: '${argName}' must not be a symlink \u2014 resolve it to its real path first: ${absPath}`
+    );
+  }
+}
+async function assertRealpathInsideRoot(rootReal, targetAbs, sourcePath, errorPrefix) {
+  let existing = targetAbs;
+  const suffix = [];
+  while (existing !== path.dirname(existing)) {
+    const st = await lstat(existing).catch(() => null);
+    if (st !== null) break;
+    suffix.unshift(path.basename(existing));
+    existing = path.dirname(existing);
+  }
+  const existingReal = await realpath(existing).catch(() => existing);
+  const targetReal = suffix.length > 0 ? path.join(existingReal, ...suffix) : existingReal;
+  if (!isPathInsideRoot(rootReal, targetReal)) {
+    throw new Error(
+      `${errorPrefix}: record path escapes target root via symlink: ${sourcePath}`
+    );
+  }
+}
+
+export {
+  sha256File,
+  sha256Bytes,
+  sha256String,
+  readUtf8FileStrict,
+  writeJsonFile,
+  readJsonFile,
+  listFilesRecursive,
+  ensureDirExists,
+  fileExists,
+  toPosixRelPath,
+  fromPosixRelPath,
+  prepareSafeArchiveRoot,
+  validateArchiveRelativePath,
+  resolveSafeArchiveTarget,
+  isPathInsideRoot,
+  assertIsDirectoryNotSymlink,
+  assertRealpathInsideRoot
+};
+//# sourceMappingURL=chunk-AGZQD76C.js.map

package/dist/chunk-AGZQD76C.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transfer/fs-utils.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport {\n  lstat,\n  mkdir,\n  readdir,\n  readFile,\n  realpath,\n  stat,\n  writeFile,\n} from \"node:fs/promises\";\nimport path from \"node:path\";\n\nconst fatalUtf8Decoder = new TextDecoder(\"utf-8\", { fatal: true, ignoreBOM: true });\n\nexport async function sha256File(filePath: string): Promise<{ sha256: string; bytes: number }> {\n  const buf = await readFile(filePath);\n  const sha256 = createHash(\"sha256\").update(buf).digest(\"hex\");\n  return { sha256, bytes: buf.byteLength };\n}\n\nexport function sha256Bytes(content: Uint8Array): { sha256: string; bytes: number } {\n  const buf = Buffer.from(content);\n  const sha256 = createHash(\"sha256\").update(buf).digest(\"hex\");\n  return { sha256, bytes: buf.byteLength };\n}\n\nexport function sha256String(content: string): { sha256: string; bytes: number } {\n  return sha256Bytes(Buffer.from(content, \"utf-8\"));\n}\n\nexport async function readUtf8FileStrict(filePath: string): Promise<{ content: string; sha256: string; bytes: number }> {\n  const buf = await readFile(filePath);\n  let content: string;\n  try {\n    content = fatalUtf8Decoder.decode(buf);\n  } catch {\n    throw new Error(`transfer export requires UTF-8 text files: ${filePath}`);\n  }\n  return { content, ...sha256Bytes(buf) };\n}\n\nexport async function writeJsonFile(filePath: string, value: unknown): Promise<void> {\n  await mkdir(path.dirname(filePath), { recursive: true });\n  await writeFile(filePath, JSON.stringify(value, null, 2) + \"\\n\", \"utf-8\");\n}\n\nexport async function readJsonFile<T>(filePath: string): Promise<T> {\n  const raw = await readFile(filePath, \"utf-8\");\n  return JSON.parse(raw) as T;\n}\n\nexport async function listFilesRecursive(rootDir: string): Promise<string[]> {\n  const out: string[] = [];\n  async function walk(dir: string): Promise<void> {\n    const entries = await readdir(dir, { withFileTypes: true });\n    for (const ent of entries) {\n      const fp = path.join(dir, ent.name);\n      if (ent.isDirectory()) {\n        await walk(fp);\n      } else if (ent.isFile()) {\n        out.push(fp);\n      }\n    }\n  }\n  await walk(rootDir);\n  return out.sort();\n}\n\nexport async function ensureDirExists(dirPath: string): Promise<void> {\n  await mkdir(dirPath, { recursive: true });\n}\n\nexport async function fileExists(filePath: string): Promise<boolean> {\n  try {\n    await stat(filePath);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nexport function toPosixRelPath(absPath: string, rootDir: string): string {\n  const rel = path.relative(rootDir, absPath);\n  // normalize to posix for portability across platforms\n  return rel.split(path.sep).join(\"/\");\n}\n\nexport function fromPosixRelPath(relPath: string): string {\n  return relPath.split(\"/\").join(path.sep);\n}\n\nexport interface SafeArchiveRoot {\n  abs: string;\n  real: string;\n  errorPrefix: string;\n  argName: string;\n}\n\nexport async function prepareSafeArchiveRoot(\n  absPath: string,\n  errorPrefix: string,\n  argName: string,\n): Promise<SafeArchiveRoot> {\n  const rootAbs = path.resolve(absPath);\n  await assertIsDirectoryNotSymlink(rootAbs, errorPrefix, argName);\n  return {\n    abs: rootAbs,\n    real: await realpath(rootAbs),\n    errorPrefix,\n    argName,\n  };\n}\n\nexport function validateArchiveRelativePath(\n  relPath: string,\n  errorPrefix: string,\n): string {\n  if (relPath.length === 0) {\n    throw new Error(`${errorPrefix}: record path must not be empty`);\n  }\n  if (relPath.includes(\"\\\\\")) {\n    throw new Error(\n      `${errorPrefix}: record path must use POSIX separators: ${relPath}`,\n    );\n  }\n  if (path.posix.isAbsolute(relPath)) {\n    throw new Error(\n      `${errorPrefix}: record path must be relative: ${relPath}`,\n    );\n  }\n\n  const segments = relPath.split(\"/\");\n  if (segments.some((segment) => segment === \"\" || segment === \".\" || segment === \"..\")) {\n    throw new Error(\n      `${errorPrefix}: record path contains unsafe segments: ${relPath}`,\n    );\n  }\n\n  const normalized = path.posix.normalize(relPath);\n  if (\n    normalized === \".\" ||\n    normalized === \"..\" ||\n    normalized.startsWith(\"../\") ||\n    path.posix.isAbsolute(normalized)\n  ) {\n    throw new Error(\n      `${errorPrefix}: record path escapes target root: ${relPath}`,\n    );\n  }\n\n  return normalized;\n}\n\nexport async function resolveSafeArchiveTarget(\n  root: SafeArchiveRoot,\n  relPath: string,\n): Promise<string> {\n  const safeRelPath = validateArchiveRelativePath(relPath, root.errorPrefix);\n  const targetAbs = path.resolve(root.abs, fromPosixRelPath(safeRelPath));\n  if (!isPathInsideRoot(root.abs, targetAbs)) {\n    throw new Error(\n      `${root.errorPrefix}: record path escapes target root: ${relPath}`,\n    );\n  }\n\n  const targetStat = await lstat(targetAbs).catch((error: unknown) => {\n    if ((error as NodeJS.ErrnoException).code === \"ENOENT\") return null;\n    throw error;\n  });\n  if (targetStat?.isSymbolicLink()) {\n    throw new Error(\n      `${root.errorPrefix}: record path targets a symlink: ${relPath}`,\n    );\n  }\n\n  await assertRealpathInsideRoot(\n    root.real,\n    targetAbs,\n    relPath,\n    root.errorPrefix,\n  );\n  return targetAbs;\n}\n\n// ---------------------------------------------------------------------------\n// Shared path-safety helpers (used by capsule-import, capsule-merge, and\n// capsule-fork).\n//\n// These helpers are security-critical (path-traversal and symlink-bypass\n// guards), so any future fix must apply uniformly. The `errorPrefix` and\n// `argName` arguments let each caller surface module-specific error messages\n// (\"importCapsule:\" vs \"mergeCapsule:\" vs \"forkCapsule:\") without forking the\n// implementation.\n// ---------------------------------------------------------------------------\n\n/**\n * Return true when {@link absPath} is the same as {@link rootReal} or a\n * descendant. {@link rootReal} should be the value returned by\n * `realpath(rootAbs)` so that symlinked subdirectories are detected.\n */\nexport function isPathInsideRoot(rootReal: string, absPath: string): boolean {\n  const rel = path.relative(rootReal, absPath);\n  if (rel === \"\") return true;\n  if (rel === \"..\") return false;\n  if (rel.startsWith(`..${path.sep}`)) return false;\n  if (path.isAbsolute(rel)) return false;\n  return true;\n}\n\n/**\n * Assert that {@link absPath} is an existing directory and is not itself a\n * symlink. `existsSync` returns true for files (gotcha #24); a stat-based\n * check is required. Symlinked roots are rejected up-front so an attacker\n * cannot hand the importer a `~/import-target` link → `/etc` and have writes\n * silently follow the link (Codex P1 round 5 thread on PR #741).\n */\nexport async function assertIsDirectoryNotSymlink(\n  absPath: string,\n  errorPrefix: string,\n  argName: string,\n): Promise<void> {\n  const st = await stat(absPath).catch(() => null);\n  if (!st || !st.isDirectory()) {\n    throw new Error(\n      `${errorPrefix}: '${argName}' must be an existing directory: ${absPath}`,\n    );\n  }\n  const lst = await lstat(absPath).catch(() => null);\n  if (lst && lst.isSymbolicLink()) {\n    throw new Error(\n      `${errorPrefix}: '${argName}' must not be a symlink — resolve it to its real path first: ${absPath}`,\n    );\n  }\n}\n\n/**\n * Walk upward from {@link targetAbs} to find the nearest existing ancestor,\n * resolve it via `fs.realpath` (which follows symlinks), then re-append the\n * remaining suffix and verify the result is inside {@link rootReal}.\n *\n * This catches the case where an existing subdirectory at any point in the\n * path is a symlink that points outside the intended root. Because the file\n * does not exist yet we cannot realpath it directly; we resolve the deepest\n * existing prefix and re-apply the non-existent suffix. Callers must ensure\n * {@link rootReal} was already resolved via `realpath`.\n */\nexport async function assertRealpathInsideRoot(\n  rootReal: string,\n  targetAbs: string,\n  sourcePath: string,\n  errorPrefix: string,\n): Promise<void> {\n  let existing = targetAbs;\n  const suffix: string[] = [];\n  while (existing !== path.dirname(existing)) {\n    const st = await lstat(existing).catch(() => null);\n    if (st !== null) break;\n    suffix.unshift(path.basename(existing));\n    existing = path.dirname(existing);\n  }\n  const existingReal = await realpath(existing).catch(() => existing);\n  const targetReal =\n    suffix.length > 0 ? path.join(existingReal, ...suffix) : existingReal;\n  if (!isPathInsideRoot(rootReal, targetReal)) {\n    throw new Error(\n      `${errorPrefix}: record path escapes target root via symlink: ${sourcePath}`,\n    );\n  }\n}\n"],"mappings":"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","names":[]}