clawvault 2.1.2 → 2.2.0

package/dist/{chunk-5MQB7B37.js → chunk-2HM7ZI4X.js}

@@ -1,6 +1,22 @@
+import {
+  DATE_HEADING_RE,
+  inferObservationType,
+  normalizeObservationContent,
+  parseObservationLine,
+  parseObservationMarkdown,
+  renderObservationMarkdown,
+  renderScoredObservationLine
+} from "./chunk-K6XHCUFL.js";
+import {
+  ensureLedgerStructure,
+  ensureParentDir,
+  getLegacyObservationPath,
+  getObservationPath,
+  getRawTranscriptPath,
+  toDateKey
+} from "./chunk-Z2XBWN7A.js";
+
 // src/observer/compressor.ts
-var DATE_HEADING_RE = /^##\s+(\d{4}-\d{2}-\d{2})\s*$/;
-var OBSERVATION_LINE_RE = /^(🔴|🟡|🟢)\s+(.+)$/u;
 var CRITICAL_RE = /(?:\b(?:decision|decided|chose|chosen|selected|picked|opted|switched to)\s*:?|\bdecid(?:e|ed|ing|ion)\b|\berror\b|\bfail(?:ed|ure|ing)?\b|\bblock(?:ed|er)?\b|\bbreaking(?:\s+change)?s?\b|\bcritical\b|\b\w+\s+chosen\s+(?:for|over|as)\b|\bpublish(?:ed)?\b.*@?\d+\.\d+|\bmerge[d]?\s+(?:PR|pull\s+request)\b|\bshipped\b|\breleased?\b.*v?\d+\.\d+|\bsigned\b.*\b(?:contract|agreement|deal)\b|\bpricing\b.*\$|\bdemo\b.*\b(?:completed?|done|finished)\b|\bmeeting\b.*\b(?:completed?|done|finished)\b|\bstrategy\b.*\b(?:pivot|change|shift)\b)/i;
 var DEADLINE_WITH_DATE_RE = /(?:(?:\bdeadline\b|\bdue(?:\s+date)?\b|\bcutoff\b).*(?:\d{4}-\d{2}-\d{2}|\d{1,2}\/\d{1,2}(?:\/\d{2,4})?|(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*\s+\d{1,2})|(?:\d{4}-\d{2}-\d{2}|\d{1,2}\/\d{1,2}(?:\/\d{2,4})?|(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*\s+\d{1,2}).*(?:\bdeadline\b|\bdue(?:\s+date)?\b|\bcutoff\b))/i;
 var NOTABLE_RE = /\b(prefer(?:ence|s)?|likes?|dislikes?|context|pattern|architecture|approach|trade[- ]?off|milestone|stakeholder|teammate|collaborat(?:e|ed|ion)|discussion|notable|deadline|due|timeline|deploy(?:ed|ment)?|built|configured|launched|proposal|pitch|onboard(?:ed|ing)?|migrat(?:e|ed|ion)|domain|DNS|infra(?:structure)?)\b/i;
@@ -53,11 +69,12 @@ var Compressor = class {
       "Rules:",
       "- Output markdown only.",
       "- Group observations by date heading: ## YYYY-MM-DD",
-      "- Each line must follow: <emoji> <HH:MM> <observation>",
-      "- Priority emojis: \u{1F534} critical, \u{1F7E1} notable, \u{1F7E2} info",
-      "- \u{1F534} for: decisions, blockers, deadlines, breaking changes, commitments to people, version releases, merged PRs, shipped features, client meetings/demos, pricing/contract decisions, strategy changes, signed agreements",
-      "- \u{1F7E1} for: preferences, architecture discussions, trade-offs, milestones, people interactions, notable context, production deploys, new tools built, config changes, proposals sent, content published, infrastructure changes",
-      "- \u{1F7E2} for: routine tasks, intermediate build steps, general progress, minor fixes",
+      "- Each observation line MUST follow: - [type|c=<0.00-1.00>|i=<0.00-1.00>] <observation>",
+      "- Allowed type tags: decision, preference, fact, commitment, milestone, lesson, relationship, project",
+      "- i >= 0.80 for structural/persistent observations (major decisions, blockers, releases, commitments)",
+      "- i 0.40-0.79 for potentially important observations (notable context, preferences, milestones)",
+      "- i < 0.40 for contextual/routine observations",
+      "- Confidence c reflects extraction certainty, not importance.",
       "- Preserve source tags when present (e.g., [main], [telegram-dm], [discord], [telegram-group]).",
       "",
       "QUALITY FILTERS (important):",
@@ -74,19 +91,16 @@ var Compressor = class {
       "",
       "PROJECT MILESTONES (critical \u2014 these are the most valuable observations):",
       "Projects are NOT just code. Milestones include business, strategy, client, and operational events.",
-      "- \u{1F534} ALWAYS for: version releases/publishes, PR merges, shipped features, signed contracts, pricing decisions, client meetings/demos, strategy pivots, partnership agreements, major config changes",
-      "- \u{1F7E1} ALWAYS for: production deploys, new tools/commands built, pitch decks sent, proposals delivered, infrastructure changes, domain/DNS changes, onboarding steps, content published (blog posts, landing pages)",
+      "- Use milestone/decision/commitment types for strategic events with high importance.",
+      "- Use preference/lesson/relationship/project/fact when appropriate.",
       "- Examples:",
-      '  "\u{1F534} 14:00 Published clawvault@2.1.0 to npm with active session observer"',
-      '  "\u{1F534} 14:00 Artemisa demo completed \u2014 #1 pain point confirmed: quick estimates"',
-      '  "\u{1F534} 14:00 Pricing decision: $33K one-time + $3K/mo for Artemisa"',
-      '  "\u{1F534} 14:00 Merged PR #2: Active session observation into master"',
-      '  "\u{1F7E1} 14:00 Deployed pitch deck to artemisa-pitch-deck.vercel.app"',
-      '  "\u{1F7E1} 14:00 Moved docs.clawvault.dev domain to new Vercel project"',
+      '  "- [decision|c=0.95|i=0.90] 14:00 Pricing decision: $33K one-time + $3K/mo for Artemisa"',
+      '  "- [milestone|c=0.93|i=0.88] 14:00 Published clawvault@2.1.0 to npm"',
+      '  "- [project|c=0.84|i=0.58] 14:00 Deployed pitch deck to artemisa-pitch-deck.vercel.app"',
       "- Do NOT collapse multiple milestones into one line \u2014 each matters for history.",
       "",
       "COMMITMENT FORMAT (when someone promises/agrees to something):",
-      '- Use: "\u{1F534} HH:MM [COMMITMENT] <who> committed to <what> by <when>" (include deadline if mentioned)',
+      '- Prefer: "- [commitment|c=...|i=...] HH:MM [COMMITMENT] <who> committed to <what> by <when>"',
       "",
       "Keep observations concise and factual. Aim for signal, not completeness.",
       "",
@@ -179,7 +193,7 @@ var Compressor = class {
     }
     const cleaned = output.replace(/^```(?:markdown)?\s*/i, "").replace(/\s*```$/, "").trim();
     const lines = cleaned.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-    const hasObservationLine = lines.some((line) => OBSERVATION_LINE_RE.test(line));
+    const hasObservationLine = lines.some((line) => line.startsWith("- [") || /^(?:-\s*)?(🔴|🟡|🟢)\s+/.test(line));
     if (!hasObservationLine) {
       return "";
     }
@@ -188,7 +202,7 @@ var Compressor = class {
 
 ${cleaned}`;
     const sanitized = this.sanitizeWikiLinks(result);
-    return this.enforcePriorityRules(sanitized);
+    return this.enforceImportanceRules(sanitized);
   }
   /**
    * Fix wiki-link corruption from LLM compression.
@@ -204,24 +218,43 @@ ${cleaned}`;
     result = result.replace(/ {2,}/g, " ");
     return result;
   }
-  /**
-   * Post-process LLM output to enforce priority rules.
-   * Lines matching critical rules get upgraded to 🔴, notable rules to 🟡.
-   */
-  enforcePriorityRules(markdown) {
-    return markdown.split(/\r?\n/).map((line) => {
-      const match = line.match(OBSERVATION_LINE_RE);
-      if (!match) return line;
-      const currentPriority = match[1];
-      const content = match[2];
-      if (this.isCriticalContent(content) && currentPriority !== "\u{1F534}") {
-        return line.replace(/^🟡|^🟢/u, "\u{1F534}");
-      }
-      if (this.isNotableContent(content) && currentPriority === "\u{1F7E2}") {
-        return line.replace(/^🟢/u, "\u{1F7E1}");
+  enforceImportanceRules(markdown) {
+    const parsed = parseObservationMarkdown(markdown);
+    if (parsed.length === 0) {
+      return "";
+    }
+    const grouped = /* @__PURE__ */ new Map();
+    for (const record of parsed) {
+      const adjusted = this.enforceImportanceForRecord(record);
+      const bucket = grouped.get(record.date) ?? [];
+      bucket.push(adjusted);
+      grouped.set(record.date, bucket);
+    }
+    return renderObservationMarkdown(grouped);
+  }
+  enforceImportanceForRecord(record) {
+    let importance = record.importance;
+    let confidence = record.confidence;
+    let type = record.type;
+    if (this.isCriticalContent(record.content)) {
+      importance = Math.max(importance, 0.85);
+      confidence = Math.max(confidence, 0.85);
+      if (type === "fact") {
+        type = inferObservationType(record.content);
       }
-      return line;
-    }).join("\n");
+    } else if (this.isNotableContent(record.content)) {
+      importance = Math.max(importance, 0.5);
+      confidence = Math.max(confidence, 0.75);
+    }
+    if (type === "decision" || type === "commitment" || type === "milestone") {
+      importance = Math.max(importance, 0.6);
+    }
+    return {
+      type,
+      confidence: this.clamp01(confidence),
+      importance: this.clamp01(importance),
+      content: record.content
+    };
   }
   fallbackCompression(messages) {
     const sections = /* @__PURE__ */ new Map();
@@ -231,107 +264,96 @@ ${cleaned}`;
       if (!normalized) continue;
       const date = this.extractDate(message) ?? this.formatDate(this.now());
       const time = this.extractTime(message) ?? this.formatTime(this.now());
-      const priority = this.inferPriority(normalized);
       const line = `${time} ${normalized}`;
-      const dedupeKey = `${date}|${priority}|${this.normalizeText(line)}`;
+      const type = inferObservationType(line);
+      const importance = this.inferImportance(line, type);
+      const confidence = this.inferConfidence(line, type, importance);
+      const dedupeKey = `${date}|${type}|${normalizeObservationContent(line)}`;
       if (seen.has(dedupeKey)) continue;
       seen.add(dedupeKey);
       const bucket = sections.get(date) ?? [];
-      bucket.push({ priority, content: line });
+      bucket.push({ type, confidence, importance, content: line });
       sections.set(date, bucket);
     }
     if (sections.size === 0) {
       const date = this.formatDate(this.now());
-      sections.set(date, [{ priority: "\u{1F7E2}", content: `${this.formatTime(this.now())} Processed session updates.` }]);
+      sections.set(date, [{
+        type: "fact",
+        confidence: 0.7,
+        importance: 0.2,
+        content: `${this.formatTime(this.now())} Processed session updates.`
+      }]);
     }
     return this.renderSections(sections);
   }
   mergeObservations(existing, incoming) {
-    const existingSections = this.parseSections(existing);
-    const incomingSections = this.parseSections(incoming);
-    if (incomingSections.size === 0) {
+    const existingRecords = parseObservationMarkdown(existing);
+    const incomingRecords = parseObservationMarkdown(incoming);
+    if (incomingRecords.length === 0) {
       return existing.trim();
     }
-    if (existingSections.size === 0) {
-      return this.renderSections(incomingSections);
-    }
-    for (const [date, lines] of existingSections.entries()) {
-      existingSections.set(date, this.deduplicateObservationLines(lines));
-    }
-    for (const [date, lines] of incomingSections.entries()) {
-      const current = this.deduplicateObservationLines(existingSections.get(date) ?? []);
-      const seen = new Set(current.map((line) => this.normalizeObservationContent(line.content)));
-      for (const line of lines) {
-        const normalized = this.normalizeObservationContent(line.content);
-        if (!normalized || seen.has(normalized)) {
-          continue;
-        }
-        seen.add(normalized);
-        current.push(line);
-      }
-      existingSections.set(date, current);
+    const merged = /* @__PURE__ */ new Map();
+    for (const record of existingRecords) {
+      this.mergeRecord(merged, {
+        date: record.date,
+        type: record.type,
+        confidence: record.confidence,
+        importance: record.importance,
+        content: record.content
+      });
     }
-    return this.renderSections(existingSections);
-  }
-  deduplicateObservationLines(lines) {
-    const deduped = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (const line of lines) {
-      const normalized = this.normalizeObservationContent(line.content);
-      if (!normalized || seen.has(normalized)) {
-        continue;
-      }
-      seen.add(normalized);
-      deduped.push(line);
+    for (const record of incomingRecords) {
+      this.mergeRecord(merged, {
+        date: record.date,
+        type: record.type,
+        confidence: record.confidence,
+        importance: record.importance,
+        content: record.content
+      });
     }
-    return deduped;
+    return this.renderSections(merged);
   }
-  normalizeObservationContent(content) {
-    return content.replace(/^\d{2}:\d{2}\s+/, "").replace(/\s+/g, " ").trim().toLowerCase();
-  }
-  parseSections(markdown) {
-    const sections = /* @__PURE__ */ new Map();
-    let currentDate = null;
-    for (const rawLine of markdown.split(/\r?\n/)) {
-      const dateMatch = rawLine.match(DATE_HEADING_RE);
-      if (dateMatch) {
-        currentDate = dateMatch[1];
-        if (!sections.has(currentDate)) {
-          sections.set(currentDate, []);
-        }
-        continue;
-      }
-      if (!currentDate) continue;
-      const lineMatch = rawLine.match(OBSERVATION_LINE_RE);
-      if (!lineMatch) continue;
-      const bucket = sections.get(currentDate) ?? [];
+  mergeRecord(sections, input) {
+    const bucket = sections.get(input.date) ?? [];
+    const key = normalizeObservationContent(input.content);
+    const index = bucket.findIndex((line) => normalizeObservationContent(line.content) === key);
+    if (index === -1) {
       bucket.push({
-        priority: lineMatch[1],
-        content: lineMatch[2].trim()
+        type: input.type,
+        confidence: this.clamp01(input.confidence),
+        importance: this.clamp01(input.importance),
+        content: input.content.trim()
       });
-      sections.set(currentDate, bucket);
+      sections.set(input.date, bucket);
+      return;
     }
-    return sections;
+    const existing = bucket[index];
+    bucket[index] = {
+      type: input.importance >= existing.importance ? input.type : existing.type,
+      confidence: this.clamp01(Math.max(existing.confidence, input.confidence)),
+      importance: this.clamp01(Math.max(existing.importance, input.importance)),
+      content: existing.content.length >= input.content.length ? existing.content : input.content
+    };
+    sections.set(input.date, bucket);
   }
   renderSections(sections) {
-    const chunks = [];
-    const sortedDates = [...sections.keys()].sort((a, b) => a.localeCompare(b));
-    for (const date of sortedDates) {
-      const lines = sections.get(date) ?? [];
-      if (lines.length === 0) continue;
-      chunks.push(`## ${date}`);
-      chunks.push("");
-      for (const line of lines) {
-        chunks.push(`${line.priority} ${line.content}`);
-      }
-      chunks.push("");
+    return renderObservationMarkdown(sections);
+  }
+  inferImportance(text, type) {
+    if (this.isCriticalContent(text)) return 0.9;
+    if (this.isNotableContent(text)) return 0.6;
+    if (type === "decision" || type === "commitment" || type === "milestone") return 0.55;
+    if (type === "preference" || type === "lesson" || type === "relationship" || type === "project") return 0.45;
+    return 0.2;
+  }
+  inferConfidence(text, type, importance) {
+    let confidence = 0.72;
+    if (importance >= 0.8) confidence += 0.12;
+    if (type === "decision" || type === "commitment" || type === "milestone") confidence += 0.06;
+    if (/\b(?:decided|chose|committed|deadline|released|merged)\b/i.test(text)) {
+      confidence += 0.05;
     }
-    return chunks.join("\n").trim();
-  }
-  inferPriority(text) {
-    if (this.isCriticalContent(text)) return "\u{1F534}";
-    if (this.isNotableContent(text)) return "\u{1F7E1}";
-    return "\u{1F7E2}";
+    return this.clamp01(confidence);
   }
   isCriticalContent(text) {
     return CRITICAL_RE.test(text) || DEADLINE_WITH_DATE_RE.test(text);
@@ -359,11 +381,17 @@ ${cleaned}`;
   formatTime(date) {
     return date.toISOString().slice(11, 16);
   }
+  clamp01(value) {
+    if (!Number.isFinite(value)) return 0;
+    if (value < 0) return 0;
+    if (value > 1) return 1;
+    return value;
+  }
 };
 
 // src/observer/reflector.ts
 var DATE_HEADING_RE2 = /^##\s+(\d{4}-\d{2}-\d{2})\s*$/;
-var OBSERVATION_LINE_RE2 = /^(🔴|🟡|🟢)\s+(.+)$/u;
+var OBSERVATION_LINE_RE = /^(🔴|🟡|🟢)\s+(.+)$/u;
 var Reflector = class {
   now;
   constructor(options = {}) {
@@ -431,7 +459,7 @@ var Reflector = class {
         continue;
       }
       if (!currentDate) continue;
-      const lineMatch = rawLine.match(OBSERVATION_LINE_RE2);
+      const lineMatch = rawLine.match(OBSERVATION_LINE_RE);
       if (!lineMatch) continue;
       const bucket = sections.get(currentDate) ?? [];
       bucket.push({
@@ -524,8 +552,16 @@ var CATEGORY_PATTERNS = [
     ]
   }
 ];
-var OBSERVATION_LINE_RE3 = /^(🔴|🟡|🟢)\s+(\d{2}:\d{2})?\s*(.+)$/u;
-var DATE_HEADING_RE3 = /^##\s+(\d{4}-\d{2}-\d{2})\s*$/;
+var TYPE_TO_CATEGORY = {
+  decision: "decisions",
+  preference: "preferences",
+  fact: "facts",
+  commitment: "commitments",
+  milestone: "projects",
+  lesson: "lessons",
+  relationship: "people",
+  project: "projects"
+};
 var Router = class {
   vaultPath;
   constructor(vaultPath) {
@@ -533,17 +569,25 @@ var Router = class {
   }
   /**
    * Takes observation markdown and routes items to appropriate vault categories.
-   * Only routes 🔴 and 🟡 items — 🟢 stays only in observations.
+   * Routes only items with importance >= 0.4.
    * Returns a summary of what was routed where.
    */
   route(observationMarkdown) {
     const items = this.parseObservations(observationMarkdown);
     const routed = [];
     for (const item of items) {
-      if (item.priority === "\u{1F7E2}") continue;
-      const category = this.categorize(item.content);
+      if (item.importance < 0.4) continue;
+      const category = this.categorize(item.type, item.content);
       if (!category) continue;
-      const routedItem = { category, title: item.title, content: item.content, priority: item.priority, date: item.date };
+      const routedItem = {
+        category,
+        title: item.title,
+        content: item.content,
+        type: item.type,
+        confidence: item.confidence,
+        importance: item.importance,
+        date: item.date
+      };
       routed.push(routedItem);
       this.appendToCategory(category, routedItem);
     }
@@ -551,24 +595,21 @@ var Router = class {
     return { routed, summary };
   }
   parseObservations(markdown) {
-    const results = [];
-    let currentDate = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    for (const line of markdown.split(/\r?\n/)) {
-      const dateMatch = line.match(DATE_HEADING_RE3);
-      if (dateMatch) {
-        currentDate = dateMatch[1];
-        continue;
-      }
-      const obsMatch = line.match(OBSERVATION_LINE_RE3);
-      if (!obsMatch) continue;
-      const priority = obsMatch[1];
-      const content = obsMatch[3].trim();
-      const title = content.slice(0, 80).replace(/[^a-zA-Z0-9\s-]/g, "").trim();
-      results.push({ priority, content, date: currentDate, title });
+    const records = parseObservationMarkdown(markdown);
+    return records.map((record) => ({
+      type: record.type,
+      confidence: record.confidence,
+      importance: record.importance,
+      content: record.content,
+      date: record.date,
+      title: record.content.slice(0, 80).replace(/[^a-zA-Z0-9\s-]/g, "").trim()
+    }));
+  }
+  categorize(type, content) {
+    const typedCategory = TYPE_TO_CATEGORY[type];
+    if (typedCategory) {
+      return typedCategory;
     }
-    return results;
-  }
-  categorize(content) {
     for (const { category, patterns } of CATEGORY_PATTERNS) {
       if (patterns.some((p) => p.test(content))) {
         return category;
@@ -577,7 +618,9 @@ var Router = class {
     return null;
   }
   normalizeForDedup(content) {
-    return content.replace(/^\d{2}:\d{2}\s+/, "").replace(/\[\[[^\]]*\]\]/g, (m) => m.replace(/\[\[|\]\]/g, "")).replace(/\s+/g, " ").trim().toLowerCase();
+    return normalizeObservationContent(
+      content.replace(/\[\[[^\]]*\]\]/g, (match) => match.replace(/\[\[|\]\]/g, ""))
+    );
   }
   /**
    * Extract entity slug from observation content for people/projects routing.
@@ -634,12 +677,15 @@ var Router = class {
     const normalizedNew = this.normalizeForDedup(item.content);
     const existingLines = existing.split(/\r?\n/);
     for (const line of existingLines) {
-      const lineContent = line.replace(/^-\s*(?:🔴|🟡|🟢)\s*/, "");
-      if (this.normalizeForDedup(lineContent) === normalizedNew) return;
+      const lineContent = line.replace(/^-\s*/, "").trim();
+      const parsed = parseObservationLine(lineContent, item.date);
+      const candidate = parsed ? parsed.content : lineContent;
+      if (this.normalizeForDedup(candidate) === normalizedNew) return;
     }
     for (const line of existingLines) {
-      const lineContent = line.replace(/^-\s*(?:🔴|🟡|🟢)\s*/, "");
-      const normalizedExisting = this.normalizeForDedup(lineContent);
+      const lineContent = line.replace(/^-\s*/, "").trim();
+      const parsed = parseObservationLine(lineContent, item.date);
+      const normalizedExisting = this.normalizeForDedup(parsed ? parsed.content : lineContent);
       if (normalizedExisting.length > 10 && normalizedNew.length > 10) {
         const shorter = normalizedNew.length < normalizedExisting.length ? normalizedNew : normalizedExisting;
         const longer = normalizedNew.length >= normalizedExisting.length ? normalizedNew : normalizedExisting;
@@ -647,7 +693,12 @@ var Router = class {
       }
     }
     const linkedContent = this.addWikiLinks(item.content);
-    const entry = `- ${item.priority} ${linkedContent}`;
+    const entry = renderScoredObservationLine({
+      type: item.type,
+      confidence: item.confidence,
+      importance: item.importance,
+      content: linkedContent
+    });
     const entitySlug = this.extractEntitySlug(item.content, category);
     const headerLabel = entitySlug ? `${category}/${entitySlug}` : category;
     const header = existing ? "" : `# ${headerLabel} \u2014 ${item.date}
@@ -842,44 +893,48 @@ ${entry}
 };
 
 // src/observer/observer.ts
-var DATE_HEADING_RE4 = /^##\s+(\d{4}-\d{2}-\d{2})\s*$/;
-var OBSERVATION_LINE_RE4 = /^(🔴|🟡|🟢)\s+(.+)$/u;
 var Observer = class {
   vaultPath;
-  observationsDir;
   tokenThreshold;
+  // Kept for backwards API compatibility with callers that still pass this.
+  // Reflection now runs explicitly via clawvault reflect.
   reflectThreshold;
   compressor;
   reflector;
   now;
+  rawCapture;
   router;
   pendingMessages = [];
   observationsCache = "";
   lastRoutingSummary = "";
   constructor(vaultPath, options = {}) {
     this.vaultPath = path2.resolve(vaultPath);
-    this.observationsDir = path2.join(this.vaultPath, "observations");
     this.tokenThreshold = options.tokenThreshold ?? 3e4;
     this.reflectThreshold = options.reflectThreshold ?? 4e4;
     this.now = options.now ?? (() => /* @__PURE__ */ new Date());
     this.compressor = options.compressor ?? new Compressor({ model: options.model, now: this.now });
     this.reflector = options.reflector ?? new Reflector({ now: this.now });
+    this.rawCapture = options.rawCapture ?? true;
     this.router = new Router(vaultPath);
-    fs2.mkdirSync(this.observationsDir, { recursive: true });
+    ensureLedgerStructure(this.vaultPath);
     this.observationsCache = this.readTodayObservations();
   }
-  async processMessages(messages) {
+  async processMessages(messages, options = {}) {
     const incoming = messages.map((message) => message.trim()).filter(Boolean);
     if (incoming.length === 0) {
       return;
     }
+    if (this.rawCapture) {
+      this.persistRawMessages(incoming, options);
+    }
     this.pendingMessages.push(...incoming);
     const buffered = this.pendingMessages.join("\n");
     if (this.estimateTokens(buffered) < this.tokenThreshold) {
       return;
     }
-    const todayPath = this.getObservationPath(this.now());
-    const existingRaw = this.readObservationFile(todayPath);
+    const today = this.now();
+    const todayPath = getObservationPath(this.vaultPath, today);
+    const existingRaw = this.readObservationForDate(today);
     const existing = this.deduplicateObservationMarkdown(existingRaw);
     if (existingRaw.trim() !== existing) {
       this.writeObservationFile(todayPath, existing);
@@ -896,7 +951,6 @@ var Observer = class {
     if (summary) {
       this.lastRoutingSummary = summary;
     }
-    await this.reflectIfNeeded();
   }
   /**
    * Force-flush pending messages regardless of threshold.
@@ -906,8 +960,9 @@ var Observer = class {
     if (this.pendingMessages.length === 0) {
       return { observations: this.observationsCache, routingSummary: this.lastRoutingSummary };
     }
-    const todayPath = this.getObservationPath(this.now());
-    const existingRaw = this.readObservationFile(todayPath);
+    const today = this.now();
+    const todayPath = getObservationPath(this.vaultPath, today);
+    const existingRaw = this.readObservationForDate(today);
     const existing = this.deduplicateObservationMarkdown(existingRaw);
     if (existingRaw.trim() !== existing) {
       this.writeObservationFile(todayPath, existing);
@@ -920,7 +975,6 @@ var Observer = class {
       this.observationsCache = compressed;
       const { summary } = this.router.route(compressed);
       this.lastRoutingSummary = summary;
-      await this.reflectIfNeeded();
     }
     return { observations: this.observationsCache, routingSummary: this.lastRoutingSummary };
   }
@@ -931,13 +985,16 @@ var Observer = class {
   estimateTokens(input) {
     return Math.ceil(input.length / 4);
   }
-  getObservationPath(date) {
-    const datePart = date.toISOString().split("T")[0];
-    return path2.join(this.observationsDir, `${datePart}.md`);
-  }
   readTodayObservations() {
-    const todayPath = this.getObservationPath(this.now());
-    return this.readObservationFile(todayPath);
+    return this.readObservationForDate(this.now());
+  }
+  readObservationForDate(date) {
+    const ledgerPath = getObservationPath(this.vaultPath, date);
+    const ledgerValue = this.readObservationFile(ledgerPath);
+    if (ledgerValue) {
+      return ledgerValue;
+    }
+    return this.readObservationFile(getLegacyObservationPath(this.vaultPath, toDateKey(date)));
   }
   readObservationFile(filePath) {
     if (!fs2.existsSync(filePath)) {
@@ -946,292 +1003,69 @@ var Observer = class {
     return fs2.readFileSync(filePath, "utf-8").trim();
   }
   writeObservationFile(filePath, content) {
-    fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
+    ensureParentDir(filePath);
     fs2.writeFileSync(filePath, `${content.trim()}
 `, "utf-8");
   }
-  getObservationFiles() {
-    if (!fs2.existsSync(this.observationsDir)) {
-      return [];
-    }
-    return fs2.readdirSync(this.observationsDir).filter((name) => name.endsWith(".md")).sort((a, b) => a.localeCompare(b)).map((name) => path2.join(this.observationsDir, name));
-  }
-  readObservationCorpus() {
-    const files = this.getObservationFiles();
-    if (files.length === 0) {
-      return "";
-    }
-    return files.map((filePath) => this.readObservationFile(filePath)).filter(Boolean).join("\n\n");
-  }
   deduplicateObservationMarkdown(markdown) {
-    const parsed = this.parseSections(markdown);
-    if (parsed.size === 0) {
+    const parsed = parseObservationMarkdown(markdown);
+    if (parsed.length === 0) {
       return markdown.trim();
     }
-    for (const [date, lines] of parsed.entries()) {
-      const seen = /* @__PURE__ */ new Set();
-      const deduped = [];
-      for (const line of lines) {
-        const normalized = this.normalizeObservationContent(line.content);
-        if (!normalized || seen.has(normalized)) {
-          continue;
-        }
-        seen.add(normalized);
-        deduped.push(line);
-      }
-      parsed.set(date, deduped);
-    }
-    return this.renderSections(parsed);
-  }
-  parseSections(markdown) {
-    const sections = /* @__PURE__ */ new Map();
-    let currentDate = null;
-    for (const rawLine of markdown.split(/\r?\n/)) {
-      const dateMatch = rawLine.match(DATE_HEADING_RE4);
-      if (dateMatch) {
-        currentDate = dateMatch[1];
-        if (!sections.has(currentDate)) {
-          sections.set(currentDate, []);
-        }
-        continue;
-      }
-      if (!currentDate) {
-        continue;
-      }
-      const lineMatch = rawLine.match(OBSERVATION_LINE_RE4);
-      if (!lineMatch) {
-        continue;
+    const grouped = /* @__PURE__ */ new Map();
+    for (const record of parsed) {
+      const bucket = grouped.get(record.date) ?? [];
+      const normalized = normalizeObservationContent(record.content);
+      const existingIndex = bucket.findIndex(
+        (line) => normalizeObservationContent(line.content) === normalized
+      );
+      if (existingIndex === -1) {
+        bucket.push({
+          type: record.type,
+          confidence: record.confidence,
+          importance: record.importance,
+          content: record.content
+        });
+      } else {
+        const existing = bucket[existingIndex];
+        bucket[existingIndex] = {
+          type: record.importance >= existing.importance ? record.type : existing.type,
+          confidence: Math.max(existing.confidence, record.confidence),
+          importance: Math.max(existing.importance, record.importance),
+          content: existing.content.length >= record.content.length ? existing.content : record.content
+        };
       }
-      const current = sections.get(currentDate) ?? [];
-      current.push({
-        priority: lineMatch[1],
-        content: lineMatch[2].trim()
-      });
-      sections.set(currentDate, current);
+      grouped.set(record.date, bucket);
     }
-    return sections;
-  }
-  renderSections(sections) {
-    const chunks = [];
-    const dates = [...sections.keys()].sort((a, b) => a.localeCompare(b));
-    for (const date of dates) {
-      const lines = sections.get(date) ?? [];
-      if (lines.length === 0) {
-        continue;
-      }
-      chunks.push(`## ${date}`);
-      chunks.push("");
-      for (const line of lines) {
-        chunks.push(`${line.priority} ${line.content}`);
-      }
-      chunks.push("");
-    }
-    return chunks.join("\n").trim();
-  }
-  normalizeObservationContent(content) {
-    return content.replace(/^\d{2}:\d{2}\s+/, "").replace(/\s+/g, " ").trim().toLowerCase();
+    return renderObservationMarkdown(grouped);
+  }
+  persistRawMessages(messages, options) {
+    const source = this.sanitizeSource(options.source ?? "openclaw");
+    const messageTimestamp = options.timestamp ?? this.now();
+    const rawPath = getRawTranscriptPath(this.vaultPath, source, messageTimestamp);
+    ensureParentDir(rawPath);
+    const records = messages.map((message) => JSON.stringify({
+      recordedAt: this.now().toISOString(),
+      timestamp: messageTimestamp.toISOString(),
+      source,
+      sessionKey: options.sessionKey ?? null,
+      transcriptId: options.transcriptId ?? null,
+      message
+    }));
+    fs2.appendFileSync(rawPath, `${records.join("\n")}
+`, "utf-8");
   }
-  async reflectIfNeeded() {
-    const corpus = this.readObservationCorpus();
-    if (this.estimateTokens(corpus) < this.reflectThreshold) {
-      return;
-    }
-    for (const filePath of this.getObservationFiles()) {
-      const current = this.readObservationFile(filePath);
-      if (!current) continue;
-      const reflected = this.reflector.reflect(current).trim();
-      if (!reflected) {
-        fs2.rmSync(filePath, { force: true });
-        continue;
-      }
-      this.writeObservationFile(filePath, reflected);
+  sanitizeSource(source) {
+    const normalized = source.trim().toLowerCase();
+    if (/^[a-z0-9_-]{1,64}$/.test(normalized)) {
+      return normalized;
     }
-    this.observationsCache = this.readTodayObservations();
+    return "openclaw";
   }
 };
 
-// src/observer/session-parser.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
-var JSONL_SAMPLE_LIMIT = 20;
-var MARKDOWN_SIGNAL_RE = /^(#{1,6}\s|[-*+]\s|>\s)/;
-var MARKDOWN_INLINE_RE = /(\[[^\]]+\]\([^)]+\)|[*_`~])/;
-function normalizeText(value) {
-  return value.replace(/\s+/g, " ").trim();
-}
-function extractText(value) {
-  if (typeof value === "string") {
-    return normalizeText(value);
-  }
-  if (Array.isArray(value)) {
-    const parts = [];
-    for (const part of value) {
-      const extracted = extractText(part);
-      if (extracted) {
-        parts.push(extracted);
-      }
-    }
-    return normalizeText(parts.join(" "));
-  }
-  if (!value || typeof value !== "object") {
-    return "";
-  }
-  const record = value;
-  if (typeof record.text === "string") {
-    return normalizeText(record.text);
-  }
-  if (typeof record.content === "string") {
-    return normalizeText(record.content);
-  }
-  return "";
-}
-function normalizeRole(role) {
-  if (typeof role !== "string") {
-    return "";
-  }
-  const normalized = role.trim().toLowerCase();
-  if (!normalized) {
-    return "";
-  }
-  return normalized;
-}
-function isLikelyJsonMessage(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return false;
-  }
-  const record = value;
-  if ("role" in record && "content" in record) {
-    return true;
-  }
-  if (record.type === "message" && record.message && typeof record.message === "object") {
-    return true;
-  }
-  return false;
-}
-function parseJsonLine(line) {
-  let parsed;
-  try {
-    parsed = JSON.parse(line);
-  } catch {
-    return "";
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    return "";
-  }
-  const entry = parsed;
-  if ("role" in entry && "content" in entry) {
-    const role = normalizeRole(entry.role);
-    const content = extractText(entry.content);
-    if (!content) return "";
-    return role ? `${role}: ${content}` : content;
-  }
-  if (entry.type === "message" && entry.message && typeof entry.message === "object") {
-    const message = entry.message;
-    const role = normalizeRole(message.role);
-    const content = extractText(message.content);
-    if (!content) return "";
-    return role ? `${role}: ${content}` : content;
-  }
-  return "";
-}
-function parseJsonLines(raw) {
-  const messages = [];
-  for (const line of raw.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    const parsed = parseJsonLine(trimmed);
-    if (parsed) {
-      messages.push(parsed);
-    }
-  }
-  return messages;
-}
-function stripMarkdownSyntax(text) {
-  return normalizeText(
-    text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/[*_`~]/g, "").replace(/<[^>]+>/g, "")
-  );
-}
-function normalizeMarkdownLine(line) {
-  return stripMarkdownSyntax(
-    line.replace(/^>\s*/, "").replace(/^[-*+]\s+/, "").replace(/^#{1,6}\s+/, "")
-  );
-}
-function parseMarkdown(raw) {
-  const withoutCodeBlocks = raw.replace(/```[\s\S]*?```/g, " ");
-  const blocks = withoutCodeBlocks.split(/\r?\n\s*\r?\n/).map((block) => block.trim()).filter(Boolean);
-  const messages = [];
-  for (const block of blocks) {
-    const lines = block.split(/\r?\n/).map((line) => normalizeMarkdownLine(line)).filter(Boolean);
-    if (lines.length === 0) {
-      continue;
-    }
-    const joined = stripMarkdownSyntax(lines.join(" "));
-    if (!joined) continue;
-    const roleMatch = /^(user|assistant|system|tool)\s*:?\s*(.+)$/i.exec(joined);
-    if (roleMatch) {
-      const role = normalizeRole(roleMatch[1]);
-      const content = normalizeText(roleMatch[2]);
-      if (content) {
-        messages.push(`${role}: ${content}`);
-      }
-      continue;
-    }
-    messages.push(joined);
-  }
-  return messages;
-}
-function parsePlainText(raw) {
-  return raw.split(/\r?\n/).map((line) => normalizeText(line)).filter(Boolean);
-}
-function detectSessionFormat(raw, filePath) {
-  const nonEmptyLines = raw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-  if (nonEmptyLines.length === 0) {
-    return "plain";
-  }
-  const sample = nonEmptyLines.slice(0, JSONL_SAMPLE_LIMIT);
-  const jsonHits = sample.filter((line) => {
-    try {
-      const parsed = JSON.parse(line);
-      return isLikelyJsonMessage(parsed);
-    } catch {
-      return false;
-    }
-  }).length;
-  if (jsonHits >= Math.max(1, Math.ceil(sample.length * 0.6))) {
-    return "jsonl";
-  }
-  const ext = path3.extname(filePath).toLowerCase();
-  if (ext === ".md" || ext === ".markdown") {
-    return "markdown";
-  }
-  const markdownSignals = sample.filter((line) => MARKDOWN_SIGNAL_RE.test(line) || MARKDOWN_INLINE_RE.test(line)).length;
-  if (markdownSignals >= Math.max(2, Math.ceil(sample.length * 0.4))) {
-    return "markdown";
-  }
-  return "plain";
-}
-function parseSessionFile(filePath) {
-  const resolved = path3.resolve(filePath);
-  const raw = fs3.readFileSync(resolved, "utf-8");
-  const format = detectSessionFormat(raw, resolved);
-  if (format === "jsonl") {
-    const parsed = parseJsonLines(raw);
-    if (parsed.length > 0) {
-      return parsed;
-    }
-  }
-  if (format === "markdown") {
-    const parsed = parseMarkdown(raw);
-    if (parsed.length > 0) {
-      return parsed;
-    }
-  }
-  return parsePlainText(raw);
-}
-
 export {
   Compressor,
   Reflector,
-  Observer,
-  parseSessionFile
+  Observer
 };