@joshuaswarren/openclaw-engram 9.0.92 → 9.0.93

package/dist/calibration-TLGCHI7D.js

@@ -0,0 +1,236 @@
+// openclaw-engram: Local-first memory plugin
+import {
+  FallbackLlmClient
+} from "./chunk-PW5V7OJH.js";
+import {
+  listJsonFiles
+} from "./chunk-DEIBZP3O.js";
+import {
+  log
+} from "./chunk-SSIIJJKA.js";
+
+// src/calibration.ts
+import { createHash } from "crypto";
+import path from "path";
+import { mkdir, readFile, writeFile } from "fs/promises";
+function calibrationDir(memoryDir) {
+  return path.join(memoryDir, "state", "calibration");
+}
+function calibrationIndexPath(memoryDir) {
+  return path.join(calibrationDir(memoryDir), "calibration-index.json");
+}
+async function readCalibrationIndex(memoryDir) {
+  try {
+    const raw = JSON.parse(await readFile(calibrationIndexPath(memoryDir), "utf8"));
+    return {
+      rules: Array.isArray(raw.rules) ? raw.rules : [],
+      updatedAt: typeof raw.updatedAt === "string" ? raw.updatedAt : (/* @__PURE__ */ new Date()).toISOString(),
+      totalCorrectionsAnalyzed: typeof raw.totalCorrectionsAnalyzed === "number" ? raw.totalCorrectionsAnalyzed : 0
+    };
+  } catch {
+    return { rules: [], updatedAt: (/* @__PURE__ */ new Date()).toISOString(), totalCorrectionsAnalyzed: 0 };
+  }
+}
+async function writeCalibrationIndex(memoryDir, index) {
+  const dir = calibrationDir(memoryDir);
+  await mkdir(dir, { recursive: true });
+  index.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeFile(calibrationIndexPath(memoryDir), JSON.stringify(index, null, 2), "utf8");
+}
+async function readCorrections(memoryDir) {
+  const correctionsDir = path.join(memoryDir, "corrections");
+  const files = await listJsonFiles(correctionsDir).catch(() => {
+    return [];
+  });
+  const factsDir = path.join(memoryDir, "facts");
+  try {
+    const { readdir } = await import("fs/promises");
+    const dayDirs = (await readdir(factsDir)).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d));
+    for (const day of dayDirs) {
+      const dayPath = path.join(factsDir, day);
+      const dayFiles = (await readdir(dayPath)).filter((f) => f.startsWith("correction-") && f.endsWith(".md")).map((f) => path.join(dayPath, f));
+      files.push(...dayFiles);
+    }
+  } catch {
+  }
+  try {
+    const { readdir } = await import("fs/promises");
+    const corrFiles = (await readdir(correctionsDir)).filter((f) => f.endsWith(".md")).map((f) => path.join(correctionsDir, f));
+    files.push(...corrFiles);
+  } catch {
+  }
+  const corrections = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const filePath of files) {
+    try {
+      const raw = await readFile(filePath, "utf8");
+      const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+      if (!fmMatch) continue;
+      const content = fmMatch[2].trim();
+      if (!content || content.length < 10) continue;
+      const idMatch = fmMatch[1].match(/^id:\s*(.+)$/m);
+      const id = idMatch?.[1]?.trim() ?? path.basename(filePath, ".md");
+      if (seen.has(id)) continue;
+      seen.add(id);
+      const confMatch = fmMatch[1].match(/^confidence:\s*(.+)$/m);
+      const confidence = confMatch ? parseFloat(confMatch[1]) : 0.9;
+      const entityMatch = fmMatch[1].match(/^entityRef:\s*(.+)$/m);
+      const entityRefs = entityMatch ? [entityMatch[1].trim()] : [];
+      corrections.push({ id, content, created: "", confidence, entityRefs, tags: [] });
+    } catch {
+    }
+  }
+  return corrections;
+}
+var CLUSTER_PROMPT = `You are analyzing user corrections to an AI assistant. Each correction represents a moment where the assistant's prediction of what the user wanted was WRONG.
+
+Your job: Group these corrections into clusters where the SAME TYPE of misunderstanding is happening. Then for each cluster, synthesize a CalibrationRule.
+
+A CalibrationRule describes:
+- condition: When does this type of mistake happen?
+- modelTendency: What does the model tend to assume or do wrong?
+- userExpectation: What does the user actually want instead?
+- calibration: How should the model adjust its behavior?
+- ruleType: One of "model_tendency", "user_expectation", "scope_boundary", "verification_required"
+
+Focus on PATTERNS, not individual corrections. A cluster needs at least 2 corrections to be worth a rule.
+
+Output valid JSON only:
+{
+  "rules": [
+    {
+      "ruleType": "model_tendency",
+      "condition": "When discussing project scope or task boundaries",
+      "modelTendency": "The model tends to assume broader scope than the user intends",
+      "userExpectation": "The user prefers narrow, specific task definitions and wants to be asked before scope expansion",
+      "calibration": "When uncertain about scope, ask for clarification rather than assuming. Default to the narrower interpretation.",
+      "confidence": 0.85,
+      "evidenceIds": ["correction-id-1", "correction-id-2"]
+    }
+  ]
+}`;
+async function synthesizeCalibrationRules(corrections, llm, existingRules) {
+  if (corrections.length < 2) return [];
+  const correctionText = corrections.slice(0, 50).map((c, i) => `[${c.id}] ${c.content}`).join("\n\n");
+  const existingRulesText = existingRules.length > 0 ? `
+
+Existing calibration rules (avoid duplicating these):
+${existingRules.map((r) => `- ${r.condition}: ${r.calibration}`).join("\n")}` : "";
+  const response = await llm.chatCompletion(
+    [
+      { role: "system", content: CLUSTER_PROMPT },
+      { role: "user", content: `Here are ${corrections.length} corrections from this user:
+
+${correctionText}${existingRulesText}` }
+    ],
+    { temperature: 0.3, maxTokens: 3e3 }
+  );
+  if (!response?.content) return [];
+  try {
+    let jsonStr = response.content.trim();
+    const fenceMatch = jsonStr.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/);
+    if (fenceMatch) jsonStr = fenceMatch[1];
+    const parsed = JSON.parse(jsonStr);
+    if (!Array.isArray(parsed.rules)) return [];
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return parsed.rules.filter((r) => r.condition && r.calibration && r.modelTendency).map((r) => ({
+      id: `cal-${createHash("sha256").update(r.condition + r.calibration).digest("hex").slice(0, 12)}`,
+      ruleType: r.ruleType ?? "model_tendency",
+      condition: String(r.condition),
+      modelTendency: String(r.modelTendency),
+      userExpectation: String(r.userExpectation ?? ""),
+      calibration: String(r.calibration),
+      confidence: typeof r.confidence === "number" ? r.confidence : 0.7,
+      evidenceCount: Array.isArray(r.evidenceIds) ? r.evidenceIds.length : 1,
+      evidenceCorrectionIds: Array.isArray(r.evidenceIds) ? r.evidenceIds : [],
+      createdAt: now,
+      lastReinforcedAt: now
+    }));
+  } catch {
+    log.warn("[calibration] failed to parse LLM response");
+    return [];
+  }
+}
+function buildCalibrationRecallSection(rules, query, maxChars = 1200) {
+  if (rules.length === 0) return null;
+  const lines = [
+    "## Model Calibration (learned from past corrections)",
+    "",
+    "Adjustments for this specific user, learned from patterns in their corrections:",
+    ""
+  ];
+  let totalChars = lines.join("\n").length;
+  for (const rule of rules) {
+    const line = `- **${rule.condition}**: ${rule.modelTendency} \u2192 Instead: ${rule.calibration}`;
+    if (totalChars + line.length + 1 > maxChars) break;
+    lines.push(line);
+    totalChars += line.length + 1;
+  }
+  if (lines.length <= 4) return null;
+  lines.push("");
+  return lines.join("\n");
+}
+async function runCalibrationConsolidation(options) {
+  try {
+    const llm = new FallbackLlmClient(options.gatewayConfig);
+    if (!llm.isAvailable()) {
+      log.debug("[calibration] no LLM available \u2014 skipping consolidation");
+      return [];
+    }
+    const corrections = await readCorrections(options.memoryDir);
+    if (corrections.length < 3) {
+      log.debug(`[calibration] only ${corrections.length} corrections \u2014 need at least 3`);
+      return [];
+    }
+    const existingIndex = await readCalibrationIndex(options.memoryDir);
+    const newRules = await synthesizeCalibrationRules(corrections, llm, existingIndex.rules);
+    if (newRules.length === 0) {
+      log.debug("[calibration] no new calibration rules synthesized");
+      return existingIndex.rules;
+    }
+    const ruleMap = new Map(existingIndex.rules.map((r) => [r.id, r]));
+    for (const rule of newRules) {
+      if (ruleMap.has(rule.id)) {
+        const existing = ruleMap.get(rule.id);
+        existing.lastReinforcedAt = (/* @__PURE__ */ new Date()).toISOString();
+        existing.evidenceCount += rule.evidenceCount;
+        existing.confidence = Math.min(1, existing.confidence + 0.05);
+      } else {
+        ruleMap.set(rule.id, rule);
+      }
+    }
+    const allRules = [...ruleMap.values()];
+    await writeCalibrationIndex(options.memoryDir, {
+      rules: allRules,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      totalCorrectionsAnalyzed: corrections.length
+    });
+    log.debug(`[calibration] synthesized ${newRules.length} new rule(s), ${allRules.length} total`);
+    return allRules;
+  } catch (error) {
+    log.warn(`[calibration] consolidation failed (non-fatal): ${error instanceof Error ? error.message : String(error)}`);
+    return [];
+  }
+}
+async function runCalibrationIfEnabled(options) {
+  if (!options.calibrationEnabled) {
+    return [];
+  }
+  return runCalibrationConsolidation({
+    memoryDir: options.memoryDir,
+    gatewayConfig: options.gatewayConfig
+  });
+}
+async function getCalibrationRulesForRecall(memoryDir) {
+  const index = await readCalibrationIndex(memoryDir);
+  return index.rules;
+}
+export {
+  buildCalibrationRecallSection,
+  getCalibrationRulesForRecall,
+  readCalibrationIndex,
+  runCalibrationConsolidation,
+  runCalibrationIfEnabled,
+  synthesizeCalibrationRules
+};
+//# sourceMappingURL=calibration-TLGCHI7D.js.map

