@remnic/core 1.1.30 → 9.3.515

package/dist/{chunk-XSZEP4SF.js → chunk-6XSPNR6L.js}

@@ -1,11 +1,11 @@
 import {
   runPostConsolidationMaterialize
-} from "./chunk-4KGVTPGD.js";
+} from "./chunk-6F6BXB7A.js";
 import {
   discoverMemoryExtensions,
   renderExtensionsBlock,
   resolveExtensionsRoot
-} from "./chunk-EJI5XIBB.js";
+} from "./chunk-JLNBQWZ2.js";
 import {
   isSemanticConsolidationLlmOperator
 } from "./chunk-G7D6GZ5J.js";
@@ -39,11 +39,13 @@ function findSimilarClusters(memories, config) {
     }));
     const clustered = /* @__PURE__ */ new Set();
     for (let i = 0; i < tokenized.length && totalCandidates < config.maxPerRun; i++) {
+      const remainingBudget = config.maxPerRun - totalCandidates;
+      if (remainingBudget < config.minClusterSize) break;
       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++) {
+      for (let j = i + 1; j < tokenized.length && cluster.length < remainingBudget; j++) {
         if (clustered.has(tokenized[j].memory.frontmatter.id)) continue;
         const aTokens = tokenized[i].tokens;
         const bTokens = tokenized[j].tokens;
@@ -55,7 +57,6 @@ function findSimilarClusters(memories, config) {
           cluster.push(tokenized[j].memory);
           totalOverlap += score;
           comparisons++;
-          if (totalCandidates + cluster.length >= config.maxPerRun) break;
         }
       }
       if (cluster.length >= config.minClusterSize) {
@@ -216,4 +217,4 @@ export {
   buildExtensionsBlockForConsolidation,
   materializeAfterSemanticConsolidation
 };
-//# sourceMappingURL=chunk-XSZEP4SF.js.map
+//# sourceMappingURL=chunk-6XSPNR6L.js.map

package/dist/chunk-6XSPNR6L.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      const remainingBudget = config.maxPerRun - totalCandidates;\n      if (remainingBudget < config.minClusterSize) break;\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 && cluster.length < remainingBudget; 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        }\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-6H2TESSP.js → chunk-765K3SAT.js}

@@ -5,13 +5,13 @@ import {
 import {
   computeTransferOutputRel,
   isTransferPathExcluded
-} from "./chunk-I6K5FBRQ.js";
+} from "./chunk-UI3NYK34.js";
 import {
   listFilesRecursive,
   sha256File,
   toPosixRelPath,
   writeJsonFile
-} from "./chunk-AGZQD76C.js";
+} from "./chunk-GCGJW34D.js";
 
 // src/transfer/export-md.ts
 import path from "path";
@@ -59,4 +59,4 @@ export {
   exportMarkdownBundle,
   looksLikeEngramMdExport
 };
-//# sourceMappingURL=chunk-6H2TESSP.js.map
+//# sourceMappingURL=chunk-765K3SAT.js.map

package/dist/{chunk-EDTHC6UD.js → chunk-77NAFXUD.js}

@@ -4,7 +4,7 @@ import {
 import {
   mergeEnv,
   readEnvVar
-} from "./chunk-XIG5PDM7.js";
+} from "./chunk-JUC24CTX.js";
 import {
   log
 } from "./chunk-2ODBA7MQ.js";
@@ -1072,4 +1072,4 @@ var LocalLlmClient = class _LocalLlmClient {
 export {
   LocalLlmClient
 };
-//# sourceMappingURL=chunk-EDTHC6UD.js.map
+//# sourceMappingURL=chunk-77NAFXUD.js.map

package/dist/{chunk-S7KDBTWT.js → chunk-7F7Z6MOS.js}

@@ -2,10 +2,10 @@ import {
   normalizeReplayContent,
   normalizeReplayRole,
   normalizeReplayTimestamp
-} from "./chunk-TZOLIGIG.js";
+} from "./chunk-JJEJJ7RK.js";
 
 // src/replay/normalizers/openclaw.ts
