@remnic/core 1.1.12 → 1.1.13

package/dist/chunk-I5V2VDIW.js

@@ -0,0 +1,219 @@
+import {
+  runPostConsolidationMaterialize
+} from "./chunk-ME6ESPZU.js";
+import {
+  discoverMemoryExtensions,
+  renderExtensionsBlock,
+  resolveExtensionsRoot
+} from "./chunk-EJI5XIBB.js";
+import {
+  isSemanticConsolidationLlmOperator
+} from "./chunk-G7D6GZ5J.js";
+import {
+  countRecallTokenOverlap,
+  normalizeRecallTokens
+} from "./chunk-DT5TVLJE.js";
+import {
+  log
+} from "./chunk-2ODBA7MQ.js";
+
+// src/semantic-consolidation.ts
+function findSimilarClusters(memories, config) {
+  const excluded = new Set(config.excludeCategories);
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const m of memories) {
+    const cat = m.frontmatter.category;
+    if (excluded.has(cat)) continue;
+    if (m.frontmatter.status && m.frontmatter.status !== "active") continue;
+    const list = byCategory.get(cat) ?? [];
+    list.push(m);
+    byCategory.set(cat, list);
+  }
+  const clusters = [];
+  let totalCandidates = 0;
+  for (const [category, mems] of byCategory) {
+    if (totalCandidates >= config.maxPerRun) break;
+    const tokenized = mems.map((m) => ({
+      memory: m,
+      tokens: new Set(normalizeRecallTokens(m.content, []))
+    }));
+    const clustered = /* @__PURE__ */ new Set();
+    for (let i = 0; i < tokenized.length && totalCandidates < config.maxPerRun; i++) {
+      if (clustered.has(tokenized[i].memory.frontmatter.id)) continue;
+      const cluster = [tokenized[i].memory];
+      let totalOverlap = 0;
+      let comparisons = 0;
+      for (let j = i + 1; j < tokenized.length; j++) {
+        if (clustered.has(tokenized[j].memory.frontmatter.id)) continue;
+        const aTokens = tokenized[i].tokens;
+        const bTokens = tokenized[j].tokens;
+        if (aTokens.size === 0 || bTokens.size === 0) continue;
+        const overlap = countRecallTokenOverlap(aTokens, [...bTokens].join(" "));
+        const maxTokens = Math.max(aTokens.size, bTokens.size);
+        const score = maxTokens > 0 ? overlap / maxTokens : 0;
+        if (score >= config.threshold) {
+          cluster.push(tokenized[j].memory);
+          totalOverlap += score;
+          comparisons++;
+          if (totalCandidates + cluster.length >= config.maxPerRun) break;
+        }
+      }
+      if (cluster.length >= config.minClusterSize) {
+        for (const m of cluster) clustered.add(m.frontmatter.id);
+        clusters.push({
+          category,
+          memories: cluster,
+          overlapScore: comparisons > 0 ? totalOverlap / comparisons : 0
+        });
+        totalCandidates += cluster.length;
+      }
+    }
+  }
+  return clusters;
+}
+function buildConsolidationPrompt(cluster) {
+  const memoryTexts = cluster.memories.map(
+    (m, i) => `Memory ${i + 1} (${m.frontmatter.id}, created ${m.frontmatter.created}):
+${m.content}`
+  ).join("\n\n");
+  return `You are a memory consolidation system. The following ${cluster.memories.length} memories in the "${cluster.category}" category contain overlapping information.
+
+Synthesize them into ONE canonical memory that:
+1. Preserves ALL unique information from every source memory
+2. Removes redundancy and repetition
+3. Uses clear, concise language
+4. Maintains the same category and tone
+5. Does NOT add information that isn't in the sources
+
+${memoryTexts}
+
+Write ONLY the consolidated memory content (no metadata, no explanation, no preamble):`;
+}
+function parseConsolidationResponse(response) {
+  return response.trim();
+}
+function chooseConsolidationOperator(cluster) {
+  if (cluster.memories.length <= 1) return "update";
+  return "merge";
+}
+function buildOperatorAwareConsolidationPrompt(cluster) {
+  const memoryTexts = cluster.memories.map(
+    (m, i) => `Memory ${i + 1} (${m.frontmatter.id}, created ${m.frontmatter.created}):
+${m.content}`
+  ).join("\n\n");
+  return `You are a memory consolidation system.  The following ${cluster.memories.length} memories in the "${cluster.category}" category contain overlapping information.
+
+Pick exactly ONE consolidation operator for this cluster and return a JSON object.
+
+Operator vocabulary:
+  - "merge"  \u2014 multiple distinct source memories overlap and should be collapsed into one canonical memory (most common).
+  - "update" \u2014 one source memory carries a stale value that a newer source supersedes within the same logical fact.
+  - "split"  \u2014 a single logical source really encodes multiple distinct facts that should be separated (rare; if you pick split, still emit ONE canonical body \u2014 the write path will chunk it later).
+
+Output JSON ONLY, no prose before or after.  The "operator" key MUST be set to exactly one of the three strings "merge", "update", or "split" \u2014 never a pipe-separated placeholder like "merge|update|split".  Example shape:
+  {
+    "operator": "merge",
+    "output": "<the canonical memory text>"
+  }
+
+The "output" value must:
+1. Preserve ALL unique information from every source memory
+2. Remove redundancy and repetition
+3. Use clear, concise language
+4. Match the "${cluster.category}" category and tone
+5. NOT add information that isn't in the sources
+
+${memoryTexts}
+
+Return ONLY the JSON object:`;
+}
+function parseOperatorAwareConsolidationResponse(response, cluster) {
+  const fallback = {
+    operator: chooseConsolidationOperator(cluster),
+    output: response.trim()
+  };
+  const trimmed = response.trim();
+  if (trimmed.length === 0) return fallback;
+  const fenced = /^```(?:json)?\s*([\s\S]*?)```\s*$/u.exec(trimmed);
+  const payload = fenced ? fenced[1].trim() : trimmed;
+  const parsed = findLastJsonObjectWithOperator(payload);
+  if (parsed === void 0) return fallback;
+  if (typeof parsed !== "object" || parsed === null) return fallback;
+  const obj = parsed;
+  const rawOperator = typeof obj.operator === "string" ? obj.operator.trim().toLowerCase() : "";
+  const rawOutput = typeof obj.output === "string" ? obj.output : "";
+  const operator = isSemanticConsolidationLlmOperator(rawOperator) ? rawOperator : chooseConsolidationOperator(cluster);
+  const output = rawOutput.trim().length > 0 ? rawOutput.trim() : response.trim();
+  return { operator, output };
+}
+function findLastJsonObjectWithOperator(text) {
+  let searchFrom = 0;
+  let last = void 0;
+  while (searchFrom < text.length) {
+    const start = text.indexOf("{", searchFrom);
+    if (start < 0) return last;
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    let closed = false;
+    let endIdx = -1;
+    for (let i = start; i < text.length; i++) {
+      const ch = text[i];
+      if (inString) {
+        if (escape) {
+          escape = false;
+        } else if (ch === "\\") {
+          escape = true;
+        } else if (ch === '"') {
+          inString = false;
+        }
+        continue;
+      }
+      if (ch === '"') {
+        inString = true;
+      } else if (ch === "{") {
+        depth += 1;
+      } else if (ch === "}") {
+        depth -= 1;
+        if (depth === 0) {
+          closed = true;
+          endIdx = i;
+          break;
+        }
+      }
+    }
+    if (!closed) return last;
+    const slice = text.slice(start, endIdx + 1);
+    try {
+      const parsed = JSON.parse(slice);
+      if (typeof parsed === "object" && parsed !== null && "operator" in parsed) {
+        last = parsed;
+      }
+    } catch {
+    }
+    searchFrom = endIdx + 1;
+  }
+  return last;
+}
+async function buildExtensionsBlockForConsolidation(config) {
+  if (!config.memoryExtensionsEnabled) return "";
+  const root = resolveExtensionsRoot(config);
+  const extensions = await discoverMemoryExtensions(root, log);
+  if (extensions.length === 0) return "";
+  return renderExtensionsBlock(extensions);
+}
+async function materializeAfterSemanticConsolidation(options) {
+  return runPostConsolidationMaterialize("[semantic-consolidation]", options);
+}
+
+export {
+  findSimilarClusters,
+  buildConsolidationPrompt,
+  parseConsolidationResponse,
+  chooseConsolidationOperator,
+  buildOperatorAwareConsolidationPrompt,
+  parseOperatorAwareConsolidationResponse,
+  buildExtensionsBlockForConsolidation,
+  materializeAfterSemanticConsolidation
+};
+//# sourceMappingURL=chunk-I5V2VDIW.js.map