package/dist/calibration-TLGCHI7D.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/calibration.ts"],"sourcesContent":["/**\n * calibration.ts — Prediction-Error-Driven Model-User Calibration\n *\n * Analyzes patterns in user corrections to identify systematic miscalibration\n * between the model's predictions and the user's actual expectations.\n * During consolidation, replays chains of similar corrections through an LLM\n * to synthesize CalibrationRules that adjust model behavior for this specific user.\n *\n * Inspired by:\n * - Cerebellar motor calibration (prediction errors drive lasting adjustments)\n * - Temporal difference learning (dopamine signals prediction error)\n * - Tesla FSD shadow mode (divergence between prediction and reality = training signal)\n */\n\nimport { createHash } from \"node:crypto\";\nimport path from \"node:path\";\nimport { mkdir, readFile, writeFile } from \"node:fs/promises\";\nimport { FallbackLlmClient } from \"./fallback-llm.js\";\nimport type { GatewayConfig, MemoryFile } from \"./types.js\";\nimport { listJsonFiles, readJsonFile } from \"./json-store.js\";\nimport { isRecord } from \"./store-contract.js\";\nimport { log } from \"./logger.js\";\n\n// ─── Types ───────────────────────────────────────────────────────────────────\n\nexport interface CalibrationRule {\n  id: string;\n  ruleType: \"model_tendency\" | \"user_expectation\" | \"scope_boundary\" | \"verification_required\";\n  condition: string;\n  modelTendency: string;\n  userExpectation: string;\n  calibration: string;\n  confidence: number;\n  evidenceCount: number;\n  evidenceCorrectionIds: string[];\n  createdAt: string;\n  lastReinforcedAt: string;\n}\n\nexport interface CalibrationIndex {\n  rules: CalibrationRule[];\n  updatedAt: string;\n  totalCorrectionsAnalyzed: number;\n}\n\n// ─── Storage ─────────────────────────────────────────────────────────────────\n\nfunction calibrationDir(memoryDir: string): string {\n  return path.join(memoryDir, \"state\", \"calibration\");\n}\n\nfunction calibrationIndexPath(memoryDir: string): string {\n  return path.join(calibrationDir(memoryDir), \"calibration-index.json\");\n}\n\nexport async function readCalibrationIndex(memoryDir: string): Promise<CalibrationIndex> {\n  try {\n    const raw = JSON.parse(await readFile(calibrationIndexPath(memoryDir), \"utf8\"));\n    return {\n      rules: Array.isArray(raw.rules) ? raw.rules : [],\n      updatedAt: typeof raw.updatedAt === \"string\" ? raw.updatedAt : new Date().toISOString(),\n      totalCorrectionsAnalyzed: typeof raw.totalCorrectionsAnalyzed === \"number\" ? raw.totalCorrectionsAnalyzed : 0,\n    };\n  } catch {\n    return { rules: [], updatedAt: new Date().toISOString(), totalCorrectionsAnalyzed: 0 };\n  }\n}\n\nasync function writeCalibrationIndex(memoryDir: string, index: CalibrationIndex): Promise<void> {\n  const dir = calibrationDir(memoryDir);\n  await mkdir(dir, { recursive: true });\n  index.updatedAt = new Date().toISOString();\n  await writeFile(calibrationIndexPath(memoryDir), JSON.stringify(index, null, 2), \"utf8\");\n}\n\n// ─── Correction Reading ──────────────────────────────────────────────────────\n\ninterface CorrectionMemory {\n  id: string;\n  content: string;\n  created: string;\n  confidence: number;\n  entityRefs: string[];\n  tags: string[];\n}\n\nasync function readCorrections(memoryDir: string): Promise<CorrectionMemory[]> {\n  const correctionsDir = path.join(memoryDir, \"corrections\");\n  const files = await listJsonFiles(correctionsDir).catch(() => {\n    // Corrections might be in facts/ directories too\n    return [] as string[];\n  });\n\n  // Also scan facts directories for correction-category files\n  const factsDir = path.join(memoryDir, \"facts\");\n  try {\n    const { readdir } = await import(\"node:fs/promises\");\n    const dayDirs = (await readdir(factsDir)).filter((d: string) => /^\\d{4}-\\d{2}-\\d{2}$/.test(d));\n    for (const day of dayDirs) {\n      const dayPath = path.join(factsDir, day);\n      const dayFiles = (await readdir(dayPath))\n        .filter((f: string) => f.startsWith(\"correction-\") && f.endsWith(\".md\"))\n        .map((f: string) => path.join(dayPath, f));\n      files.push(...dayFiles);\n    }\n  } catch {\n    // facts dir might not exist\n  }\n\n  // Also check the dedicated corrections directory\n  try {\n    const { readdir } = await import(\"node:fs/promises\");\n    const corrFiles = (await readdir(correctionsDir))\n      .filter((f: string) => f.endsWith(\".md\"))\n      .map((f: string) => path.join(correctionsDir, f));\n    files.push(...corrFiles);\n  } catch {\n    // corrections dir might not exist\n  }\n\n  const corrections: CorrectionMemory[] = [];\n  const seen = new Set<string>();\n\n  for (const filePath of files) {\n    try {\n      const raw = await readFile(filePath, \"utf8\");\n\n      // Parse frontmatter\n      const fmMatch = raw.match(/^---\\n([\\s\\S]*?)\\n---\\n([\\s\\S]*)$/);\n      if (!fmMatch) continue;\n\n      const content = fmMatch[2].trim();\n      if (!content || content.length < 10) continue;\n\n      // Extract id from frontmatter\n      const idMatch = fmMatch[1].match(/^id:\\s*(.+)$/m);\n      const id = idMatch?.[1]?.trim() ?? path.basename(filePath, \".md\");\n\n      if (seen.has(id)) continue;\n      seen.add(id);\n\n      const confMatch = fmMatch[1].match(/^confidence:\\s*(.+)$/m);\n      const confidence = confMatch ? parseFloat(confMatch[1]) : 0.9;\n\n      const entityMatch = fmMatch[1].match(/^entityRef:\\s*(.+)$/m);\n      const entityRefs = entityMatch ? [entityMatch[1].trim()] : [];\n\n      corrections.push({ id, content, created: \"\", confidence, entityRefs, tags: [] });\n    } catch {\n      // skip unparseable files\n    }\n  }\n\n  return corrections;\n}\n\n// ─── LLM-Assisted Clustering and Replay ──────────────────────────────────────\n\nconst CLUSTER_PROMPT = `You are analyzing user corrections to an AI assistant. Each correction represents a moment where the assistant's prediction of what the user wanted was WRONG.\n\nYour job: Group these corrections into clusters where the SAME TYPE of misunderstanding is happening. Then for each cluster, synthesize a CalibrationRule.\n\nA CalibrationRule describes:\n- condition: When does this type of mistake happen?\n- modelTendency: What does the model tend to assume or do wrong?\n- userExpectation: What does the user actually want instead?\n- calibration: How should the model adjust its behavior?\n- ruleType: One of \"model_tendency\", \"user_expectation\", \"scope_boundary\", \"verification_required\"\n\nFocus on PATTERNS, not individual corrections. A cluster needs at least 2 corrections to be worth a rule.\n\nOutput valid JSON only:\n{\n  \"rules\": [\n    {\n      \"ruleType\": \"model_tendency\",\n      \"condition\": \"When discussing project scope or task boundaries\",\n      \"modelTendency\": \"The model tends to assume broader scope than the user intends\",\n      \"userExpectation\": \"The user prefers narrow, specific task definitions and wants to be asked before scope expansion\",\n      \"calibration\": \"When uncertain about scope, ask for clarification rather than assuming. Default to the narrower interpretation.\",\n      \"confidence\": 0.85,\n      \"evidenceIds\": [\"correction-id-1\", \"correction-id-2\"]\n    }\n  ]\n}`;\n\nexport async function synthesizeCalibrationRules(\n  corrections: CorrectionMemory[],\n  llm: FallbackLlmClient,\n  existingRules: CalibrationRule[],\n): Promise<CalibrationRule[]> {\n  if (corrections.length < 2) return [];\n\n  // Format corrections for the LLM\n  const correctionText = corrections\n    .slice(0, 50) // limit to avoid huge prompts\n    .map((c, i) => `[${c.id}] ${c.content}`)\n    .join(\"\\n\\n\");\n\n  const existingRulesText = existingRules.length > 0\n    ? `\\n\\nExisting calibration rules (avoid duplicating these):\\n${existingRules.map((r) => `- ${r.condition}: ${r.calibration}`).join(\"\\n\")}`\n    : \"\";\n\n  const response = await llm.chatCompletion(\n    [\n      { role: \"system\", content: CLUSTER_PROMPT },\n      { role: \"user\", content: `Here are ${corrections.length} corrections from this user:\\n\\n${correctionText}${existingRulesText}` },\n    ],\n    { temperature: 0.3, maxTokens: 3000 },\n  );\n\n  if (!response?.content) return [];\n\n  try {\n    let jsonStr = response.content.trim();\n    const fenceMatch = jsonStr.match(/```(?:json)?\\s*\\n?([\\s\\S]*?)\\n?\\s*```/);\n    if (fenceMatch) jsonStr = fenceMatch[1];\n\n    const parsed = JSON.parse(jsonStr);\n    if (!Array.isArray(parsed.rules)) return [];\n\n    const now = new Date().toISOString();\n    return parsed.rules\n      .filter((r: any) => r.condition && r.calibration && r.modelTendency)\n      .map((r: any) => ({\n        id: `cal-${createHash(\"sha256\").update(r.condition + r.calibration).digest(\"hex\").slice(0, 12)}`,\n        ruleType: r.ruleType ?? \"model_tendency\",\n        condition: String(r.condition),\n        modelTendency: String(r.modelTendency),\n        userExpectation: String(r.userExpectation ?? \"\"),\n        calibration: String(r.calibration),\n        confidence: typeof r.confidence === \"number\" ? r.confidence : 0.7,\n        evidenceCount: Array.isArray(r.evidenceIds) ? r.evidenceIds.length : 1,\n        evidenceCorrectionIds: Array.isArray(r.evidenceIds) ? r.evidenceIds : [],\n        createdAt: now,\n        lastReinforcedAt: now,\n      }));\n  } catch {\n    log.warn(\"[calibration] failed to parse LLM response\");\n    return [];\n  }\n}\n\n// ─── Recall Section ──────────────────────────────────────────────────────────\n\n/**\n * Build a recall section from calibration rules relevant to the current query.\n * Uses the LLM to select which rules apply to the current context.\n */\nexport function buildCalibrationRecallSection(\n  rules: CalibrationRule[],\n  query: string,\n  maxChars: number = 1200,\n): string | null {\n  if (rules.length === 0) return null;\n\n  // Simple relevance: include all rules (they're already filtered to this user)\n  // In production, could use embedding similarity to filter\n  const lines: string[] = [\n    \"## Model Calibration (learned from past corrections)\",\n    \"\",\n    \"Adjustments for this specific user, learned from patterns in their corrections:\",\n    \"\",\n  ];\n\n  let totalChars = lines.join(\"\\n\").length;\n\n  for (const rule of rules) {\n    const line = `- **${rule.condition}**: ${rule.modelTendency} → Instead: ${rule.calibration}`;\n    if (totalChars + line.length + 1 > maxChars) break;\n    lines.push(line);\n    totalChars += line.length + 1;\n  }\n\n  if (lines.length <= 4) return null;\n  lines.push(\"\");\n  return lines.join(\"\\n\");\n}\n\n// ─── Public API ──────────────────────────────────────────────────────────────\n\n/**\n * Run the full calibration pipeline:\n * 1. Read all corrections\n * 2. Send to LLM for clustering and rule synthesis\n * 3. Merge with existing rules\n * 4. Write updated index\n */\nexport async function runCalibrationConsolidation(options: {\n  memoryDir: string;\n  gatewayConfig?: GatewayConfig;\n}): Promise<CalibrationRule[]> {\n  try {\n    const llm = new FallbackLlmClient(options.gatewayConfig);\n    if (!llm.isAvailable()) {\n      log.debug(\"[calibration] no LLM available — skipping consolidation\");\n      return [];\n    }\n\n    const corrections = await readCorrections(options.memoryDir);\n    if (corrections.length < 3) {\n      log.debug(`[calibration] only ${corrections.length} corrections — need at least 3`);\n      return [];\n    }\n\n    const existingIndex = await readCalibrationIndex(options.memoryDir);\n\n    const newRules = await synthesizeCalibrationRules(corrections, llm, existingIndex.rules);\n    if (newRules.length === 0) {\n      log.debug(\"[calibration] no new calibration rules synthesized\");\n      return existingIndex.rules;\n    }\n\n    // Merge: keep existing rules, add new ones (deduplicate by id)\n    const ruleMap = new Map(existingIndex.rules.map((r) => [r.id, r]));\n    for (const rule of newRules) {\n      if (ruleMap.has(rule.id)) {\n        // Reinforce existing rule\n        const existing = ruleMap.get(rule.id)!;\n        existing.lastReinforcedAt = new Date().toISOString();\n        existing.evidenceCount += rule.evidenceCount;\n        existing.confidence = Math.min(1, existing.confidence + 0.05);\n      } else {\n        ruleMap.set(rule.id, rule);\n      }\n    }\n\n    const allRules = [...ruleMap.values()];\n    await writeCalibrationIndex(options.memoryDir, {\n      rules: allRules,\n      updatedAt: new Date().toISOString(),\n      totalCorrectionsAnalyzed: corrections.length,\n    });\n\n    log.debug(`[calibration] synthesized ${newRules.length} new rule(s), ${allRules.length} total`);\n    return allRules;\n  } catch (error) {\n    log.warn(`[calibration] consolidation failed (non-fatal): ${error instanceof Error ? error.message : String(error)}`);\n    return [];\n  }\n}\n\n/**\n * Standalone entry point for calibration consolidation that can be called\n * independently of weekly compounding. The compounding engine's\n * `synthesizeWeekly()` is one trigger, but orchestrators or periodic\n * maintenance jobs should call this directly so calibration is not gated\n * on weekly compounding being enabled.\n */\nexport async function runCalibrationIfEnabled(options: {\n  memoryDir: string;\n  calibrationEnabled: boolean;\n  gatewayConfig?: GatewayConfig;\n}): Promise<CalibrationRule[]> {\n  if (!options.calibrationEnabled) {\n    return [];\n  }\n  return runCalibrationConsolidation({\n    memoryDir: options.memoryDir,\n    gatewayConfig: options.gatewayConfig,\n  });\n}\n\n/**\n * Get calibration rules for recall injection.\n * Reads the pre-computed calibration index.\n */\nexport async function getCalibrationRulesForRecall(\n  memoryDir: string,\n): Promise<CalibrationRule[]> {\n  const index = await readCalibrationIndex(memoryDir);\n  return index.rules;\n}\n"],"mappings":"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","names":[]}

