@remnic/core 1.0.0

package/dist/causal-trajectory-graph.js

@@ -0,0 +1,59 @@
+import {
+  appendEdge
+} from "./chunk-SCHEKPYH.js";
+
+// src/causal-trajectory-graph.ts
+function causalTrajectoryGraphNodeId(trajectoryId, stage) {
+  return `causal-trajectory/${trajectoryId}#${stage}`;
+}
+function buildCausalTrajectoryGraphEdges(record) {
+  const edges = [
+    {
+      from: causalTrajectoryGraphNodeId(record.trajectoryId, "goal"),
+      to: causalTrajectoryGraphNodeId(record.trajectoryId, "action"),
+      type: "causal",
+      weight: 1,
+      label: "goal_to_action",
+      ts: record.recordedAt
+    },
+    {
+      from: causalTrajectoryGraphNodeId(record.trajectoryId, "action"),
+      to: causalTrajectoryGraphNodeId(record.trajectoryId, "observation"),
+      type: "causal",
+      weight: 1,
+      label: "action_to_observation",
+      ts: record.recordedAt
+    },
+    {
+      from: causalTrajectoryGraphNodeId(record.trajectoryId, "observation"),
+      to: causalTrajectoryGraphNodeId(record.trajectoryId, "outcome"),
+      type: "causal",
+      weight: 1,
+      label: `observation_to_outcome:${record.outcomeKind}`,
+      ts: record.recordedAt
+    }
+  ];
+  if (record.followUpSummary) {
+    edges.push({
+      from: causalTrajectoryGraphNodeId(record.trajectoryId, "outcome"),
+      to: causalTrajectoryGraphNodeId(record.trajectoryId, "follow_up"),
+      type: "causal",
+      weight: 1,
+      label: "outcome_to_follow_up",
+      ts: record.recordedAt
+    });
+  }
+  return edges;
+}
+async function appendCausalTrajectoryGraphEdges(options) {
+  const edges = buildCausalTrajectoryGraphEdges(options.record);
+  for (const edge of edges) {
+    await appendEdge(options.memoryDir, edge);
+  }
+}
+export {
+  appendCausalTrajectoryGraphEdges,
+  buildCausalTrajectoryGraphEdges,
+  causalTrajectoryGraphNodeId
+};
+//# sourceMappingURL=causal-trajectory-graph.js.map

package/dist/causal-trajectory-graph.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/causal-trajectory-graph.ts"],"sourcesContent":["import { appendEdge, type GraphEdge } from \"./graph.js\";\nimport type { CausalTrajectoryRecord } from \"./causal-trajectory.js\";\n\nexport type CausalTrajectoryGraphStage = \"goal\" | \"action\" | \"observation\" | \"outcome\" | \"follow_up\";\n\nexport function causalTrajectoryGraphNodeId(trajectoryId: string, stage: CausalTrajectoryGraphStage): string {\n  return `causal-trajectory/${trajectoryId}#${stage}`;\n}\n\nexport function buildCausalTrajectoryGraphEdges(record: CausalTrajectoryRecord): GraphEdge[] {\n  const edges: GraphEdge[] = [\n    {\n      from: causalTrajectoryGraphNodeId(record.trajectoryId, \"goal\"),\n      to: causalTrajectoryGraphNodeId(record.trajectoryId, \"action\"),\n      type: \"causal\",\n      weight: 1.0,\n      label: \"goal_to_action\",\n      ts: record.recordedAt,\n    },\n    {\n      from: causalTrajectoryGraphNodeId(record.trajectoryId, \"action\"),\n      to: causalTrajectoryGraphNodeId(record.trajectoryId, \"observation\"),\n      type: \"causal\",\n      weight: 1.0,\n      label: \"action_to_observation\",\n      ts: record.recordedAt,\n    },\n    {\n      from: causalTrajectoryGraphNodeId(record.trajectoryId, \"observation\"),\n      to: causalTrajectoryGraphNodeId(record.trajectoryId, \"outcome\"),\n      type: \"causal\",\n      weight: 1.0,\n      label: `observation_to_outcome:${record.outcomeKind}`,\n      ts: record.recordedAt,\n    },\n  ];\n\n  if (record.followUpSummary) {\n    edges.push({\n      from: causalTrajectoryGraphNodeId(record.trajectoryId, \"outcome\"),\n      to: causalTrajectoryGraphNodeId(record.trajectoryId, \"follow_up\"),\n      type: \"causal\",\n      weight: 1.0,\n      label: \"outcome_to_follow_up\",\n      ts: record.recordedAt,\n    });\n  }\n\n  return edges;\n}\n\nexport async function appendCausalTrajectoryGraphEdges(options: {\n  memoryDir: string;\n  record: CausalTrajectoryRecord;\n}): Promise<void> {\n  const edges = buildCausalTrajectoryGraphEdges(options.record);\n  for (const edge of edges) {\n    await appendEdge(options.memoryDir, edge);\n  }\n}\n"],"mappings":";;;;;AAKO,SAAS,4BAA4B,cAAsB,OAA2C;AAC3G,SAAO,qBAAqB,YAAY,IAAI,KAAK;AACnD;AAEO,SAAS,gCAAgC,QAA6C;AAC3F,QAAM,QAAqB;AAAA,IACzB;AAAA,MACE,MAAM,4BAA4B,OAAO,cAAc,MAAM;AAAA,MAC7D,IAAI,4BAA4B,OAAO,cAAc,QAAQ;AAAA,MAC7D,MAAM;AAAA,MACN,QAAQ;AAAA,MACR,OAAO;AAAA,MACP,IAAI,OAAO;AAAA,IACb;AAAA,IACA;AAAA,MACE,MAAM,4BAA4B,OAAO,cAAc,QAAQ;AAAA,MAC/D,IAAI,4BAA4B,OAAO,cAAc,aAAa;AAAA,MAClE,MAAM;AAAA,MACN,QAAQ;AAAA,MACR,OAAO;AAAA,MACP,IAAI,OAAO;AAAA,IACb;AAAA,IACA;AAAA,MACE,MAAM,4BAA4B,OAAO,cAAc,aAAa;AAAA,MACpE,IAAI,4BAA4B,OAAO,cAAc,SAAS;AAAA,MAC9D,MAAM;AAAA,MACN,QAAQ;AAAA,MACR,OAAO,0BAA0B,OAAO,WAAW;AAAA,MACnD,IAAI,OAAO;AAAA,IACb;AAAA,EACF;AAEA,MAAI,OAAO,iBAAiB;AAC1B,UAAM,KAAK;AAAA,MACT,MAAM,4BAA4B,OAAO,cAAc,SAAS;AAAA,MAChE,IAAI,4BAA4B,OAAO,cAAc,WAAW;AAAA,MAChE,MAAM;AAAA,MACN,QAAQ;AAAA,MACR,OAAO;AAAA,MACP,IAAI,OAAO;AAAA,IACb,CAAC;AAAA,EACH;AAEA,SAAO;AACT;AAEA,eAAsB,iCAAiC,SAGrC;AAChB,QAAM,QAAQ,gCAAgC,QAAQ,MAAM;AAC5D,aAAW,QAAQ,OAAO;AACxB,UAAM,WAAW,QAAQ,WAAW,IAAI;AAAA,EAC1C;AACF;","names":[]}