package/dist/chunk-I5V2VDIW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/semantic-consolidation.ts"],"sourcesContent":["/**\n * semantic-consolidation.ts — Semantic Consolidation Engine\n *\n * Finds clusters of semantically similar memories using token overlap,\n * synthesizes canonical versions via LLM, and archives the originals.\n * Reduces memory store bloat while preserving all unique information.\n */\n\nimport type { MemoryFile, PluginConfig } from \"./types.js\";\nimport { normalizeRecallTokens, countRecallTokenOverlap } from \"./recall-tokenization.js\";\nimport { runPostConsolidationMaterialize } from \"./connectors/codex-materialize-runner.js\";\nimport type { MaterializeResult, RolloutSummaryInput } from \"./connectors/codex-materialize.js\";\nimport { discoverMemoryExtensions, renderExtensionsBlock, resolveExtensionsRoot } from \"./memory-extension-host/index.js\";\nimport { log } from \"./logger.js\";\n\n// Re-export resolveExtensionsRoot for backward compatibility — existing\n// consumers that import from semantic-consolidation.ts continue to work.\nexport { resolveExtensionsRoot } from \"./memory-extension-host/index.js\";\n\n// Operator vocabulary (issue #561).  The types and validators live in a\n// standalone `consolidation-operator.ts` module so `storage.ts` can import\n// them without creating a `storage → semantic-consolidation →\n// codex-materialize-runner → storage` cycle.  Re-exported here so existing\n// consumers that reach for `./semantic-consolidation.js` keep working.\nexport {\n  CONSOLIDATION_OPERATORS,\n  isConsolidationOperator,\n  isSemanticConsolidationLlmOperator,\n  isValidDerivedFromEntry,\n  type ConsolidationOperator,\n  type SemanticConsolidationLlmOperator,\n} from \"./consolidation-operator.js\";\n\nimport {\n  CONSOLIDATION_OPERATORS as _CONSOLIDATION_OPERATORS,\n  isConsolidationOperator as _isConsolidationOperator,\n  isSemanticConsolidationLlmOperator as _isSemanticConsolidationLlmOperator,\n  type ConsolidationOperator as _ConsolidationOperator,\n  type SemanticConsolidationLlmOperator as _SemanticConsolidationLlmOperator,\n} from \"./consolidation-operator.js\";\n\nexport interface ConsolidationCluster {\n  category: string;\n  memories: MemoryFile[];\n  overlapScore: number;\n  canonicalContent?: string;\n}\n\nexport interface SemanticConsolidationResult {\n  clustersFound: number;\n  memoriesConsolidated: number;\n  memoriesArchived: number;\n  errors: number;\n  clusters: ConsolidationCluster[];\n}\n\n/**\n * Find clusters of semantically similar memories using token overlap.\n */\nexport function findSimilarClusters(\n  memories: MemoryFile[],\n  config: {\n    threshold: number;\n    minClusterSize: number;\n    excludeCategories: string[];\n    maxPerRun: number;\n  },\n): ConsolidationCluster[] {\n  const excluded = new Set(config.excludeCategories);\n\n  // Group by category first\n  const byCategory = new Map<string, MemoryFile[]>();\n  for (const m of memories) {\n    const cat = m.frontmatter.category;\n    if (excluded.has(cat)) continue;\n    if (m.frontmatter.status && m.frontmatter.status !== \"active\") continue;\n    const list = byCategory.get(cat) ?? [];\n    list.push(m);\n    byCategory.set(cat, list);\n  }\n\n  const clusters: ConsolidationCluster[] = [];\n  let totalCandidates = 0;\n\n  for (const [category, mems] of byCategory) {\n    if (totalCandidates >= config.maxPerRun) break;\n\n    // Token-normalize all memories in this category\n    const tokenized = mems.map((m) => ({\n      memory: m,\n      tokens: new Set(normalizeRecallTokens(m.content, [])),\n    }));\n\n    // Track which memories are already clustered\n    const clustered = new Set<string>();\n\n    for (let i = 0; i < tokenized.length && totalCandidates < config.maxPerRun; i++) {\n      if (clustered.has(tokenized[i].memory.frontmatter.id)) continue;\n\n      const cluster: MemoryFile[] = [tokenized[i].memory];\n      let totalOverlap = 0;\n      let comparisons = 0;\n\n      for (let j = i + 1; j < tokenized.length; j++) {\n        if (clustered.has(tokenized[j].memory.frontmatter.id)) continue;\n\n        const aTokens = tokenized[i].tokens;\n        const bTokens = tokenized[j].tokens;\n        if (aTokens.size === 0 || bTokens.size === 0) continue;\n\n        // Bidirectional overlap: what fraction of tokens are shared\n        const overlap = countRecallTokenOverlap(aTokens, [...bTokens].join(\" \"));\n        const maxTokens = Math.max(aTokens.size, bTokens.size);\n        const score = maxTokens > 0 ? overlap / maxTokens : 0;\n\n        if (score >= config.threshold) {\n          cluster.push(tokenized[j].memory);\n          totalOverlap += score;\n          comparisons++;\n          // Enforce maxPerRun within a single cluster\n          if (totalCandidates + cluster.length >= config.maxPerRun) break;\n        }\n      }\n\n      if (cluster.length >= config.minClusterSize) {\n        for (const m of cluster) clustered.add(m.frontmatter.id);\n        clusters.push({\n          category,\n          memories: cluster,\n          overlapScore: comparisons > 0 ? totalOverlap / comparisons : 0,\n        });\n        totalCandidates += cluster.length;\n      }\n    }\n  }\n\n  return clusters;\n}\n\n/**\n * Build the LLM prompt for synthesizing a canonical memory from a cluster.\n */\nexport function buildConsolidationPrompt(cluster: ConsolidationCluster): string {\n  const memoryTexts = cluster.memories\n    .map(\n      (m, i) =>\n        `Memory ${i + 1} (${m.frontmatter.id}, created ${m.frontmatter.created}):\\n${m.content}`,\n    )\n    .join(\"\\n\\n\");\n\n  return `You are a memory consolidation system. The following ${cluster.memories.length} memories in the \"${cluster.category}\" category contain overlapping information.\n\nSynthesize them into ONE canonical memory that:\n1. Preserves ALL unique information from every source memory\n2. Removes redundancy and repetition\n3. Uses clear, concise language\n4. Maintains the same category and tone\n5. Does NOT add information that isn't in the sources\n\n${memoryTexts}\n\nWrite ONLY the consolidated memory content (no metadata, no explanation, no preamble):`;\n}\n\n/**\n * Parse the LLM response to extract the canonical content.\n */\nexport function parseConsolidationResponse(response: string): string {\n  return response.trim();\n}\n\n// ─── Operator-aware prompt / parse (issue #561 PR 3) ─────────────────────────\n\n/**\n * Structured result from an operator-aware consolidation LLM call.\n *\n * - `operator` — the consolidation operator the LLM chose for this cluster.\n *   Falls back to the heuristic default when the LLM omits or returns an\n *   unknown value (the parser never surfaces an invalid operator; see\n *   `parseOperatorAwareConsolidationResponse`).\n * - `output` — the canonical content (same format the legacy prompt\n *   returns).  Callers persist this as the body of the new memory.\n */\nexport interface OperatorAwareConsolidationResult {\n  // Restricted to the LLM-allowed subset (Cursor Bugbot, PR #730):\n  // `pattern-reinforcement` is reserved for the maintenance job and\n  // must never reach this struct from a consolidation LLM response.\n  operator: _SemanticConsolidationLlmOperator;\n  output: string;\n}\n\n/**\n * Heuristic default operator for a cluster.  Used as the fallback when the\n * LLM does not return a parseable operator, and as the \"floor\" decision in\n * `parseOperatorAwareConsolidationResponse`.\n *\n * Current heuristic (kept deliberately conservative — PR 3 only):\n *\n *   - Two or more memories being collapsed into one canonical blob is a\n *     MERGE by definition.  This is the path the current clustering\n *     pipeline exercises.\n *   - A cluster of size 1 that still reaches consolidation (future path,\n *     e.g. supersession of a single older memory by a newer value) is an\n *     UPDATE.\n *   - SPLIT is never selected by the heuristic because the current write\n *     path emits exactly one canonical memory per cluster.  The prompt\n *     reserves SPLIT for future cluster shapes where the LLM decides one\n *     logical source actually encodes several distinct facts — at which\n *     point the orchestrator would need to write multiple outputs.\n */\nexport function chooseConsolidationOperator(\n  cluster: ConsolidationCluster,\n): _SemanticConsolidationLlmOperator {\n  if (cluster.memories.length <= 1) return \"update\";\n  return \"merge\";\n}\n\n/**\n * Build the operator-aware LLM prompt.  The LLM is asked to return a\n * JSON object `{ \"operator\": <split|merge|update>, \"output\": <content> }`.\n *\n * The prompt is additive: it still asks for a single canonical blob under\n * `output`, so the upstream write path does not change.  Future expansions\n * (SPLIT emitting multiple outputs) are explicitly documented as\n * out-of-scope for the parser — `parseOperatorAwareConsolidationResponse`\n * collapses any SPLIT response into a single canonical output for now.\n */\nexport function buildOperatorAwareConsolidationPrompt(\n  cluster: ConsolidationCluster,\n): string {\n  const memoryTexts = cluster.memories\n    .map(\n      (m, i) =>\n        `Memory ${i + 1} (${m.frontmatter.id}, created ${m.frontmatter.created}):\\n${m.content}`,\n    )\n    .join(\"\\n\\n\");\n\n  return `You are a memory consolidation system.  The following ${cluster.memories.length} memories in the \"${cluster.category}\" category contain overlapping information.\n\nPick exactly ONE consolidation operator for this cluster and return a JSON object.\n\nOperator vocabulary:\n  - \"merge\"  — multiple distinct source memories overlap and should be collapsed into one canonical memory (most common).\n  - \"update\" — one source memory carries a stale value that a newer source supersedes within the same logical fact.\n  - \"split\"  — a single logical source really encodes multiple distinct facts that should be separated (rare; if you pick split, still emit ONE canonical body — the write path will chunk it later).\n\nOutput JSON ONLY, no prose before or after.  The \"operator\" key MUST be set to exactly one of the three strings \"merge\", \"update\", or \"split\" — never a pipe-separated placeholder like \"merge|update|split\".  Example shape:\n  {\n    \"operator\": \"merge\",\n    \"output\": \"<the canonical memory text>\"\n  }\n\nThe \"output\" value must:\n1. Preserve ALL unique information from every source memory\n2. Remove redundancy and repetition\n3. Use clear, concise language\n4. Match the \"${cluster.category}\" category and tone\n5. NOT add information that isn't in the sources\n\n${memoryTexts}\n\nReturn ONLY the JSON object:`;\n}\n\n/**\n * Parse an operator-aware consolidation response.\n *\n * Contract:\n *   - Accepts strict JSON `{ \"operator\": \"...\", \"output\": \"...\" }`.\n *   - Tolerates a JSON payload wrapped in a fenced code block (```json ...```).\n *   - Falls back to the heuristic operator when the JSON is malformed,\n *     the `operator` field is missing / unknown, or the raw response is\n *     a plain blob with no JSON at all.  This keeps PR 3 backwards\n *     compatible with older models that ignore the JSON instruction.\n *   - Never throws.  A missing / empty `output` field falls back to the\n *     trimmed raw response so the caller still writes something rather\n *     than dropping the cluster.\n */\nexport function parseOperatorAwareConsolidationResponse(\n  response: string,\n  cluster: ConsolidationCluster,\n): OperatorAwareConsolidationResult {\n  const fallback: OperatorAwareConsolidationResult = {\n    operator: chooseConsolidationOperator(cluster),\n    output: response.trim(),\n  };\n\n  const trimmed = response.trim();\n  if (trimmed.length === 0) return fallback;\n\n  // Strip a fenced code block if present.\n  const fenced = /^```(?:json)?\\s*([\\s\\S]*?)```\\s*$/u.exec(trimmed);\n  const payload = fenced ? fenced[1].trim() : trimmed;\n\n  // Find a balanced brace-delimited JSON object that has an `operator`\n  // key (PR #632 round-4 review, codex P1).  A first/last-brace slice\n  // breaks when the model prepends an earlier brace block (e.g.\n  // `Example: {\"note\":\"...\"} ... {\"operator\":\"merge\",...}`).  Walk the\n  // payload tracking nesting + string/escape state and skip past\n  // objects that don't look like our target shape.\n  const parsed = findLastJsonObjectWithOperator(payload);\n  if (parsed === undefined) return fallback;\n  if (typeof parsed !== \"object\" || parsed === null) return fallback;\n\n  const obj = parsed as Record<string, unknown>;\n  const rawOperator = typeof obj.operator === \"string\" ? obj.operator.trim().toLowerCase() : \"\";\n  const rawOutput = typeof obj.output === \"string\" ? obj.output : \"\";\n\n  // Narrow gate (Cursor Bugbot review on PR #730 head `aa1c2a8`):\n  // accept ONLY the legacy split/merge/update LLM vocabulary here.\n  // `pattern-reinforcement` joined the broader `ConsolidationOperator`\n  // type in #687 PR 2/4 but is reserved for the maintenance job — if\n  // an LLM hallucinates that operator we must NOT promote it onto\n  // `derived_via`.\n  const operator = _isSemanticConsolidationLlmOperator(rawOperator)\n    ? rawOperator\n    : chooseConsolidationOperator(cluster);\n  const output = rawOutput.trim().length > 0 ? rawOutput.trim() : response.trim();\n\n  return { operator, output };\n}\n\n/**\n * Walk `text`, find all balanced top-level `{ ... }` blocks whose\n * JSON.parse result is an object with an `operator` key, and return\n * the LAST one (function name reflects this — PR #632 review,\n * cursor Low).  Returns `undefined` when nothing matches.  Tracks\n * string state + escape sequences so braces inside string values\n * don't throw off the depth counter.\n *\n * Used by `parseOperatorAwareConsolidationResponse` to tolerate models\n * that prepend an explanatory JSON example block before the real\n * payload (PR #632 round-4 + round-5 review, codex P1).  We take the\n * LAST candidate so that an instructional example with an `operator`\n * key ahead of the real answer doesn't steal precedence — models\n * typically write the example first and the real answer last.\n */\nfunction findLastJsonObjectWithOperator(text: string): unknown {\n  let searchFrom = 0;\n  let last: unknown = undefined;\n  while (searchFrom < text.length) {\n    const start = text.indexOf(\"{\", searchFrom);\n    if (start < 0) return last;\n    let depth = 0;\n    let inString = false;\n    let escape = false;\n    let closed = false;\n    let endIdx = -1;\n    for (let i = start; i < text.length; i++) {\n      const ch = text[i];\n      if (inString) {\n        if (escape) {\n          escape = false;\n        } else if (ch === \"\\\\\") {\n          escape = true;\n        } else if (ch === '\"') {\n          inString = false;\n        }\n        continue;\n      }\n      if (ch === '\"') {\n        inString = true;\n      } else if (ch === \"{\") {\n        depth += 1;\n      } else if (ch === \"}\") {\n        depth -= 1;\n        if (depth === 0) {\n          closed = true;\n          endIdx = i;\n          break;\n        }\n      }\n    }\n    if (!closed) return last;\n    const slice = text.slice(start, endIdx + 1);\n    try {\n      const parsed = JSON.parse(slice);\n      if (\n        typeof parsed === \"object\" &&\n        parsed !== null &&\n        \"operator\" in (parsed as Record<string, unknown>)\n      ) {\n        last = parsed;\n      }\n    } catch {\n      // Fall through to the next candidate.\n    }\n    searchFrom = endIdx + 1;\n  }\n  return last;\n}\n\n// Silence unused-import warnings when tsup tree-shakes: these are used\n// above in chooseConsolidationOperator + parse helpers.\nvoid _CONSOLIDATION_OPERATORS;\n\n/**\n * Discover extensions and build the block to append to a consolidation prompt.\n * Returns \"\" when extensions are disabled or none are found.\n */\nexport async function buildExtensionsBlockForConsolidation(\n  config: PluginConfig,\n): Promise<string> {\n  if (!config.memoryExtensionsEnabled) return \"\";\n  const root = resolveExtensionsRoot(config);\n  const extensions = await discoverMemoryExtensions(root, log);\n  if (extensions.length === 0) return \"\";\n  return renderExtensionsBlock(extensions);\n}\n\n/**\n * Optional post-consolidation hook — materializes the namespace into Codex's\n * native memory layout when the consolidation run finishes. Kept here (rather\n * than in orchestrator.ts) so #378 doesn't conflict with Wave 1 edits.\n *\n * Safe to call regardless of config state: honors `codexMaterializeMemories`\n * and `codexMaterializeOnConsolidation` and silently becomes a no-op when\n * either is disabled.\n */\nexport async function materializeAfterSemanticConsolidation(options: {\n  config: PluginConfig;\n  namespace?: string;\n  memories?: MemoryFile[];\n  memoryDir?: string;\n  codexHome?: string;\n  rolloutSummaries?: RolloutSummaryInput[];\n  now?: Date;\n}): Promise<MaterializeResult | null> {\n  // Delegates to the shared post-consolidation helper so semantic and causal\n  // flows stay in lock-step — any guard/logging change happens in one place.\n  return runPostConsolidationMaterialize(\"[semantic-consolidation]\", options);\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-I6K5FBRQ.js