package/dist/causal-chain-OJCLNNEH.js

@@ -0,0 +1,23 @@
+// openclaw-engram: Local-first memory plugin
+import {
+  makeEdgeId,
+  readChainIndex,
+  resolveChainsDir,
+  scoreStitchCandidate,
+  stitchCausalChain,
+  validateCausalEdge,
+  writeChainIndex
+} from "./chunk-3GARBXWR.js";
+import "./chunk-AFMNQR7H.js";
+import "./chunk-DEIBZP3O.js";
+import "./chunk-SSIIJJKA.js";
+export {
+  makeEdgeId,
+  readChainIndex,
+  resolveChainsDir,
+  scoreStitchCandidate,
+  stitchCausalChain,
+  validateCausalEdge,
+  writeChainIndex
+};
+//# sourceMappingURL=causal-chain-OJCLNNEH.js.map

package/dist/causal-consolidation-LN3WQ6OV.js

@@ -0,0 +1,206 @@
+// openclaw-engram: Local-first memory plugin
+import {
+  readChainIndex,
+  resolveChainsDir
+} from "./chunk-3GARBXWR.js";
+import {
+  isRecord
+} from "./chunk-AFMNQR7H.js";
+import {
+  FallbackLlmClient
+} from "./chunk-PW5V7OJH.js";
+import {
+  listJsonFiles,
+  readJsonFile
+} from "./chunk-DEIBZP3O.js";
+import {
+  log
+} from "./chunk-SSIIJJKA.js";
+
+// src/causal-consolidation.ts
+import { createHash } from "crypto";
+import path from "path";
+async function readAllTrajectories(memoryDir, causalTrajectoryStoreDir) {
+  const root = causalTrajectoryStoreDir ? path.join(memoryDir, causalTrajectoryStoreDir) : path.join(memoryDir, "state", "causal-trajectories");
+  const trajectoriesDir = path.join(root, "trajectories");
+  const files = await listJsonFiles(trajectoriesDir).catch(() => []);
+  const results = [];
+  for (const filePath of files) {
+    try {
+      const raw = await readJsonFile(filePath);
+      if (isRecord(raw) && typeof raw.trajectoryId === "string") {
+        results.push(raw);
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+function formatCausalContext(trajectories, chainIndex, maxChars = 8e3) {
+  const bySession = /* @__PURE__ */ new Map();
+  for (const t of trajectories) {
+    const list = bySession.get(t.sessionKey) ?? [];
+    list.push(t);
+    bySession.set(t.sessionKey, list);
+  }
+  const lines = [];
+  lines.push(`## Causal Trajectories (${trajectories.length} across ${bySession.size} sessions)`);
+  lines.push("");
+  for (const [sessionKey, sessionTrajs] of bySession) {
+    lines.push(`### Session: ${sessionKey}`);
+    for (const t of sessionTrajs.slice(0, 5)) {
+      const outcome = t.outcomeKind === "success" ? "+" : t.outcomeKind === "failure" ? "-" : "~";
+      lines.push(`[${outcome}] Goal: ${t.goal}`);
+      lines.push(`    Action: ${t.actionSummary}`);
+      lines.push(`    Outcome: ${t.outcomeSummary}`);
+      if (t.followUpSummary) lines.push(`    Follow-up: ${t.followUpSummary}`);
+      if (t.entityRefs?.length) lines.push(`    Entities: ${t.entityRefs.join(", ")}`);
+    }
+    lines.push("");
+  }
+  const edgeCount = Object.keys(chainIndex.edges).length;
+  if (edgeCount > 0) {
+    lines.push(`## Cross-Session Causal Chains (${edgeCount} connections)`);
+    lines.push("");
+    const trajectoryMap = new Map(trajectories.map((t) => [t.trajectoryId, t]));
+    const shown = /* @__PURE__ */ new Set();
+    for (const [edgeId, edge] of Object.entries(chainIndex.edges)) {
+      if (shown.size >= 10) break;
+      const from = trajectoryMap.get(edge.fromTrajectoryId);
+      const to = trajectoryMap.get(edge.toTrajectoryId);
+      if (!from || !to) continue;
+      lines.push(`${edge.edgeType}: "${from.goal}" (${from.sessionKey}) \u2192 "${to.goal}" (${to.sessionKey})`);
+      shown.add(edgeId);
+    }
+    lines.push("");
+  }
+  const result = lines.join("\n");
+  return result.length > maxChars ? result.slice(0, maxChars) + "\n[truncated]" : result;
+}
+var CONSOLIDATION_PROMPT = `You are analyzing a user's causal trajectory history across multiple sessions. Trajectories record what the user tried to do (goal), what they did (action), and what happened (outcome).
+
+Your job is to identify:
+1. BEHAVIORAL RULES: Recurring patterns where the same approach consistently succeeds or fails. These should be actionable guidance for future sessions.
+2. PREFERENCES: What the user cares about, prefers, or consistently chooses \u2014 even if never explicitly stated. Infer preferences from what they repeatedly do, retry until successful, or always include in their workflow.
+
+IMPORTANT:
+- Look for CROSS-SESSION patterns \u2014 things that repeat across different sessions are more significant than within-session patterns.
+- A user who retries the same goal across sessions has a strong implicit preference for that outcome.
+- Consistent action choices reveal preferences even when the user never says "I prefer X."
+- Frame preferences as "The user would prefer responses that..." when applicable.
+
+Output valid JSON only:
+{
+  "rules": [
+    {"content": "actionable rule text", "category": "rule|principle", "confidence": 0.0-1.0, "evidence": ["trajectory IDs"]}
+  ],
+  "preferences": [
+    {"statement": "The user would prefer...", "confidence": 0.0-1.0, "evidence": ["trajectory IDs"]}
+  ]
+}
+
+If no clear patterns exist, return {"rules": [], "preferences": []}.`;
+async function consolidateWithLlm(context, llm) {
+  const response = await llm.chatCompletion(
+    [
+      { role: "system", content: CONSOLIDATION_PROMPT },
+      { role: "user", content: context }
+    ],
+    { temperature: 0.2, maxTokens: 2e3 }
+  );
+  if (!response?.content) {
+    return { rules: [], preferences: [] };
+  }
+  try {
+    let jsonStr = response.content.trim();
+    const fenceMatch = jsonStr.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/);
+    if (fenceMatch) jsonStr = fenceMatch[1];
+    const parsed = JSON.parse(jsonStr);
+    return {
+      rules: Array.isArray(parsed.rules) ? parsed.rules.filter(
+        (r) => typeof r.content === "string" && r.content.length > 5
+      ) : [],
+      preferences: Array.isArray(parsed.preferences) ? parsed.preferences.filter(
+        (p) => typeof p.statement === "string" && p.statement.length > 5
+      ) : []
+    };
+  } catch {
+    log.warn("[cmc] failed to parse LLM consolidation response");
+    return { rules: [], preferences: [] };
+  }
+}
+function stablePatternId(content) {
+  const digest = createHash("sha256").update(`causal-pattern\0${content}`).digest("hex").slice(0, 16);
+  return `causal-pattern:${digest}`;
+}
+function llmResultToCandidates(result) {
+  const candidates = [];
+  for (const rule of result.rules) {
+    const category = rule.category === "principle" ? "principle" : "rule";
+    candidates.push({
+      id: stablePatternId(rule.content),
+      sourceType: "causal-pattern",
+      subject: rule.content.slice(0, 80),
+      category,
+      content: rule.content,
+      score: Math.min(1, rule.confidence ?? 0.7),
+      rationale: "LLM-identified causal pattern from cross-session trajectory analysis",
+      outcome: null,
+      provenance: (rule.evidence ?? []).slice(0, 5),
+      agent: null,
+      workflow: null
+    });
+  }
+  return candidates;
+}
+async function deriveCausalPromotionCandidates(options) {
+  try {
+    const trajectories = await readAllTrajectories(options.memoryDir, options.causalTrajectoryStoreDir);
+    if (trajectories.length < options.config.minRecurrence) return [];
+    const chainsDir = resolveChainsDir(options.memoryDir, options.causalTrajectoryStoreDir);
+    const chainIndex = await readChainIndex(chainsDir);
+    const context = formatCausalContext(trajectories, chainIndex);
+    const llm = new FallbackLlmClient(options.gatewayConfig);
+    if (!llm.isAvailable()) {
+      log.debug("[cmc] no LLM available for consolidation \u2014 skipping");
+      return [];
+    }
+    const result = await consolidateWithLlm(context, llm);
+    const candidates = llmResultToCandidates(result);
+    log.debug(`[cmc] LLM consolidation produced ${candidates.length} rule(s) and ${result.preferences.length} preference(s)`);
+    return candidates;
+  } catch (error) {
+    log.warn(`[cmc] consolidation failed (non-fatal): ${error instanceof Error ? error.message : String(error)}`);
+    return [];
+  }
+}
+async function synthesizeCausalPreferencesViaLlm(options) {
+  try {
+    const trajectories = await readAllTrajectories(options.memoryDir, options.causalTrajectoryStoreDir);
+    if (trajectories.length < (options.minTrajectories ?? 2)) return null;
+    const chainsDir = resolveChainsDir(options.memoryDir, options.causalTrajectoryStoreDir);
+    const chainIndex = await readChainIndex(chainsDir);
+    const context = formatCausalContext(trajectories, chainIndex);
+    const llm = new FallbackLlmClient(options.gatewayConfig);
+    if (!llm.isAvailable()) return null;
+    const result = await consolidateWithLlm(context, llm);
+    if (result.preferences.length === 0 && result.rules.length === 0) return null;
+    const lines = ["## Behavioral Insights (from Causal Chain Analysis)", ""];
+    for (const pref of result.preferences) {
+      lines.push(`- ${pref.statement}`);
+    }
+    for (const rule of result.rules) {
+      lines.push(`- ${rule.content}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  } catch (error) {
+    log.warn(`[cmc] preference synthesis failed (non-fatal): ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+}
+export {
+  deriveCausalPromotionCandidates,
+  synthesizeCausalPreferencesViaLlm
+};
+//# sourceMappingURL=causal-consolidation-LN3WQ6OV.js.map

package/dist/causal-consolidation-LN3WQ6OV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/causal-consolidation.ts"],"sourcesContent":["/**\n * causal-consolidation.ts — CMC Phase 2: LLM-Assisted Causal Consolidation\n *\n * Uses an LLM to analyze causal trajectory patterns across sessions.\n * The LLM receives the causal chain graph as context — connected trajectories\n * from different sessions — and identifies recurring behavioral patterns,\n * preference signals, and actionable rules.\n *\n * This is the core CMC innovation: the LLM gets cross-session causal context\n * that no other memory system provides. It can see that a user investigated\n * a bug in session 1, attempted a fix in session 2, and succeeded in session 3 —\n * and synthesize a rule or preference from that chain.\n */\n\nimport { createHash } from \"node:crypto\";\nimport type { CausalTrajectoryRecord } from \"./causal-trajectory.js\";\nimport { readChainIndex, resolveChainsDir, type CausalChainIndex, type CausalEdge } from \"./causal-chain.js\";\nimport { listJsonFiles, readJsonFile } from \"./json-store.js\";\nimport { isRecord } from \"./store-contract.js\";\nimport { FallbackLlmClient } from \"./fallback-llm.js\";\nimport type { GatewayConfig } from \"./types.js\";\nimport path from \"node:path\";\nimport { log } from \"./logger.js\";\n\n// ─── Types ───────────────────────────────────────────────────────────────────\n\nexport interface CausalPatternCandidate {\n  id: string;\n  sourceType: \"causal-pattern\";\n  subject: string;\n  category: \"principle\" | \"rule\";\n  content: string;\n  score: number;\n  rationale: string;\n  outcome: null;\n  provenance: string[];\n  agent: string | null;\n  workflow: string | null;\n}\n\nexport interface ConsolidationConfig {\n  minRecurrence: number;\n  minSessions: number;\n  successThreshold: number;\n}\n\nexport interface LlmConsolidationResult {\n  rules: Array<{\n    content: string;\n    category: \"rule\" | \"principle\" | \"preference\";\n    confidence: number;\n    evidence: string[];\n  }>;\n  preferences: Array<{\n    statement: string;\n    confidence: number;\n    evidence: string[];\n  }>;\n}\n\n// ─── Trajectory Reading ──────────────────────────────────────────────────────\n\nasync function readAllTrajectories(\n  memoryDir: string,\n  causalTrajectoryStoreDir?: string,\n): Promise<CausalTrajectoryRecord[]> {\n  const root = causalTrajectoryStoreDir\n    ? path.join(memoryDir, causalTrajectoryStoreDir)\n    : path.join(memoryDir, \"state\", \"causal-trajectories\");\n  const trajectoriesDir = path.join(root, \"trajectories\");\n\n  const files = await listJsonFiles(trajectoriesDir).catch(() => [] as string[]);\n  const results: CausalTrajectoryRecord[] = [];\n\n  for (const filePath of files) {\n    try {\n      const raw = await readJsonFile(filePath);\n      if (isRecord(raw) && typeof raw.trajectoryId === \"string\") {\n        results.push(raw as unknown as CausalTrajectoryRecord);\n      }\n    } catch {\n      // skip invalid\n    }\n  }\n\n  return results;\n}\n\n// ─── Context Formatting ──────────────────────────────────────────────────────\n\n/**\n * Format trajectories and their causal connections as a readable context\n * for the LLM. Groups by session and shows chain connections.\n */\nfunction formatCausalContext(\n  trajectories: CausalTrajectoryRecord[],\n  chainIndex: CausalChainIndex,\n  maxChars: number = 8000,\n): string {\n  // Group trajectories by session\n  const bySession = new Map<string, CausalTrajectoryRecord[]>();\n  for (const t of trajectories) {\n    const list = bySession.get(t.sessionKey) ?? [];\n    list.push(t);\n    bySession.set(t.sessionKey, list);\n  }\n\n  const lines: string[] = [];\n  lines.push(`## Causal Trajectories (${trajectories.length} across ${bySession.size} sessions)`);\n  lines.push(\"\");\n\n  // Format each session's trajectories\n  for (const [sessionKey, sessionTrajs] of bySession) {\n    lines.push(`### Session: ${sessionKey}`);\n    for (const t of sessionTrajs.slice(0, 5)) {\n      const outcome = t.outcomeKind === \"success\" ? \"+\" : t.outcomeKind === \"failure\" ? \"-\" : \"~\";\n      lines.push(`[${outcome}] Goal: ${t.goal}`);\n      lines.push(`    Action: ${t.actionSummary}`);\n      lines.push(`    Outcome: ${t.outcomeSummary}`);\n      if (t.followUpSummary) lines.push(`    Follow-up: ${t.followUpSummary}`);\n      if (t.entityRefs?.length) lines.push(`    Entities: ${t.entityRefs.join(\", \")}`);\n    }\n    lines.push(\"\");\n  }\n\n  // Format causal chain connections\n  const edgeCount = Object.keys(chainIndex.edges).length;\n  if (edgeCount > 0) {\n    lines.push(`## Cross-Session Causal Chains (${edgeCount} connections)`);\n    lines.push(\"\");\n\n    const trajectoryMap = new Map(trajectories.map((t) => [t.trajectoryId, t]));\n    const shown = new Set<string>();\n\n    for (const [edgeId, edge] of Object.entries(chainIndex.edges)) {\n      if (shown.size >= 10) break; // limit output size\n      const from = trajectoryMap.get(edge.fromTrajectoryId);\n      const to = trajectoryMap.get(edge.toTrajectoryId);\n      if (!from || !to) continue;\n\n      lines.push(`${edge.edgeType}: \"${from.goal}\" (${from.sessionKey}) → \"${to.goal}\" (${to.sessionKey})`);\n      shown.add(edgeId);\n    }\n    lines.push(\"\");\n  }\n\n  const result = lines.join(\"\\n\");\n  return result.length > maxChars ? result.slice(0, maxChars) + \"\\n[truncated]\" : result;\n}\n\n// ─── LLM Consolidation ──────────────────────────────────────────────────────\n\nconst CONSOLIDATION_PROMPT = `You are analyzing a user's causal trajectory history across multiple sessions. Trajectories record what the user tried to do (goal), what they did (action), and what happened (outcome).\n\nYour job is to identify:\n1. BEHAVIORAL RULES: Recurring patterns where the same approach consistently succeeds or fails. These should be actionable guidance for future sessions.\n2. PREFERENCES: What the user cares about, prefers, or consistently chooses — even if never explicitly stated. Infer preferences from what they repeatedly do, retry until successful, or always include in their workflow.\n\nIMPORTANT:\n- Look for CROSS-SESSION patterns — things that repeat across different sessions are more significant than within-session patterns.\n- A user who retries the same goal across sessions has a strong implicit preference for that outcome.\n- Consistent action choices reveal preferences even when the user never says \"I prefer X.\"\n- Frame preferences as \"The user would prefer responses that...\" when applicable.\n\nOutput valid JSON only:\n{\n  \"rules\": [\n    {\"content\": \"actionable rule text\", \"category\": \"rule|principle\", \"confidence\": 0.0-1.0, \"evidence\": [\"trajectory IDs\"]}\n  ],\n  \"preferences\": [\n    {\"statement\": \"The user would prefer...\", \"confidence\": 0.0-1.0, \"evidence\": [\"trajectory IDs\"]}\n  ]\n}\n\nIf no clear patterns exist, return {\"rules\": [], \"preferences\": []}.`;\n\nasync function consolidateWithLlm(\n  context: string,\n  llm: FallbackLlmClient,\n): Promise<LlmConsolidationResult> {\n  const response = await llm.chatCompletion(\n    [\n      { role: \"system\", content: CONSOLIDATION_PROMPT },\n      { role: \"user\", content: context },\n    ],\n    { temperature: 0.2, maxTokens: 2000 },\n  );\n\n  if (!response?.content) {\n    return { rules: [], preferences: [] };\n  }\n\n  try {\n    // Extract JSON from response (may have markdown code fences)\n    let jsonStr = response.content.trim();\n    const fenceMatch = jsonStr.match(/```(?:json)?\\s*\\n?([\\s\\S]*?)\\n?\\s*```/);\n    if (fenceMatch) jsonStr = fenceMatch[1];\n\n    const parsed = JSON.parse(jsonStr);\n    return {\n      rules: Array.isArray(parsed.rules) ? parsed.rules.filter(\n        (r: any) => typeof r.content === \"string\" && r.content.length > 5,\n      ) : [],\n      preferences: Array.isArray(parsed.preferences) ? parsed.preferences.filter(\n        (p: any) => typeof p.statement === \"string\" && p.statement.length > 5,\n      ) : [],\n    };\n  } catch {\n    log.warn(\"[cmc] failed to parse LLM consolidation response\");\n    return { rules: [], preferences: [] };\n  }\n}\n\n// ─── Candidate Generation ────────────────────────────────────────────────────\n\nfunction stablePatternId(content: string): string {\n  const digest = createHash(\"sha256\")\n    .update(`causal-pattern\\0${content}`)\n    .digest(\"hex\")\n    .slice(0, 16);\n  return `causal-pattern:${digest}`;\n}\n\nfunction llmResultToCandidates(result: LlmConsolidationResult): CausalPatternCandidate[] {\n  const candidates: CausalPatternCandidate[] = [];\n\n  for (const rule of result.rules) {\n    const category = rule.category === \"principle\" ? \"principle\" : \"rule\";\n    candidates.push({\n      id: stablePatternId(rule.content),\n      sourceType: \"causal-pattern\",\n      subject: rule.content.slice(0, 80),\n      category,\n      content: rule.content,\n      score: Math.min(1, rule.confidence ?? 0.7),\n      rationale: \"LLM-identified causal pattern from cross-session trajectory analysis\",\n      outcome: null,\n      provenance: (rule.evidence ?? []).slice(0, 5),\n      agent: null,\n      workflow: null,\n    });\n  }\n\n  return candidates;\n}\n\n// ─── Public API ──────────────────────────────────────────────────────────────\n\n/**\n * Run LLM-assisted consolidation: read trajectories, format causal context,\n * ask LLM to identify patterns and preferences.\n */\nexport async function deriveCausalPromotionCandidates(options: {\n  memoryDir: string;\n  causalTrajectoryStoreDir?: string;\n  config: ConsolidationConfig;\n  gatewayConfig?: GatewayConfig;\n}): Promise<CausalPatternCandidate[]> {\n  try {\n    const trajectories = await readAllTrajectories(options.memoryDir, options.causalTrajectoryStoreDir);\n    if (trajectories.length < options.config.minRecurrence) return [];\n\n    const chainsDir = resolveChainsDir(options.memoryDir, options.causalTrajectoryStoreDir);\n    const chainIndex = await readChainIndex(chainsDir);\n\n    // Format the causal context for the LLM\n    const context = formatCausalContext(trajectories, chainIndex);\n\n    // If no LLM available, fall back to empty (no deterministic fallback)\n    const llm = new FallbackLlmClient(options.gatewayConfig);\n    if (!llm.isAvailable()) {\n      log.debug(\"[cmc] no LLM available for consolidation — skipping\");\n      return [];\n    }\n\n    // Call LLM for pattern analysis\n    const result = await consolidateWithLlm(context, llm);\n    const candidates = llmResultToCandidates(result);\n\n    log.debug(`[cmc] LLM consolidation produced ${candidates.length} rule(s) and ${result.preferences.length} preference(s)`);\n    return candidates;\n  } catch (error) {\n    log.warn(`[cmc] consolidation failed (non-fatal): ${error instanceof Error ? error.message : String(error)}`);\n    return [];\n  }\n}\n\n/**\n * Get LLM-synthesized preferences from causal trajectory analysis.\n * Returns formatted preference statements for recall injection.\n */\nexport async function synthesizeCausalPreferencesViaLlm(options: {\n  memoryDir: string;\n  causalTrajectoryStoreDir?: string;\n  gatewayConfig?: GatewayConfig;\n  minTrajectories?: number;\n}): Promise<string | null> {\n  try {\n    const trajectories = await readAllTrajectories(options.memoryDir, options.causalTrajectoryStoreDir);\n    if (trajectories.length < (options.minTrajectories ?? 2)) return null;\n\n    const chainsDir = resolveChainsDir(options.memoryDir, options.causalTrajectoryStoreDir);\n    const chainIndex = await readChainIndex(chainsDir);\n    const context = formatCausalContext(trajectories, chainIndex);\n\n    const llm = new FallbackLlmClient(options.gatewayConfig);\n    if (!llm.isAvailable()) return null;\n\n    const result = await consolidateWithLlm(context, llm);\n    if (result.preferences.length === 0 && result.rules.length === 0) return null;\n\n    const lines: string[] = [\"## Behavioral Insights (from Causal Chain Analysis)\", \"\"];\n\n    for (const pref of result.preferences) {\n      lines.push(`- ${pref.statement}`);\n    }\n\n    for (const rule of result.rules) {\n      lines.push(`- ${rule.content}`);\n    }\n\n    lines.push(\"\");\n    return lines.join(\"\\n\");\n  } catch (error) {\n    log.warn(`[cmc] preference synthesis failed (non-fatal): ${error instanceof Error ? error.message : String(error)}`);\n    return null;\n  }\n}\n"],"mappings":"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","names":[]}