package/dist/causal-trajectory.d.ts

@@ -0,0 +1,68 @@
+import { ObjectiveStateOutcome } from './objective-state.js';
+
+interface CausalTrajectoryRecord {
+    schemaVersion: 1;
+    trajectoryId: string;
+    recordedAt: string;
+    sessionKey: string;
+    goal: string;
+    actionSummary: string;
+    observationSummary: string;
+    outcomeKind: ObjectiveStateOutcome;
+    outcomeSummary: string;
+    followUpSummary?: string;
+    objectiveStateSnapshotRefs?: string[];
+    entityRefs?: string[];
+    tags?: string[];
+    metadata?: Record<string, string>;
+}
+interface CausalTrajectoryStoreStatus {
+    enabled: boolean;
+    rootDir: string;
+    trajectoriesDir: string;
+    trajectories: {
+        total: number;
+        valid: number;
+        invalid: number;
+        byOutcome: Partial<Record<ObjectiveStateOutcome, number>>;
+        latestTrajectoryId?: string;
+        latestRecordedAt?: string;
+        latestSessionKey?: string;
+    };
+    latestTrajectory?: CausalTrajectoryRecord;
+    invalidTrajectories: Array<{
+        path: string;
+        error: string;
+    }>;
+}
+interface CausalTrajectorySearchResult {
+    record: CausalTrajectoryRecord;
+    score: number;
+    matchedFields: string[];
+}
+declare function resolveCausalTrajectoryStoreDir(memoryDir: string, overrideDir?: string): string;
+declare function validateCausalTrajectoryRecord(raw: unknown): CausalTrajectoryRecord;
+declare function recordCausalTrajectory(options: {
+    memoryDir: string;
+    causalTrajectoryStoreDir?: string;
+    actionGraphRecallEnabled?: boolean;
+    cmcEnabled?: boolean;
+    cmcStitchLookbackDays?: number;
+    cmcStitchMinScore?: number;
+    cmcStitchMaxEdgesPerTrajectory?: number;
+    record: CausalTrajectoryRecord;
+}): Promise<string>;
+declare function getCausalTrajectoryStoreStatus(options: {
+    memoryDir: string;
+    causalTrajectoryStoreDir?: string;
+    enabled: boolean;
+}): Promise<CausalTrajectoryStoreStatus>;
+declare function searchCausalTrajectories(options: {
+    memoryDir: string;
+    causalTrajectoryStoreDir?: string;
+    query: string;
+    maxResults: number;
+    sessionKey?: string;
+}): Promise<CausalTrajectorySearchResult[]>;
+
+export { type CausalTrajectoryRecord, type CausalTrajectorySearchResult, type CausalTrajectoryStoreStatus, getCausalTrajectoryStoreStatus, recordCausalTrajectory, resolveCausalTrajectoryStoreDir, searchCausalTrajectories, validateCausalTrajectoryRecord };

package/dist/causal-trajectory.js

@@ -0,0 +1,18 @@
+import {
+  getCausalTrajectoryStoreStatus,
+  recordCausalTrajectory,
+  resolveCausalTrajectoryStoreDir,
+  searchCausalTrajectories,
+  validateCausalTrajectoryRecord
+} from "./chunk-ORZMT74A.js";
+import "./chunk-DT5TVLJE.js";
+import "./chunk-DGXUHMOV.js";
+import "./chunk-LPSF4OQH.js";
+export {
+  getCausalTrajectoryStoreStatus,
+  recordCausalTrajectory,
+  resolveCausalTrajectoryStoreDir,
+  searchCausalTrajectories,
+  validateCausalTrajectoryRecord
+};
+//# sourceMappingURL=causal-trajectory.js.map

package/dist/causal-trajectory.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-2CJCWDMR.js

@@ -0,0 +1,87 @@
+import {
+  countRecallTokenOverlap,
+  normalizeRecallTokens
+} from "./chunk-DT5TVLJE.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();
+}
+
+export {
+  findSimilarClusters,
+  buildConsolidationPrompt,
+  parseConsolidationResponse
+};
+//# sourceMappingURL=chunk-2CJCWDMR.js.map