@@ -0,0 +1,35 @@
+// src/transfer/exclusions.ts
+import path from "path";
+var DEFAULT_TRANSFER_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".secure-store",
+  ".capsules"
+]);
+function computeTransferOutputRel(rootAbs, outputAbs) {
+  const rel = path.relative(rootAbs, outputAbs);
+  if (rel === "") {
+    throw new Error("transfer export output path must not equal the memory directory");
+  }
+  if (rel === ".." || rel.startsWith(`..${path.sep}`)) return null;
+  if (path.isAbsolute(rel)) return null;
+  return rel.split(path.sep).join("/");
+}
+function isTransferPathExcluded(relPosix, options = {}) {
+  const parts = relPosix.split("/");
+  if (parts.some((part) => DEFAULT_TRANSFER_EXCLUDE_DIRS.has(part))) return true;
+  if (!options.includeTranscripts && parts[0] === "transcripts") return true;
+  const outputRelPosix = options.outputRelPosix ?? null;
+  if (outputRelPosix !== null) {
+    if (outputRelPosix === ".") return true;
+    if (relPosix === outputRelPosix || relPosix.startsWith(`${outputRelPosix}/`)) return true;
+  }
+  return false;
+}
+
+export {
+  DEFAULT_TRANSFER_EXCLUDE_DIRS,
+  computeTransferOutputRel,
+  isTransferPathExcluded
+};
+//# sourceMappingURL=chunk-I6K5FBRQ.js.map