-function parseJsonl(raw, warnings) {
+function parseJsonl(raw, warnings, strict) {
   const out = [];
   for (const [index, line] of raw.split("\n").entries()) {
     const trimmed = line.trim();
@@ -13,23 +13,27 @@ function parseJsonl(raw, warnings) {
     try {
       out.push(JSON.parse(trimmed));
     } catch {
-      warnings.push({
+      const warning = {
         code: "replay.openclaw.jsonl.invalid_line",
         message: `Skipping invalid JSONL line ${index + 1}.`,
         index
-      });
+      };
+      if (strict) throw new Error(warning.message);
+      warnings.push(warning);
     }
   }
   return out;
 }
-function gatherCandidates(input, warnings) {
+function gatherCandidates(input, warnings, strict) {
   if (Array.isArray(input)) return input;
   if (typeof input === "string") {
+    let parsed;
     try {
-      return gatherCandidates(JSON.parse(input), warnings);
+      parsed = JSON.parse(input);
     } catch {
-      return parseJsonl(input, warnings);
+      return parseJsonl(input, warnings, strict);
     }
+    return gatherCandidates(parsed, warnings, strict);
   }
   if (!input || typeof input !== "object") return [];
   const obj = input;
@@ -38,14 +42,23 @@ function gatherCandidates(input, warnings) {
   if (Array.isArray(obj.messages)) return obj.messages;
   if (Array.isArray(obj.records)) {
     const rows = [];
-    for (const rec of obj.records) {
-      if (!rec || typeof rec !== "object") continue;
+    for (const [index, rec] of obj.records.entries()) {
+      if (!rec || typeof rec !== "object") {
+        const warning = {
+          code: "replay.openclaw.record.invalid",
+          message: `Skipping non-object OpenClaw replay record at index ${index}.`,
+          index
+        };
+        if (strict) throw new Error(warning.message);
+        warnings.push(warning);
+        continue;
+      }
       const record = rec;
       const content = typeof record.content === "string" ? record.content : null;
       if (!content) continue;
       const path = typeof record.path === "string" ? record.path : "";
       if (!path.startsWith("transcripts/") && !path.includes("/transcripts/")) continue;
-      rows.push(...parseJsonl(content, warnings));
+      rows.push(...parseJsonl(content, warnings, strict));
     }
     return rows;
   }
@@ -55,17 +68,19 @@ var openclawReplayNormalizer = {
   source: "openclaw",
   parse(input, options = {}) {
     const warnings = [];
-    const rawTurns = gatherCandidates(input, warnings);
+    const rawTurns = gatherCandidates(input, warnings, options.strict);
     const turns = [];
     const defaultSessionKey = options.defaultSessionKey?.trim() || "replay:openclaw:import";
     for (let i = 0; i < rawTurns.length; i += 1) {
       const raw = rawTurns[i];
       if (!raw || typeof raw !== "object") {
-        warnings.push({
+        const warning = {
           code: "replay.openclaw.turn.invalid",
           message: "Skipping non-object replay turn.",
           index: i
-        });
+        };
+        if (options.strict) throw new Error(warning.message);
+        warnings.push(warning);
         continue;
       }
       const row = raw;
@@ -103,4 +118,4 @@ var openclawReplayNormalizer = {
 export {
   openclawReplayNormalizer
 };
-//# sourceMappingURL=chunk-S7KDBTWT.js.map
+//# sourceMappingURL=chunk-7F7Z6MOS.js.map

package/dist/chunk-7F7Z6MOS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/replay/normalizers/openclaw.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 parseJsonl(\n  raw: string,\n  warnings: Array<{ code: string; message: string; index?: number }>,\n  strict: boolean | undefined,\n): unknown[] {\n  const out: unknown[] = [];\n  for (const [index, line] of raw.split(\"\\n\").entries()) {\n    const trimmed = line.trim();\n    if (!trimmed) continue;\n    try {\n      out.push(JSON.parse(trimmed));\n    } catch {\n      const warning = {\n        code: \"replay.openclaw.jsonl.invalid_line\",\n        message: `Skipping invalid JSONL line ${index + 1}.`,\n        index,\n      };\n      if (strict) throw new Error(warning.message);\n      warnings.push(warning);\n    }\n  }\n  return out;\n}\n\nfunction gatherCandidates(\n  input: unknown,\n  warnings: Array<{ code: string; message: string; index?: number }>,\n  strict: boolean | undefined,\n): unknown[] {\n  if (Array.isArray(input)) return input;\n\n  if (typeof input === \"string\") {\n    let parsed: unknown;\n    try {\n      parsed = JSON.parse(input);\n    } catch {\n      return parseJsonl(input, warnings, strict);\n    }\n    return gatherCandidates(parsed, warnings, strict);\n  }\n\n  if (!input || typeof input !== \"object\") return [];\n  const obj = input as Record<string, unknown>;\n\n  if (Array.isArray(obj.turns)) return obj.turns;\n  if (Array.isArray(obj.entries)) return obj.entries;\n  if (Array.isArray(obj.messages)) return obj.messages;\n\n  if (Array.isArray(obj.records)) {\n    const rows: unknown[] = [];\n    for (const [index, rec] of obj.records.entries()) {\n      if (!rec || typeof rec !== \"object\") {\n        const warning = {\n          code: \"replay.openclaw.record.invalid\",\n          message: `Skipping non-object OpenClaw replay record at index ${index}.`,\n          index,\n        };\n        if (strict) throw new Error(warning.message);\n        warnings.push(warning);\n        continue;\n      }\n      const record = rec as Record<string, unknown>;\n      const content = typeof record.content === \"string\" ? record.content : null;\n      if (!content) continue;\n      const path = typeof record.path === \"string\" ? record.path : \"\";\n      if (!path.startsWith(\"transcripts/\") && !path.includes(\"/transcripts/\")) continue;\n      rows.push(...parseJsonl(content, warnings, strict));\n    }\n    return rows;\n  }\n\n  return [];\n}\n\nexport const openclawReplayNormalizer: ReplayNormalizer = {\n  source: \"openclaw\",\n  parse(input: unknown, options: ReplayParseOptions = {}): ReplayParseResult {\n    const warnings: ReplayParseResult[\"warnings\"] = [];\n    const rawTurns = gatherCandidates(input, warnings, options.strict);\n    const turns: ReplayTurn[] = [];\n\n    const defaultSessionKey = options.defaultSessionKey?.trim() || \"replay:openclaw:import\";\n\n    for (let i = 0; i < rawTurns.length; i += 1) {\n      const raw = rawTurns[i];\n      if (!raw || typeof raw !== \"object\") {\n        const warning = {\n          code: \"replay.openclaw.turn.invalid\",\n          message: \"Skipping non-object replay turn.\",\n          index: i,\n        };\n        if (options.strict) throw new Error(warning.message);\n        warnings.push(warning);\n        continue;\n      }\n\n      const row = raw as Record<string, unknown>;\n      const role = normalizeReplayRole(row.role ?? row.sender ?? (row.author as Record<string, unknown> | undefined)?.role, {\n        assistantAliases: [\"bot\"],\n      });\n      const content = normalizeReplayContent(row.content ?? row.text ?? row.message);\n      const timestamp = normalizeReplayTimestamp(\n        row.timestamp ?? row.createdAt ?? row.created_at ?? row.time ?? row.date,\n        { acceptDateObject: true },\n      );\n\n      if (!role || !content || !timestamp) {\n        const message = `Skipping invalid openclaw turn at index ${i}.`;\n        if (options.strict) throw new Error(message);\n        warnings.push({ code: \"replay.openclaw.turn.invalid\", message, index: i });\n        continue;\n      }\n\n      const sessionKeyRaw = row.sessionKey ?? row.session_key;\n      const sessionKey = typeof sessionKeyRaw === \"string\" && sessionKeyRaw.trim().length > 0\n        ? sessionKeyRaw.trim()\n        : defaultSessionKey;\n\n      const externalIdRaw = row.turnId ?? row.turn_id ?? row.id;\n\n      turns.push({\n        source: \"openclaw\",\n        sessionKey,\n        role,\n        content,\n        timestamp,\n        sourceValidAt: timestamp,\n        externalId: typeof externalIdRaw === \"string\" ? externalIdRaw : undefined,\n      });\n    }\n\n    return { turns, warnings };\n  },\n};\n"],"mappings":"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","names":[]}

package/dist/{chunk-MZH6EHNR.js → chunk-7H6CFEBJ.js}

@@ -9,10 +9,13 @@ import {
 import {
   normalizeEntitySchemas
 } from "./chunk-4DJQYKMN.js";
+import {
+  expandTildePath
+} from "./chunk-EYIEWJNI.js";
 import {
   readEnvVar,
   resolveHomeDir
-} from "./chunk-XIG5PDM7.js";
+} from "./chunk-JUC24CTX.js";
 import {
   log
 } from "./chunk-2ODBA7MQ.js";
@@ -108,6 +111,26 @@ function parseIntegerAtLeast(value, fallback, min, keyName) {
   }
   return coerced;
 }
+function parseOptionalIntegerAtLeast(value, min, keyName) {
+  if (value === void 0 || value === null) return void 0;
+  const coerced = coerceNumber(value);
+  if (coerced === void 0 || !Number.isFinite(coerced) || !Number.isInteger(coerced) || coerced < min) {
+    throw new Error(
+      `${keyName} must be an integer greater than or equal to ${min}; got ${JSON.stringify(value)}`
+    );
+  }
+  return coerced;
+}
+function parsePortNumber(value, fallback, keyName) {
+  if (value === void 0 || value === null) return fallback;
+  const coerced = coerceNumber(value);
+  if (coerced === void 0 || !Number.isInteger(coerced) || coerced < 0 || coerced > 65535) {
+    throw new Error(
+      `${keyName} must be an integer from 0 to 65535; got ${JSON.stringify(value)}`
+    );
+  }
+  return coerced;
+}
 function coerceBooleanLike(value) {
   if (typeof value === "boolean") return value;
   if (typeof value === "number") {
@@ -151,6 +174,12 @@ function parseAgentAccessAuthToken(raw) {
     "unsupported SecretRef shape for agentAccessHttp.authToken \u2014 expected a string or an object with a non-empty `source` field (see https://github.com/joshuaswarren/remnic/issues/757)"
   );
 }
+function parseAgentAccessPrincipal(raw) {
+  if (typeof raw === "string" && raw.trim().length > 0) {
+    return resolveEnvVars(raw);
+  }
+  return readEnvVar("OPENCLAW_REMNIC_ACCESS_PRINCIPAL")?.trim() || readEnvVar("OPENCLAW_ENGRAM_ACCESS_PRINCIPAL")?.trim() || void 0;
+}
 function resolveEnvVars(value) {
   const resolved = value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, envVar) => {
     const envValue = readEnvVar(envVar);
@@ -557,7 +586,7 @@ function parseConfig(raw) {
     // read fallbacks so globally useful memories remain visible. CLAUDE.md #30.
     globalFallback: codingGlobalFallbackRaw === void 0 ? true : codingGlobalFallbackRaw
   };
-  const memoryDir = typeof cfg.memoryDir === "string" && cfg.memoryDir.length > 0 ? cfg.memoryDir : DEFAULT_MEMORY_DIR;
+  const memoryDir = typeof cfg.memoryDir === "string" && cfg.memoryDir.length > 0 ? expandTildePath(cfg.memoryDir) : DEFAULT_MEMORY_DIR;
   const rawIdentityInjectionMode = cfg.identityInjectionMode;
   const identityInjectionMode = rawIdentityInjectionMode && VALID_IDENTITY_INJECTION_MODES.includes(rawIdentityInjectionMode) ? rawIdentityInjectionMode : "recovery_only";
   const identityContinuityEnabled = cfg.identityContinuityEnabled === true;
@@ -643,9 +672,9 @@ function parseConfig(raw) {
   const agentAccessHttp = {
     enabled: rawAgentAccessHttp?.enabled === true,
     host: typeof rawAgentAccessHttp?.host === "string" && rawAgentAccessHttp.host.trim().length > 0 ? rawAgentAccessHttp.host.trim() : "127.0.0.1",
-    port: typeof rawAgentAccessHttp?.port === "number" ? Math.max(0, Math.floor(rawAgentAccessHttp.port)) : 4318,
+    port: parsePortNumber(rawAgentAccessHttp?.port, 4318, "agentAccessHttp.port"),
     [["auth", "Token"].join("")]: agentAccessAuthToken,
-    principal: typeof rawAgentAccessHttp?.principal === "string" && rawAgentAccessHttp.principal.trim().length > 0 ? resolveEnvVars(rawAgentAccessHttp.principal) : readEnvVar("OPENCLAW_ENGRAM_ACCESS_PRINCIPAL")?.trim() || void 0,
+    principal: parseAgentAccessPrincipal(rawAgentAccessHttp?.principal),
     maxBodyBytes: typeof rawAgentAccessHttp?.maxBodyBytes === "number" ? Math.max(1, Math.floor(rawAgentAccessHttp.maxBodyBytes)) : 131072
   };
   let baseUrl;
@@ -760,7 +789,7 @@ function parseConfig(raw) {
       1,
       "commitmentDecayDays"
     ),
-    workspaceDir: typeof cfg.workspaceDir === "string" && cfg.workspaceDir.length > 0 ? cfg.workspaceDir : DEFAULT_WORKSPACE_DIR,
+    workspaceDir: typeof cfg.workspaceDir === "string" && cfg.workspaceDir.length > 0 ? expandTildePath(cfg.workspaceDir) : DEFAULT_WORKSPACE_DIR,
     captureMode,
     fileHygiene,
     nativeKnowledge,
@@ -809,12 +838,10 @@ function parseConfig(raw) {
     // On by default
     temporalSupersessionIncludeInRecall: cfg.temporalSupersessionIncludeInRecall === true,
     // Off by default
-    // Direct-answer retrieval tier (issue #518).  Default on — the
-    // tier runs in observation mode: it annotates
-    // LastRecallSnapshot.tierExplain but never short-circuits the
-    // QMD path.  Operators can opt out with
-    // recallDirectAnswerEnabled=false.
-    recallDirectAnswerEnabled: coerceBool(cfg.recallDirectAnswerEnabled) ?? true,
+    // Direct-answer retrieval tier (issue #518).  Default off so the
+    // recall path keeps least-privileged behavior unless operators
+    // explicitly opt in.
+    recallDirectAnswerEnabled: coerceBool(cfg.recallDirectAnswerEnabled) ?? false,
     // Disclosure auto-escalation (issue #677 PR 4/4).  Default `manual`
     // so pre-#677 callers see unchanged behavior.  Reject anything
     // outside the allow-list rather than silently defaulting (CLAUDE.md
@@ -1269,7 +1296,7 @@ function parseConfig(raw) {
     localLmsCliPath: typeof cfg.localLmsCliPath === "string" && cfg.localLmsCliPath.length > 0 ? cfg.localLmsCliPath : void 0,
     localLmsBinDir: typeof cfg.localLmsBinDir === "string" && cfg.localLmsBinDir.length > 0 ? cfg.localLmsBinDir : void 0,
     localLlmTimeoutMs: parseBoundedIntegerMs(cfg.localLlmTimeoutMs, 18e4, 1, 864e5),
-    localLlmMaxContext: typeof cfg.localLlmMaxContext === "number" ? cfg.localLlmMaxContext : void 0,
+    localLlmMaxContext: parseOptionalIntegerAtLeast(cfg.localLlmMaxContext, 1024, "localLlmMaxContext"),
     // Observability (disabled by default to avoid log spam)
     slowLogEnabled: cfg.slowLogEnabled === true,
     slowLogThresholdMs: typeof cfg.slowLogThresholdMs === "number" ? cfg.slowLogThresholdMs : 3e4,
@@ -1996,7 +2023,7 @@ function parseConfig(raw) {
     enrichmentMaxCandidatesPerEntity: typeof cfg.enrichmentMaxCandidatesPerEntity === "number" ? Math.max(0, Math.floor(cfg.enrichmentMaxCandidatesPerEntity)) : 20,
     // Memory extensions discovery (#382)
     memoryExtensionsEnabled: cfg.memoryExtensionsEnabled !== false,
-    memoryExtensionsRoot: typeof cfg.memoryExtensionsRoot === "string" && cfg.memoryExtensionsRoot.trim().length > 0 ? cfg.memoryExtensionsRoot.trim() : ""
+    memoryExtensionsRoot: typeof cfg.memoryExtensionsRoot === "string" && cfg.memoryExtensionsRoot.trim().length > 0 ? expandTildePath(cfg.memoryExtensionsRoot.trim()) : ""
   };
 }
 function parseBriefingConfig(raw) {
@@ -2269,4 +2296,4 @@ export {
   VALID_MEMORY_CATEGORIES,
   parseConfig
 };
-//# sourceMappingURL=chunk-MZH6EHNR.js.map
+//# sourceMappingURL=chunk-7H6CFEBJ.js.map