package/dist/chunk-2CJCWDMR.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 { log } from \"./logger.js\";\nimport type { MemoryFile } from \"./types.js\";\nimport { normalizeRecallTokens, countRecallTokenOverlap } from \"./recall-tokenization.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"],"mappings":";;;;;;AA8BO,SAAS,oBACd,UACA,QAMwB;AACxB,QAAM,WAAW,IAAI,IAAI,OAAO,iBAAiB;AAGjD,QAAM,aAAa,oBAAI,IAA0B;AACjD,aAAW,KAAK,UAAU;AACxB,UAAM,MAAM,EAAE,YAAY;AAC1B,QAAI,SAAS,IAAI,GAAG,EAAG;AACvB,QAAI,EAAE,YAAY,UAAU,EAAE,YAAY,WAAW,SAAU;AAC/D,UAAM,OAAO,WAAW,IAAI,GAAG,KAAK,CAAC;AACrC,SAAK,KAAK,CAAC;AACX,eAAW,IAAI,KAAK,IAAI;AAAA,EAC1B;AAEA,QAAM,WAAmC,CAAC;AAC1C,MAAI,kBAAkB;AAEtB,aAAW,CAAC,UAAU,IAAI,KAAK,YAAY;AACzC,QAAI,mBAAmB,OAAO,UAAW;AAGzC,UAAM,YAAY,KAAK,IAAI,CAAC,OAAO;AAAA,MACjC,QAAQ;AAAA,MACR,QAAQ,IAAI,IAAI,sBAAsB,EAAE,SAAS,CAAC,CAAC,CAAC;AAAA,IACtD,EAAE;AAGF,UAAM,YAAY,oBAAI,IAAY;AAElC,aAAS,IAAI,GAAG,IAAI,UAAU,UAAU,kBAAkB,OAAO,WAAW,KAAK;AAC/E,UAAI,UAAU,IAAI,UAAU,CAAC,EAAE,OAAO,YAAY,EAAE,EAAG;AAEvD,YAAM,UAAwB,CAAC,UAAU,CAAC,EAAE,MAAM;AAClD,UAAI,eAAe;AACnB,UAAI,cAAc;AAElB,eAAS,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;AAC7C,YAAI,UAAU,IAAI,UAAU,CAAC,EAAE,OAAO,YAAY,EAAE,EAAG;AAEvD,cAAM,UAAU,UAAU,CAAC,EAAE;AAC7B,cAAM,UAAU,UAAU,CAAC,EAAE;AAC7B,YAAI,QAAQ,SAAS,KAAK,QAAQ,SAAS,EAAG;AAG9C,cAAM,UAAU,wBAAwB,SAAS,CAAC,GAAG,OAAO,EAAE,KAAK,GAAG,CAAC;AACvE,cAAM,YAAY,KAAK,IAAI,QAAQ,MAAM,QAAQ,IAAI;AACrD,cAAM,QAAQ,YAAY,IAAI,UAAU,YAAY;AAEpD,YAAI,SAAS,OAAO,WAAW;AAC7B,kBAAQ,KAAK,UAAU,CAAC,EAAE,MAAM;AAChC,0BAAgB;AAChB;AAEA,cAAI,kBAAkB,QAAQ,UAAU,OAAO,UAAW;AAAA,QAC5D;AAAA,MACF;AAEA,UAAI,QAAQ,UAAU,OAAO,gBAAgB;AAC3C,mBAAW,KAAK,QAAS,WAAU,IAAI,EAAE,YAAY,EAAE;AACvD,iBAAS,KAAK;AAAA,UACZ;AAAA,UACA,UAAU;AAAA,UACV,cAAc,cAAc,IAAI,eAAe,cAAc;AAAA,QAC/D,CAAC;AACD,2BAAmB,QAAQ;AAAA,MAC7B;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AAKO,SAAS,yBAAyB,SAAuC;AAC9E,QAAM,cAAc,QAAQ,SACzB;AAAA,IACC,CAAC,GAAG,MACF,UAAU,IAAI,CAAC,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,YAAY,OAAO;AAAA,EAAO,EAAE,OAAO;AAAA,EAC1F,EACC,KAAK,MAAM;AAEd,SAAO,wDAAwD,QAAQ,SAAS,MAAM,qBAAqB,QAAQ,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAS3H,WAAW;AAAA;AAAA;AAGb;AAKO,SAAS,2BAA2B,UAA0B;AACnE,SAAO,SAAS,KAAK;AACvB;","names":[]}

package/dist/chunk-2NMMFZ5T.js