package/dist/chunk-I6K5FBRQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transfer/exclusions.ts"],"sourcesContent":["import path from \"node:path\";\n\nexport const DEFAULT_TRANSFER_EXCLUDE_DIRS: ReadonlySet<string> = new Set([\n  \"node_modules\",\n  \".git\",\n  \".secure-store\",\n  \".capsules\",\n]);\n\nexport interface TransferPathExcludeOptions {\n  includeTranscripts?: boolean;\n  outputRelPosix?: string | null;\n}\n\nexport function computeTransferOutputRel(rootAbs: string, outputAbs: string): string | null {\n  const rel = path.relative(rootAbs, outputAbs);\n  if (rel === \"\") {\n    throw new Error(\"transfer export output path must not equal the memory directory\");\n  }\n  if (rel === \"..\" || rel.startsWith(`..${path.sep}`)) return null;\n  if (path.isAbsolute(rel)) return null;\n  return rel.split(path.sep).join(\"/\");\n}\n\nexport function isTransferPathExcluded(relPosix: string, options: TransferPathExcludeOptions = {}): boolean {\n  const parts = relPosix.split(\"/\");\n  if (parts.some((part) => DEFAULT_TRANSFER_EXCLUDE_DIRS.has(part))) return true;\n  if (!options.includeTranscripts && parts[0] === \"transcripts\") return true;\n\n  const outputRelPosix = options.outputRelPosix ?? null;\n  if (outputRelPosix !== null) {\n    if (outputRelPosix === \".\") return true;\n    if (relPosix === outputRelPosix || relPosix.startsWith(`${outputRelPosix}/`)) return true;\n  }\n\n  return false;\n}\n"],"mappings":";AAAA,OAAO,UAAU;AAEV,IAAM,gCAAqD,oBAAI,IAAI;AAAA,EACxE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAOM,SAAS,yBAAyB,SAAiB,WAAkC;AAC1F,QAAM,MAAM,KAAK,SAAS,SAAS,SAAS;AAC5C,MAAI,QAAQ,IAAI;AACd,UAAM,IAAI,MAAM,iEAAiE;AAAA,EACnF;AACA,MAAI,QAAQ,QAAQ,IAAI,WAAW,KAAK,KAAK,GAAG,EAAE,EAAG,QAAO;AAC5D,MAAI,KAAK,WAAW,GAAG,EAAG,QAAO;AACjC,SAAO,IAAI,MAAM,KAAK,GAAG,EAAE,KAAK,GAAG;AACrC;AAEO,SAAS,uBAAuB,UAAkB,UAAsC,CAAC,GAAY;AAC1G,QAAM,QAAQ,SAAS,MAAM,GAAG;AAChC,MAAI,MAAM,KAAK,CAAC,SAAS,8BAA8B,IAAI,IAAI,CAAC,EAAG,QAAO;AAC1E,MAAI,CAAC,QAAQ,sBAAsB,MAAM,CAAC,MAAM,cAAe,QAAO;AAEtE,QAAM,iBAAiB,QAAQ,kBAAkB;AACjD,MAAI,mBAAmB,MAAM;AAC3B,QAAI,mBAAmB,IAAK,QAAO;AACnC,QAAI,aAAa,kBAAkB,SAAS,WAAW,GAAG,cAAc,GAAG,EAAG,QAAO;AAAA,EACvF;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-ICRIXAP2.js

@@ -0,0 +1,121 @@
+import {
+  normalizeReplayContent,
+  normalizeReplayRole,
+  normalizeReplayTimestamp
+} from "./chunk-TZOLIGIG.js";
+
+// src/replay/normalizers/chatgpt.ts
+function gatherConversations(input) {
+  if (Array.isArray(input)) {
+    return input.filter((item) => !!item && typeof item === "object");
+  }
+  if (!input || typeof input !== "object") return [];
+  const obj = input;
+  if (Array.isArray(obj.conversations)) {
+    return obj.conversations.filter((item) => !!item && typeof item === "object");
+  }
+  return [obj];
+}
+function extractFromMapping(conversation) {
+  const mapping = conversation.mapping;
+  if (!mapping || typeof mapping !== "object") return [];
+  const nodes = mapping;
+  const currentNodeId = typeof conversation.current_node === "string" ? conversation.current_node : null;
+  if (!currentNodeId || !nodes[currentNodeId] || typeof nodes[currentNodeId] !== "object") {
+    const loose = [];
+    for (const node of Object.values(nodes)) {
+      if (!node || typeof node !== "object") continue;
+      const nodeObj = node;
+      const message = nodeObj.message;
+      if (!message || typeof message !== "object") continue;
+      loose.push({
+        ...message,
+        _nodeId: typeof nodeObj.id === "string" ? nodeObj.id : void 0,
+        _nodeCreateTime: nodeObj.create_time
+      });
+    }
+    return loose;
+  }
+  const chain = [];
+  const seen = /* @__PURE__ */ new Set();
+  let cursor = currentNodeId;
+  while (cursor && !seen.has(cursor)) {
+    seen.add(cursor);
+    const node = nodes[cursor];
+    if (!node || typeof node !== "object") break;
+    const nodeObj = node;
+    const message = nodeObj.message;
+    if (message && typeof message === "object") {
+      chain.push({
+        ...message,
+        _nodeId: typeof nodeObj.id === "string" ? nodeObj.id : cursor,
+        _nodeCreateTime: nodeObj.create_time
+      });
+    }
+    cursor = typeof nodeObj.parent === "string" ? nodeObj.parent : null;
+  }
+  return chain.reverse();
+}
+var chatgptReplayNormalizer = {
+  source: "chatgpt",
+  parse(input, options = {}) {
+    let parsedInput = input;
+    if (typeof input === "string") {
+      try {
+        parsedInput = JSON.parse(input);
+      } catch {
+        parsedInput = [];
+      }
+    }
+    const warnings = [];
+    const turns = [];
+    const conversations = gatherConversations(parsedInput);
+    for (let i = 0; i < conversations.length; i += 1) {
+      const conversation = conversations[i];
+      const convIdRaw = conversation.id ?? conversation.conversation_id ?? conversation.uuid;
+      const hasSourceConversationId = typeof convIdRaw === "string" && convIdRaw.trim().length > 0;
+      const convId = hasSourceConversationId ? convIdRaw.trim() : `conv-${i + 1}`;
+      const sessionKey = `replay:chatgpt:${convId}`;
+      const fallbackSessionKey = options.defaultSessionKey?.trim() || sessionKey;
+      const messageRows = Array.isArray(conversation.messages) ? conversation.messages.filter((item) => !!item && typeof item === "object") : extractFromMapping(conversation);
+      for (let j = 0; j < messageRows.length; j += 1) {
+        const row = messageRows[j];
+        const role = normalizeReplayRole(
+          row.author?.role ?? row.role
+        );
+        const content = normalizeReplayContent(
+          row.content?.parts ?? row.content ?? row.text
+        );
+        const timestamp = normalizeReplayTimestamp(
+          row.create_time ?? row.timestamp ?? row._nodeCreateTime ?? row.created_at
+        );
+        if (!role || !content || !timestamp) {
+          const message = `Skipping invalid ChatGPT replay message at conversation ${i + 1}, index ${j}.`;
+          if (options.strict) throw new Error(message);
+          warnings.push({ code: "replay.chatgpt.message.invalid", message, index: j });
+          continue;
+        }
+        const externalIdRaw = row.id ?? row._nodeId;
+        turns.push({
+          source: "chatgpt",
+          sessionKey: hasSourceConversationId ? sessionKey : fallbackSessionKey,
+          role,
+          content,
+          timestamp,
+          sourceValidAt: timestamp,
+          externalId: typeof externalIdRaw === "string" ? externalIdRaw : void 0,
+          metadata: {
+            conversationId: convId,
+            conversationTitle: typeof conversation.title === "string" ? conversation.title : void 0
+          }
+        });
+      }
+    }
+    return { turns, warnings };
+  }
+};
+
+export {
+  chatgptReplayNormalizer
+};
+//# sourceMappingURL=chunk-ICRIXAP2.js.map