@@ -0,0 +1,216 @@
+// src/compression-optimizer.ts
+var MAX_DELTA = 0.15;
+var SPARSE_SAMPLE = 5;
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function parseRecallQuality(reason) {
+  if (!reason) return "unknown";
+  const text = reason.toLowerCase();
+  if (/(recall[_\s-]?good|quality[:=]\s*(good|high)|improv(ed|e)|resolved)/i.test(text)) {
+    return "good";
+  }
+  if (/(recall[_\s-]?poor|quality[:=]\s*(poor|low)|degrad(ed|e)|miss(ed|ing)|irrelevant)/i.test(text)) {
+    return "poor";
+  }
+  return "unknown";
+}
+function nextGuidelineVersion(previousState) {
+  if (!previousState) return 1;
+  return Math.max(1, previousState.guidelineVersion + 1);
+}
+function nextOptimizerVersion(previousState) {
+  if (!previousState) return 1;
+  return Math.max(1, previousState.version + 1);
+}
+function roundDelta(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+function confidenceForDelta(delta) {
+  const magnitude = Math.abs(delta);
+  return magnitude >= 0.09 ? "high" : magnitude >= 0.04 ? "medium" : "low";
+}
+function directionForDelta(delta) {
+  return delta > 0 ? "increase" : delta < 0 ? "decrease" : "hold";
+}
+function computeCompressionGuidelineCandidate(events, options = {}) {
+  const generatedAt = options.generatedAtIso ?? (/* @__PURE__ */ new Date()).toISOString();
+  const previousState = options.previousState ?? null;
+  const effectiveEvents = events.filter((event) => event.dryRun !== true);
+  const totalCounts = {
+    total: effectiveEvents.length,
+    applied: 0,
+    skipped: 0,
+    failed: 0
+  };
+  const actionMap = /* @__PURE__ */ new Map();
+  let windowFrom = effectiveEvents[0]?.timestamp ?? generatedAt;
+  let windowTo = effectiveEvents[0]?.timestamp ?? generatedAt;
+  for (const event of effectiveEvents) {
+    if (event.timestamp < windowFrom) windowFrom = event.timestamp;
+    if (event.timestamp > windowTo) windowTo = event.timestamp;
+    totalCounts[event.outcome] += 1;
+    let summary = actionMap.get(event.action);
+    if (!summary) {
+      summary = {
+        action: event.action,
+        total: 0,
+        outcomes: { applied: 0, skipped: 0, failed: 0 },
+        quality: { good: 0, poor: 0, unknown: 0 }
+      };
+      actionMap.set(event.action, summary);
+    }
+    summary.total += 1;
+    summary.outcomes[event.outcome] += 1;
+    const quality = parseRecallQuality(event.reason);
+    summary.quality[quality] += 1;
+  }
+  const actionSummaries = [...actionMap.values()].sort((a, b) => {
+    if (b.total !== a.total) return b.total - a.total;
+    return a.action.localeCompare(b.action);
+  });
+  const ruleUpdates = actionSummaries.map((summary) => {
+    const notes = [];
+    if (summary.total < SPARSE_SAMPLE) {
+      notes.push("Sparse sample size; holding baseline policy.");
+      return {
+        action: summary.action,
+        delta: 0,
+        direction: "hold",
+        confidence: "low",
+        notes
+      };
+    }
+    const successRate = summary.outcomes.applied / summary.total;
+    const failureRate = summary.outcomes.failed / summary.total;
+    const qualitySeen = summary.quality.good + summary.quality.poor;
+    const qualitySignal = qualitySeen > 0 ? (summary.quality.good - summary.quality.poor) / qualitySeen : 0;
+    const rawDelta = clamp((successRate - failureRate) * 0.12 + qualitySignal * 0.06, -MAX_DELTA, MAX_DELTA);
+    const delta = roundDelta(rawDelta);
+    const direction = directionForDelta(delta);
+    if (direction === "decrease" && summary.outcomes.failed > summary.outcomes.applied) {
+      notes.push("Failures exceed applied outcomes; conservative down-adjustment.");
+    } else if (direction === "increase" && summary.quality.good > summary.quality.poor) {
+      notes.push("Good recall quality markers support this action.");
+    } else if (direction === "decrease" && summary.quality.poor > summary.quality.good) {
+      notes.push("Poor recall quality markers exceed good markers.");
+    } else {
+      notes.push("Outcomes are stable; keep bounded adjustments.");
+    }
+    const confidence = confidenceForDelta(delta);
+    return {
+      action: summary.action,
+      delta,
+      direction,
+      confidence,
+      notes
+    };
+  });
+  return {
+    generatedAt,
+    sourceWindow: {
+      from: effectiveEvents.length > 0 ? windowFrom : generatedAt,
+      to: effectiveEvents.length > 0 ? windowTo : generatedAt
+    },
+    eventCounts: totalCounts,
+    actionSummaries,
+    ruleUpdates,
+    guidelineVersion: nextGuidelineVersion(previousState),
+    optimizerVersion: nextOptimizerVersion(previousState)
+  };
+}
+async function refineCompressionGuidelineCandidateSemantically(baseline, options) {
+  if (!options.enabled) return baseline;
+  if (typeof options.runRefinement !== "function") return baseline;
+  const timeoutMs = Math.max(1, Math.floor(options.timeoutMs));
+  let timeoutId = null;
+  const timeout = new Promise((resolve) => {
+    timeoutId = setTimeout(() => resolve(null), timeoutMs);
+  });
+  const refinementPromise = options.runRefinement(baseline).catch(() => null);
+  let refinement = null;
+  try {
+    refinement = await Promise.race([refinementPromise, timeout]);
+  } catch {
+    if (timeoutId) clearTimeout(timeoutId);
+    return baseline;
+  }
+  if (timeoutId) clearTimeout(timeoutId);
+  if (!refinement || !Array.isArray(refinement.updates) || refinement.updates.length === 0) {
+    return baseline;
+  }
+  const updatesByAction = /* @__PURE__ */ new Map();
+  for (const update of refinement.updates) {
+    if (!update || typeof update.action !== "string") continue;
+    updatesByAction.set(update.action, update);
+  }
+  let changed = false;
+  const ruleUpdates = baseline.ruleUpdates.map((rule) => {
+    const patch = updatesByAction.get(rule.action);
+    if (!patch) return rule;
+    const nextDelta = typeof patch.delta === "number" && Number.isFinite(patch.delta) ? roundDelta(clamp(patch.delta, -MAX_DELTA, MAX_DELTA)) : rule.delta;
+    const nextConfidence = patch.confidence ?? confidenceForDelta(nextDelta);
+    const nextDirection = directionForDelta(nextDelta);
+    const nextNotes = typeof patch.note === "string" && patch.note.trim().length > 0 ? [patch.note.trim()] : rule.notes;
+    if (nextDelta !== rule.delta || nextDirection !== rule.direction || nextConfidence !== rule.confidence || nextNotes.join("\n") !== rule.notes.join("\n")) {
+      changed = true;
+    }
+    return {
+      ...rule,
+      delta: nextDelta,
+      direction: nextDirection,
+      confidence: nextConfidence,
+      notes: nextNotes
+    };
+  });
+  if (!changed) return baseline;
+  return {
+    ...baseline,
+    ruleUpdates
+  };
+}
+function renderCompressionGuidelinesMarkdown(candidate) {
+  const actionLines = candidate.actionSummaries.length === 0 ? ["- (none)"] : candidate.actionSummaries.map((item) => `- ${item.action}: ${item.total}`);
+  const outcomeLines = [
+    `- applied: ${candidate.eventCounts.applied}`,
+    `- skipped: ${candidate.eventCounts.skipped}`,
+    `- failed: ${candidate.eventCounts.failed}`
+  ];
+  const updateLines = candidate.ruleUpdates.length === 0 ? ["- No telemetry events available yet. Keep defaults conservative and gather action data first."] : candidate.ruleUpdates.map((update) => {
+    const sign = update.delta > 0 ? "+" : "";
+    return `- ${update.action}: ${update.direction} (${sign}${update.delta.toFixed(3)}, confidence=${update.confidence}) \u2014 ${update.notes.join(" ")}`;
+  });
+  return [
+    "# Compression Guidelines",
+    "",
+    `Generated: ${candidate.generatedAt}`,
+    `Source events analyzed: ${candidate.eventCounts.total}`,
+    `Source window: ${candidate.sourceWindow.from} -> ${candidate.sourceWindow.to}`,
+    `Guideline version: ${candidate.guidelineVersion}`,
+    "",
+    "## Action Distribution",
+    ...actionLines,
+    "",
+    "## Outcome Distribution",
+    ...outcomeLines,
+    "",
+    "## Suggested Guidelines",
+    ...updateLines,
+    ""
+  ].join("\n");
+}
+function buildCompressionGuidelinesMarkdown(events, generatedAtIso = (/* @__PURE__ */ new Date()).toISOString(), previousState = null) {
+  const candidate = computeCompressionGuidelineCandidate(events, {
+    generatedAtIso,
+    previousState
+  });
+  return renderCompressionGuidelinesMarkdown(candidate);
+}
+
+export {
+  computeCompressionGuidelineCandidate,
+  refineCompressionGuidelineCandidateSemantically,
+  renderCompressionGuidelinesMarkdown,
+  buildCompressionGuidelinesMarkdown
+};
+//# sourceMappingURL=chunk-2NMMFZ5T.js.map

package/dist/chunk-2NMMFZ5T.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/compression-optimizer.ts"],"sourcesContent":["import type {\n  CompressionGuidelineOptimizerActionSummary,\n  CompressionGuidelineOptimizerEventCounts,\n  CompressionGuidelineOptimizerRuleUpdate,\n  CompressionGuidelineOptimizerState,\n  MemoryActionEvent,\n  MemoryActionOutcome,\n  MemoryActionType,\n} from \"./types.js\";\n\nexport interface CompressionGuidelineCandidate {\n  generatedAt: string;\n  sourceWindow: {\n    from: string;\n    to: string;\n  };\n  eventCounts: CompressionGuidelineOptimizerEventCounts;\n  actionSummaries: CompressionGuidelineOptimizerActionSummary[];\n  ruleUpdates: CompressionGuidelineOptimizerRuleUpdate[];\n  guidelineVersion: number;\n  optimizerVersion: number;\n}\n\nexport interface CompressionSemanticRuleRefinement {\n  action: MemoryActionType;\n  delta?: number;\n  confidence?: \"low\" | \"medium\" | \"high\";\n  note?: string;\n}\n\nexport interface CompressionSemanticRefinementResult {\n  updates: CompressionSemanticRuleRefinement[];\n}\n\nexport interface CompressionSemanticRefinementOptions {\n  enabled: boolean;\n  timeoutMs: number;\n  runRefinement?: (\n    candidate: CompressionGuidelineCandidate,\n  ) => Promise<CompressionSemanticRefinementResult | null>;\n}\n\nconst MAX_DELTA = 0.15;\nconst SPARSE_SAMPLE = 5;\n\nfunction clamp(value: number, min: number, max: number): number {\n  return Math.min(max, Math.max(min, value));\n}\n\nfunction parseRecallQuality(reason: string | undefined): \"good\" | \"poor\" | \"unknown\" {\n  if (!reason) return \"unknown\";\n  const text = reason.toLowerCase();\n  if (/(recall[_\\s-]?good|quality[:=]\\s*(good|high)|improv(ed|e)|resolved)/i.test(text)) {\n    return \"good\";\n  }\n  if (/(recall[_\\s-]?poor|quality[:=]\\s*(poor|low)|degrad(ed|e)|miss(ed|ing)|irrelevant)/i.test(text)) {\n    return \"poor\";\n  }\n  return \"unknown\";\n}\n\nfunction nextGuidelineVersion(previousState: CompressionGuidelineOptimizerState | null): number {\n  if (!previousState) return 1;\n  return Math.max(1, previousState.guidelineVersion + 1);\n}\n\nfunction nextOptimizerVersion(previousState: CompressionGuidelineOptimizerState | null): number {\n  if (!previousState) return 1;\n  return Math.max(1, previousState.version + 1);\n}\n\nfunction roundDelta(value: number): number {\n  return Math.round(value * 1000) / 1000;\n}\n\nfunction confidenceForDelta(delta: number): \"low\" | \"medium\" | \"high\" {\n  const magnitude = Math.abs(delta);\n  return magnitude >= 0.09 ? \"high\" : magnitude >= 0.04 ? \"medium\" : \"low\";\n}\n\nfunction directionForDelta(delta: number): \"increase\" | \"decrease\" | \"hold\" {\n  return delta > 0 ? \"increase\" : delta < 0 ? \"decrease\" : \"hold\";\n}\n\nexport function computeCompressionGuidelineCandidate(\n  events: MemoryActionEvent[],\n  options: {\n    generatedAtIso?: string;\n    previousState?: CompressionGuidelineOptimizerState | null;\n  } = {},\n): CompressionGuidelineCandidate {\n  const generatedAt = options.generatedAtIso ?? new Date().toISOString();\n  const previousState = options.previousState ?? null;\n  const effectiveEvents = events.filter((event) => event.dryRun !== true);\n  const totalCounts: CompressionGuidelineOptimizerEventCounts = {\n    total: effectiveEvents.length,\n    applied: 0,\n    skipped: 0,\n    failed: 0,\n  };\n\n  const actionMap = new Map<MemoryActionType, CompressionGuidelineOptimizerActionSummary>();\n  let windowFrom = effectiveEvents[0]?.timestamp ?? generatedAt;\n  let windowTo = effectiveEvents[0]?.timestamp ?? generatedAt;\n\n  for (const event of effectiveEvents) {\n    if (event.timestamp < windowFrom) windowFrom = event.timestamp;\n    if (event.timestamp > windowTo) windowTo = event.timestamp;\n    totalCounts[event.outcome] += 1;\n\n    let summary = actionMap.get(event.action);\n    if (!summary) {\n      summary = {\n        action: event.action,\n        total: 0,\n        outcomes: { applied: 0, skipped: 0, failed: 0 },\n        quality: { good: 0, poor: 0, unknown: 0 },\n      };\n      actionMap.set(event.action, summary);\n    }\n\n    summary.total += 1;\n    summary.outcomes[event.outcome] += 1;\n    const quality = parseRecallQuality(event.reason);\n    summary.quality[quality] += 1;\n  }\n\n  const actionSummaries = [...actionMap.values()].sort((a, b) => {\n    if (b.total !== a.total) return b.total - a.total;\n    return a.action.localeCompare(b.action);\n  });\n\n  const ruleUpdates = actionSummaries.map((summary): CompressionGuidelineOptimizerRuleUpdate => {\n    const notes: string[] = [];\n    if (summary.total < SPARSE_SAMPLE) {\n      notes.push(\"Sparse sample size; holding baseline policy.\");\n      return {\n        action: summary.action,\n        delta: 0,\n        direction: \"hold\",\n        confidence: \"low\",\n        notes,\n      };\n    }\n\n    const successRate = summary.outcomes.applied / summary.total;\n    const failureRate = summary.outcomes.failed / summary.total;\n    const qualitySeen = summary.quality.good + summary.quality.poor;\n    const qualitySignal = qualitySeen > 0\n      ? (summary.quality.good - summary.quality.poor) / qualitySeen\n      : 0;\n    const rawDelta = clamp((successRate - failureRate) * 0.12 + qualitySignal * 0.06, -MAX_DELTA, MAX_DELTA);\n    const delta = roundDelta(rawDelta);\n\n    const direction = directionForDelta(delta);\n    if (direction === \"decrease\" && summary.outcomes.failed > summary.outcomes.applied) {\n      notes.push(\"Failures exceed applied outcomes; conservative down-adjustment.\");\n    } else if (direction === \"increase\" && summary.quality.good > summary.quality.poor) {\n      notes.push(\"Good recall quality markers support this action.\");\n    } else if (direction === \"decrease\" && summary.quality.poor > summary.quality.good) {\n      notes.push(\"Poor recall quality markers exceed good markers.\");\n    } else {\n      notes.push(\"Outcomes are stable; keep bounded adjustments.\");\n    }\n\n    const confidence = confidenceForDelta(delta);\n    return {\n      action: summary.action,\n      delta,\n      direction,\n      confidence,\n      notes,\n    };\n  });\n\n  return {\n    generatedAt,\n    sourceWindow: {\n      from: effectiveEvents.length > 0 ? windowFrom : generatedAt,\n      to: effectiveEvents.length > 0 ? windowTo : generatedAt,\n    },\n    eventCounts: totalCounts,\n    actionSummaries,\n    ruleUpdates,\n    guidelineVersion: nextGuidelineVersion(previousState),\n    optimizerVersion: nextOptimizerVersion(previousState),\n  };\n}\n\nexport async function refineCompressionGuidelineCandidateSemantically(\n  baseline: CompressionGuidelineCandidate,\n  options: CompressionSemanticRefinementOptions,\n): Promise<CompressionGuidelineCandidate> {\n  if (!options.enabled) return baseline;\n  if (typeof options.runRefinement !== \"function\") return baseline;\n\n  const timeoutMs = Math.max(1, Math.floor(options.timeoutMs));\n  let timeoutId: ReturnType<typeof setTimeout> | null = null;\n  const timeout = new Promise<CompressionSemanticRefinementResult | null>((resolve) => {\n    timeoutId = setTimeout(() => resolve(null), timeoutMs);\n  });\n\n  const refinementPromise = options.runRefinement(baseline).catch(() => null);\n\n  let refinement: CompressionSemanticRefinementResult | null = null;\n  try {\n    refinement = await Promise.race([refinementPromise, timeout]);\n  } catch {\n    if (timeoutId) clearTimeout(timeoutId);\n    return baseline;\n  }\n  if (timeoutId) clearTimeout(timeoutId);\n  if (!refinement || !Array.isArray(refinement.updates) || refinement.updates.length === 0) {\n    return baseline;\n  }\n\n  const updatesByAction = new Map<MemoryActionType, CompressionSemanticRuleRefinement>();\n  for (const update of refinement.updates) {\n    if (!update || typeof update.action !== \"string\") continue;\n    updatesByAction.set(update.action, update);\n  }\n\n  let changed = false;\n  const ruleUpdates = baseline.ruleUpdates.map((rule) => {\n    const patch = updatesByAction.get(rule.action);\n    if (!patch) return rule;\n\n    const nextDelta =\n      typeof patch.delta === \"number\" && Number.isFinite(patch.delta)\n        ? roundDelta(clamp(patch.delta, -MAX_DELTA, MAX_DELTA))\n        : rule.delta;\n    const nextConfidence = patch.confidence ?? confidenceForDelta(nextDelta);\n    const nextDirection = directionForDelta(nextDelta);\n    const nextNotes =\n      typeof patch.note === \"string\" && patch.note.trim().length > 0\n        ? [patch.note.trim()]\n        : rule.notes;\n\n    if (\n      nextDelta !== rule.delta ||\n      nextDirection !== rule.direction ||\n      nextConfidence !== rule.confidence ||\n      nextNotes.join(\"\\n\") !== rule.notes.join(\"\\n\")\n    ) {\n      changed = true;\n    }\n\n    return {\n      ...rule,\n      delta: nextDelta,\n      direction: nextDirection,\n      confidence: nextConfidence,\n      notes: nextNotes,\n    };\n  });\n\n  if (!changed) return baseline;\n  return {\n    ...baseline,\n    ruleUpdates,\n  };\n}\n\nexport function renderCompressionGuidelinesMarkdown(candidate: CompressionGuidelineCandidate): string {\n  const actionLines =\n    candidate.actionSummaries.length === 0\n      ? [\"- (none)\"]\n      : candidate.actionSummaries.map((item) => `- ${item.action}: ${item.total}`);\n  const outcomeLines: string[] = [\n    `- applied: ${candidate.eventCounts.applied}`,\n    `- skipped: ${candidate.eventCounts.skipped}`,\n    `- failed: ${candidate.eventCounts.failed}`,\n  ];\n  const updateLines =\n    candidate.ruleUpdates.length === 0\n      ? [\"- No telemetry events available yet. Keep defaults conservative and gather action data first.\"]\n      : candidate.ruleUpdates.map((update) => {\n          const sign = update.delta > 0 ? \"+\" : \"\";\n          return `- ${update.action}: ${update.direction} (${sign}${update.delta.toFixed(3)}, confidence=${update.confidence}) — ${update.notes.join(\" \")}`;\n        });\n\n  return [\n    \"# Compression Guidelines\",\n    \"\",\n    `Generated: ${candidate.generatedAt}`,\n    `Source events analyzed: ${candidate.eventCounts.total}`,\n    `Source window: ${candidate.sourceWindow.from} -> ${candidate.sourceWindow.to}`,\n    `Guideline version: ${candidate.guidelineVersion}`,\n    \"\",\n    \"## Action Distribution\",\n    ...actionLines,\n    \"\",\n    \"## Outcome Distribution\",\n    ...outcomeLines,\n    \"\",\n    \"## Suggested Guidelines\",\n    ...updateLines,\n    \"\",\n  ].join(\"\\n\");\n}\n\nexport function buildCompressionGuidelinesMarkdown(\n  events: MemoryActionEvent[],\n  generatedAtIso: string = new Date().toISOString(),\n  previousState: CompressionGuidelineOptimizerState | null = null,\n): string {\n  const candidate = computeCompressionGuidelineCandidate(events, {\n    generatedAtIso,\n    previousState,\n  });\n  return renderCompressionGuidelinesMarkdown(candidate);\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-2PO5ZRKV.js

@@ -0,0 +1,103 @@
+import {
+  log
+} from "./chunk-KWBU5S5U.js";
+
+// src/day-summary.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+var PROMPT_RELATIVE_PATH = path.join("prompts", "day_summary.prompt.md");
+var EMBEDDED_DAY_SUMMARY_PROMPT = `# Baseline day-summary prompt
+
+You are writing an Engram end-of-day summary.
+
+Your job:
+- compress the day into a short, useful recap
+- prioritize concrete events, decisions, mood/energy signals, and open loops
+- include a few practical next actions for tomorrow
+- avoid hype, fluff, therapy-speak, and invented facts
+
+Output JSON with these keys:
+- \`summary\` \u2014 one short paragraph
+- \`bullets\` \u2014 2 to 5 bullets with the most important moments
+- \`next_actions\` \u2014 1 to 3 concrete actions
+- \`risks_or_open_loops\` \u2014 0 to 3 things that still need attention
+
+Rules:
+- stay grounded in the input only
+- if the day was mixed, say so plainly
+- do not overstate confidence or importance
+- prefer specific verbs over vague abstractions
+
+Brevity:
+- keep the summary under 90 words
+- keep bullets short and information-dense
+- omit anything that does not change what tomorrow should care about
+
+Structure:
+- \`summary\` should be one paragraph only
+- \`bullets\` should contain the most important moments, not generic restatements
+- \`next_actions\` and \`risks_or_open_loops\` should be distinct and non-overlapping
+
+Risk:
+- explicitly surface unresolved blockers, dependencies, or fragile assumptions
+- do not bury open loops inside the summary if they deserve separate attention
+
+Tone:
+- sound like a clear internal daily note, not a report template
+- stay natural and direct while remaining compact`;
+function candidateRoots() {
+  const currentFile = fileURLToPath(import.meta.url);
+  const here = path.dirname(currentFile);
+  const candidates = [path.resolve(here, ".."), path.resolve(here, "..", "..")];
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.filter((candidate) => {
+    const normalized = path.resolve(candidate);
+    if (seen.has(normalized)) return false;
+    seen.add(normalized);
+    return true;
+  });
+}
+function resolvePromptPath() {
+  for (const root of candidateRoots()) {
+    const candidate = path.join(root, PROMPT_RELATIVE_PATH);
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+async function loadDaySummaryPrompt() {
+  const promptPath = resolvePromptPath();
+  if (promptPath) {
+    try {
+      const raw = await readFile(promptPath, "utf-8");
+      const match = raw.match(/```(?:[a-zA-Z0-9_-]+)?\r?\n([\s\S]*?)\r?\n```/);
+      if (match?.[1]) {
+        return match[1].trim();
+      }
+      log.warn("day summary prompt file does not contain a fenced prompt block; using embedded fallback");
+    } catch (err) {
+      log.warn(`day summary prompt file read failed; using embedded fallback: ${err}`);
+    }
+  }
+  return EMBEDDED_DAY_SUMMARY_PROMPT;
+}
+function formatDaySummaryMemories(memories) {
+  if (typeof memories === "string") {
+    return memories.trim();
+  }
+  return memories.map((memory) => {
+    const category = memory.frontmatter.category || "fact";
+    const created = memory.frontmatter.created || "unknown";
+    return `[${memory.frontmatter.id}] (${category}, ${created})
+${memory.content}`;
+  }).join("\n\n").trim();
+}
+
+export {
+  loadDaySummaryPrompt,
+  formatDaySummaryMemories
+};
+//# sourceMappingURL=chunk-2PO5ZRKV.js.map

package/dist/chunk-2PO5ZRKV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/day-summary.ts"],"sourcesContent":["import { existsSync } from \"node:fs\";\nimport { readFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { log } from \"./logger.js\";\nimport type { MemoryFile } from \"./types.js\";\n\nconst PROMPT_RELATIVE_PATH = path.join(\"prompts\", \"day_summary.prompt.md\");\n\n// Embedded fallback prompt for packaged/plugin-install builds where\n// prompts/day_summary.prompt.md may not be present in the runtime bundle.\nconst EMBEDDED_DAY_SUMMARY_PROMPT = `# Baseline day-summary prompt\n\nYou are writing an Engram end-of-day summary.\n\nYour job:\n- compress the day into a short, useful recap\n- prioritize concrete events, decisions, mood/energy signals, and open loops\n- include a few practical next actions for tomorrow\n- avoid hype, fluff, therapy-speak, and invented facts\n\nOutput JSON with these keys:\n- \\`summary\\` — one short paragraph\n- \\`bullets\\` — 2 to 5 bullets with the most important moments\n- \\`next_actions\\` — 1 to 3 concrete actions\n- \\`risks_or_open_loops\\` — 0 to 3 things that still need attention\n\nRules:\n- stay grounded in the input only\n- if the day was mixed, say so plainly\n- do not overstate confidence or importance\n- prefer specific verbs over vague abstractions\n\nBrevity:\n- keep the summary under 90 words\n- keep bullets short and information-dense\n- omit anything that does not change what tomorrow should care about\n\nStructure:\n- \\`summary\\` should be one paragraph only\n- \\`bullets\\` should contain the most important moments, not generic restatements\n- \\`next_actions\\` and \\`risks_or_open_loops\\` should be distinct and non-overlapping\n\nRisk:\n- explicitly surface unresolved blockers, dependencies, or fragile assumptions\n- do not bury open loops inside the summary if they deserve separate attention\n\nTone:\n- sound like a clear internal daily note, not a report template\n- stay natural and direct while remaining compact`;\n\nfunction candidateRoots(): string[] {\n  const currentFile = fileURLToPath(import.meta.url);\n  const here = path.dirname(currentFile);\n  const candidates = [path.resolve(here, \"..\"), path.resolve(here, \"..\", \"..\")];\n\n  const seen = new Set<string>();\n  return candidates.filter((candidate) => {\n    const normalized = path.resolve(candidate);\n    if (seen.has(normalized)) return false;\n    seen.add(normalized);\n    return true;\n  });\n}\n\nfunction resolvePromptPath(): string | null {\n  for (const root of candidateRoots()) {\n    const candidate = path.join(root, PROMPT_RELATIVE_PATH);\n    if (existsSync(candidate)) {\n      return candidate;\n    }\n  }\n  return null;\n}\n\nexport async function loadDaySummaryPrompt(): Promise<string> {\n  const promptPath = resolvePromptPath();\n  if (promptPath) {\n    try {\n      const raw = await readFile(promptPath, \"utf-8\");\n      // CRLF-compatible regex: allow \\r\\n or \\n line endings\n      const match = raw.match(/```(?:[a-zA-Z0-9_-]+)?\\r?\\n([\\s\\S]*?)\\r?\\n```/);\n      if (match?.[1]) {\n        return match[1].trim();\n      }\n      log.warn(\"day summary prompt file does not contain a fenced prompt block; using embedded fallback\");\n    } catch (err) {\n      log.warn(`day summary prompt file read failed; using embedded fallback: ${err}`);\n    }\n  }\n  return EMBEDDED_DAY_SUMMARY_PROMPT;\n}\n\nexport function formatDaySummaryMemories(memories: string | MemoryFile[]): string {\n  if (typeof memories === \"string\") {\n    return memories.trim();\n  }\n\n  return memories\n    .map((memory) => {\n      const category = memory.frontmatter.category || \"fact\";\n      const created = memory.frontmatter.created || \"unknown\";\n      return `[${memory.frontmatter.id}] (${category}, ${created})\\n${memory.content}`;\n    })\n    .join(\"\\n\\n\")\n    .trim();\n}\n"],"mappings":";;;;;AAAA,SAAS,kBAAkB;AAC3B,SAAS,gBAAgB;AACzB,OAAO,UAAU;AACjB,SAAS,qBAAqB;AAI9B,IAAM,uBAAuB,KAAK,KAAK,WAAW,uBAAuB;AAIzE,IAAM,8BAA8B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAwCpC,SAAS,iBAA2B;AAClC,QAAM,cAAc,cAAc,YAAY,GAAG;AACjD,QAAM,OAAO,KAAK,QAAQ,WAAW;AACrC,QAAM,aAAa,CAAC,KAAK,QAAQ,MAAM,IAAI,GAAG,KAAK,QAAQ,MAAM,MAAM,IAAI,CAAC;AAE5E,QAAM,OAAO,oBAAI,IAAY;AAC7B,SAAO,WAAW,OAAO,CAAC,cAAc;AACtC,UAAM,aAAa,KAAK,QAAQ,SAAS;AACzC,QAAI,KAAK,IAAI,UAAU,EAAG,QAAO;AACjC,SAAK,IAAI,UAAU;AACnB,WAAO;AAAA,EACT,CAAC;AACH;AAEA,SAAS,oBAAmC;AAC1C,aAAW,QAAQ,eAAe,GAAG;AACnC,UAAM,YAAY,KAAK,KAAK,MAAM,oBAAoB;AACtD,QAAI,WAAW,SAAS,GAAG;AACzB,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;AAEA,eAAsB,uBAAwC;AAC5D,QAAM,aAAa,kBAAkB;AACrC,MAAI,YAAY;AACd,QAAI;AACF,YAAM,MAAM,MAAM,SAAS,YAAY,OAAO;AAE9C,YAAM,QAAQ,IAAI,MAAM,+CAA+C;AACvE,UAAI,QAAQ,CAAC,GAAG;AACd,eAAO,MAAM,CAAC,EAAE,KAAK;AAAA,MACvB;AACA,UAAI,KAAK,yFAAyF;AAAA,IACpG,SAAS,KAAK;AACZ,UAAI,KAAK,iEAAiE,GAAG,EAAE;AAAA,IACjF;AAAA,EACF;AACA,SAAO;AACT;AAEO,SAAS,yBAAyB,UAAyC;AAChF,MAAI,OAAO,aAAa,UAAU;AAChC,WAAO,SAAS,KAAK;AAAA,EACvB;AAEA,SAAO,SACJ,IAAI,CAAC,WAAW;AACf,UAAM,WAAW,OAAO,YAAY,YAAY;AAChD,UAAM,UAAU,OAAO,YAAY,WAAW;AAC9C,WAAO,IAAI,OAAO,YAAY,EAAE,MAAM,QAAQ,KAAK,OAAO;AAAA,EAAM,OAAO,OAAO;AAAA,EAChF,CAAC,EACA,KAAK,MAAM,EACX,KAAK;AACV;","names":[]}