package/dist/chunk-ICRIXAP2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/replay/normalizers/chatgpt.ts"],"sourcesContent":["import {\n  type ReplayNormalizer,\n  type ReplayParseOptions,\n  type ReplayParseResult,\n  type ReplayTurn,\n} from \"../types.js\";\nimport { normalizeReplayContent, normalizeReplayRole, normalizeReplayTimestamp } from \"./shared.js\";\n\nfunction gatherConversations(input: unknown): Array<Record<string, unknown>> {\n  if (Array.isArray(input)) {\n    return input.filter((item): item is Record<string, unknown> => !!item && typeof item === \"object\");\n  }\n  if (!input || typeof input !== \"object\") return [];\n  const obj = input as Record<string, unknown>;\n  if (Array.isArray(obj.conversations)) {\n    return obj.conversations.filter((item): item is Record<string, unknown> => !!item && typeof item === \"object\");\n  }\n  return [obj];\n}\n\nfunction extractFromMapping(conversation: Record<string, unknown>): Array<Record<string, unknown>> {\n  const mapping = conversation.mapping;\n  if (!mapping || typeof mapping !== \"object\") return [];\n  const nodes = mapping as Record<string, unknown>;\n  const currentNodeId = typeof conversation.current_node === \"string\" ? conversation.current_node : null;\n\n  if (!currentNodeId || !nodes[currentNodeId] || typeof nodes[currentNodeId] !== \"object\") {\n    // Fallback for malformed/legacy exports without a traversable active pointer.\n    const loose: Array<Record<string, unknown>> = [];\n    for (const node of Object.values(nodes)) {\n      if (!node || typeof node !== \"object\") continue;\n      const nodeObj = node as Record<string, unknown>;\n      const message = nodeObj.message;\n      if (!message || typeof message !== \"object\") continue;\n      loose.push({\n        ...(message as Record<string, unknown>),\n        _nodeId: typeof nodeObj.id === \"string\" ? nodeObj.id : undefined,\n        _nodeCreateTime: nodeObj.create_time,\n      });\n    }\n    return loose;\n  }\n\n  const chain: Array<Record<string, unknown>> = [];\n  const seen = new Set<string>();\n  let cursor: string | null = currentNodeId;\n  while (cursor && !seen.has(cursor)) {\n    seen.add(cursor);\n    const node = nodes[cursor];\n    if (!node || typeof node !== \"object\") break;\n    const nodeObj = node as Record<string, unknown>;\n    const message = nodeObj.message;\n    if (message && typeof message === \"object\") {\n      chain.push({\n        ...(message as Record<string, unknown>),\n        _nodeId: typeof nodeObj.id === \"string\" ? nodeObj.id : cursor,\n        _nodeCreateTime: nodeObj.create_time,\n      });\n    }\n    cursor = typeof nodeObj.parent === \"string\" ? nodeObj.parent : null;\n  }\n\n  return chain.reverse();\n}\n\nexport const chatgptReplayNormalizer: ReplayNormalizer = {\n  source: \"chatgpt\",\n  parse(input: unknown, options: ReplayParseOptions = {}): ReplayParseResult {\n    let parsedInput = input;\n    if (typeof input === \"string\") {\n      try {\n        parsedInput = JSON.parse(input);\n      } catch {\n        parsedInput = [];\n      }\n    }\n\n    const warnings: ReplayParseResult[\"warnings\"] = [];\n    const turns: ReplayTurn[] = [];\n\n    const conversations = gatherConversations(parsedInput);\n    for (let i = 0; i < conversations.length; i += 1) {\n      const conversation = conversations[i];\n      const convIdRaw = conversation.id ?? conversation.conversation_id ?? conversation.uuid;\n      const hasSourceConversationId = typeof convIdRaw === \"string\" && convIdRaw.trim().length > 0;\n      const convId = hasSourceConversationId ? convIdRaw.trim() : `conv-${i + 1}`;\n      const sessionKey = `replay:chatgpt:${convId}`;\n      const fallbackSessionKey = options.defaultSessionKey?.trim() || sessionKey;\n\n      const messageRows = Array.isArray(conversation.messages)\n        ? conversation.messages.filter((item): item is Record<string, unknown> => !!item && typeof item === \"object\")\n        : extractFromMapping(conversation);\n\n      for (let j = 0; j < messageRows.length; j += 1) {\n        const row = messageRows[j];\n        const role = normalizeReplayRole(\n          (row.author as Record<string, unknown> | undefined)?.role ?? row.role,\n        );\n        const content = normalizeReplayContent(\n          (row.content as Record<string, unknown> | undefined)?.parts ?? row.content ?? row.text,\n        );\n        const timestamp = normalizeReplayTimestamp(\n          row.create_time ?? row.timestamp ?? row._nodeCreateTime ?? row.created_at,\n        );\n\n        if (!role || !content || !timestamp) {\n          const message = `Skipping invalid ChatGPT replay message at conversation ${i + 1}, index ${j}.`;\n          if (options.strict) throw new Error(message);\n          warnings.push({ code: \"replay.chatgpt.message.invalid\", message, index: j });\n          continue;\n        }\n\n        const externalIdRaw = row.id ?? row._nodeId;\n\n        turns.push({\n          source: \"chatgpt\",\n          sessionKey: hasSourceConversationId ? sessionKey : fallbackSessionKey,\n          role,\n          content,\n          timestamp,\n          sourceValidAt: timestamp,\n          externalId: typeof externalIdRaw === \"string\" ? externalIdRaw : undefined,\n          metadata: {\n            conversationId: convId,\n            conversationTitle: typeof conversation.title === \"string\" ? conversation.title : undefined,\n          },\n        });\n      }\n    }\n\n    return { turns, warnings };\n  },\n};\n"],"mappings":"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","names":[]}

package/dist/chunk-J4EB7DNW.js

@@ -0,0 +1,11 @@
+// src/transfer/constants.ts
+var EXPORT_FORMAT = "openclaw-engram-export";
+var EXPORT_SCHEMA_VERSION = 1;
+var CAPSULE_SCHEMA_VERSION = 2;
+
+export {
+  EXPORT_FORMAT,
+  EXPORT_SCHEMA_VERSION,
+  CAPSULE_SCHEMA_VERSION
+};
+//# sourceMappingURL=chunk-J4EB7DNW.js.map

package/dist/chunk-J4EB7DNW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transfer/constants.ts"],"sourcesContent":["export const EXPORT_FORMAT = \"openclaw-engram-export\" as const;\nexport const EXPORT_SCHEMA_VERSION = 1 as const;\n\n/**\n * Schema version for capsule-aware (V2) export manifests. See\n * {@link ../types.ts} `ExportManifestV2Schema` for the wire format.\n *\n * V1 manifests remain the default for non-capsule exports\n * (`exportJsonBundle` / `exportMarkdownBundle`). V2 is emitted by the\n * capsule export pipeline only.\n */\nexport const CAPSULE_SCHEMA_VERSION = 2 as const;\n\n"],"mappings":";AAAO,IAAM,gBAAgB;AACtB,IAAM,wBAAwB;AAU9B,IAAM,yBAAyB;","names":[]}

package/dist/chunk-JLFA7DQG.js

@@ -0,0 +1,62 @@
+import {
+  toBackupStamp
+} from "./chunk-KJTKLXTH.js";
+import {
+  StorageManager
+} from "./chunk-7AAT6G4Q.js";
+import {
+  buildLifecycleEventsForMemory,
+  sortMemoryLifecycleEvents
+} from "./chunk-RULE4VG5.js";
+
+// src/maintenance/rebuild-memory-lifecycle-ledger.ts
+import path from "path";
+import { mkdir, rename, stat, writeFile } from "fs/promises";
+async function backupExistingLedger(memoryDir, outputPath, now) {
+  try {
+    await stat(outputPath);
+  } catch {
+    return void 0;
+  }
+  const backupPath = path.join(
+    memoryDir,
+    "archive",
+    "memory-lifecycle-ledger",
+    toBackupStamp(now),
+    "state",
+    "memory-lifecycle-ledger.jsonl"
+  );
+  await mkdir(path.dirname(backupPath), { recursive: true });
+  await rename(outputPath, backupPath);
+  return backupPath;
+}
+async function rebuildMemoryLifecycleLedger(options) {
+  const dryRun = options.dryRun !== false;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const outputPath = path.join(options.memoryDir, "state", "memory-lifecycle-ledger.jsonl");
+  const storage = new StorageManager(options.memoryDir);
+  const allMemories = [...await storage.readAllMemories(), ...await storage.readArchivedMemories()].sort((a, b) => a.frontmatter.id.localeCompare(b.frontmatter.id));
+  const events = sortMemoryLifecycleEvents(
+    allMemories.flatMap((memory) => buildLifecycleEventsForMemory(memory))
+  );
+  let backupPath;
+  if (!dryRun) {
+    backupPath = await backupExistingLedger(options.memoryDir, outputPath, now);
+    await mkdir(path.dirname(outputPath), { recursive: true });
+    const payload = events.map((event) => JSON.stringify(event)).join("\n");
+    await writeFile(outputPath, payload.length > 0 ? `${payload}
+` : "", "utf-8");
+  }
+  return {
+    dryRun,
+    scannedMemories: allMemories.length,
+    rebuiltRows: events.length,
+    outputPath,
+    backupPath
+  };
+}
+
+export {
+  rebuildMemoryLifecycleLedger
+};
+//# sourceMappingURL=chunk-JLFA7DQG.js.map

package/dist/chunk-JLFA7DQG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/maintenance/rebuild-memory-lifecycle-ledger.ts"],"sourcesContent":["import path from \"node:path\";\nimport { mkdir, rename, stat, writeFile } from \"node:fs/promises\";\nimport { StorageManager } from \"../storage.js\";\nimport type { MemoryLifecycleEvent } from \"../types.js\";\nimport { toBackupStamp } from \"./backup-stamp.js\";\nimport {\n  buildLifecycleEventsForMemory,\n  sortMemoryLifecycleEvents,\n} from \"../memory-lifecycle-ledger-utils.js\";\n\nexport interface RebuildMemoryLifecycleLedgerOptions {\n  memoryDir: string;\n  dryRun?: boolean;\n  now?: Date;\n}\n\nexport interface RebuildMemoryLifecycleLedgerResult {\n  dryRun: boolean;\n  scannedMemories: number;\n  rebuiltRows: number;\n  outputPath: string;\n  backupPath?: string;\n}\n\nasync function backupExistingLedger(\n  memoryDir: string,\n  outputPath: string,\n  now: Date,\n): Promise<string | undefined> {\n  try {\n    await stat(outputPath);\n  } catch {\n    return undefined;\n  }\n\n  const backupPath = path.join(\n    memoryDir,\n    \"archive\",\n    \"memory-lifecycle-ledger\",\n    toBackupStamp(now),\n    \"state\",\n    \"memory-lifecycle-ledger.jsonl\",\n  );\n  await mkdir(path.dirname(backupPath), { recursive: true });\n  await rename(outputPath, backupPath);\n  return backupPath;\n}\n\nexport async function rebuildMemoryLifecycleLedger(\n  options: RebuildMemoryLifecycleLedgerOptions,\n): Promise<RebuildMemoryLifecycleLedgerResult> {\n  const dryRun = options.dryRun !== false;\n  const now = options.now ?? new Date();\n  const outputPath = path.join(options.memoryDir, \"state\", \"memory-lifecycle-ledger.jsonl\");\n  const storage = new StorageManager(options.memoryDir);\n  const allMemories = [...await storage.readAllMemories(), ...await storage.readArchivedMemories()]\n    .sort((a, b) => a.frontmatter.id.localeCompare(b.frontmatter.id));\n\n  const events: MemoryLifecycleEvent[] = sortMemoryLifecycleEvents(\n    allMemories.flatMap((memory) => buildLifecycleEventsForMemory(memory)),\n  );\n\n  let backupPath: string | undefined;\n  if (!dryRun) {\n    backupPath = await backupExistingLedger(options.memoryDir, outputPath, now);\n    await mkdir(path.dirname(outputPath), { recursive: true });\n    const payload = events.map((event) => JSON.stringify(event)).join(\"\\n\");\n    await writeFile(outputPath, payload.length > 0 ? `${payload}\\n` : \"\", \"utf-8\");\n  }\n\n  return {\n    dryRun,\n    scannedMemories: allMemories.length,\n    rebuiltRows: events.length,\n    outputPath,\n    backupPath,\n  };\n}\n"],"mappings":";;;;;;;;;;;;AAAA,OAAO,UAAU;AACjB,SAAS,OAAO,QAAQ,MAAM,iBAAiB;AAuB/C,eAAe,qBACb,WACA,YACA,KAC6B;AAC7B,MAAI;AACF,UAAM,KAAK,UAAU;AAAA,EACvB,QAAQ;AACN,WAAO;AAAA,EACT;AAEA,QAAM,aAAa,KAAK;AAAA,IACtB;AAAA,IACA;AAAA,IACA;AAAA,IACA,cAAc,GAAG;AAAA,IACjB;AAAA,IACA;AAAA,EACF;AACA,QAAM,MAAM,KAAK,QAAQ,UAAU,GAAG,EAAE,WAAW,KAAK,CAAC;AACzD,QAAM,OAAO,YAAY,UAAU;AACnC,SAAO;AACT;AAEA,eAAsB,6BACpB,SAC6C;AAC7C,QAAM,SAAS,QAAQ,WAAW;AAClC,QAAM,MAAM,QAAQ,OAAO,oBAAI,KAAK;AACpC,QAAM,aAAa,KAAK,KAAK,QAAQ,WAAW,SAAS,+BAA+B;AACxF,QAAM,UAAU,IAAI,eAAe,QAAQ,SAAS;AACpD,QAAM,cAAc,CAAC,GAAG,MAAM,QAAQ,gBAAgB,GAAG,GAAG,MAAM,QAAQ,qBAAqB,CAAC,EAC7F,KAAK,CAAC,GAAG,MAAM,EAAE,YAAY,GAAG,cAAc,EAAE,YAAY,EAAE,CAAC;AAElE,QAAM,SAAiC;AAAA,IACrC,YAAY,QAAQ,CAAC,WAAW,8BAA8B,MAAM,CAAC;AAAA,EACvE;AAEA,MAAI;AACJ,MAAI,CAAC,QAAQ;AACX,iBAAa,MAAM,qBAAqB,QAAQ,WAAW,YAAY,GAAG;AAC1E,UAAM,MAAM,KAAK,QAAQ,UAAU,GAAG,EAAE,WAAW,KAAK,CAAC;AACzD,UAAM,UAAU,OAAO,IAAI,CAAC,UAAU,KAAK,UAAU,KAAK,CAAC,EAAE,KAAK,IAAI;AACtE,UAAM,UAAU,YAAY,QAAQ,SAAS,IAAI,GAAG,OAAO;AAAA,IAAO,IAAI,OAAO;AAAA,EAC/E;AAEA,SAAO;AAAA,IACL;AAAA,IACA,iBAAiB,YAAY;AAAA,IAC7B,aAAa,OAAO;AAAA,IACpB;AAAA,IACA;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-KJTKLXTH.js

@@ -0,0 +1,9 @@
+// src/maintenance/backup-stamp.ts
+function toBackupStamp(now) {
+  return now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+
+export {
+  toBackupStamp
+};
+//# sourceMappingURL=chunk-KJTKLXTH.js.map

package/dist/chunk-KJTKLXTH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/maintenance/backup-stamp.ts"],"sourcesContent":["export function toBackupStamp(now: Date): string {\n  return now.toISOString().replace(/[-:]/g, \"\").replace(/\\.\\d{3}Z$/, \"Z\");\n}\n"],"mappings":";AAAO,SAAS,cAAc,KAAmB;AAC/C,SAAO,IAAI,YAAY,EAAE,QAAQ,SAAS,EAAE,EAAE,QAAQ,aAAa,GAAG;AACxE;","names":[]}