clawvault 1.9.2 → 1.9.3

package/dist/{chunk-S3TOK4VI.js → chunk-AVPHNEDB.js}

@@ -58,33 +58,6 @@ function estimateTokens(text) {
   }
   return Math.ceil(text.length / 4);
 }
-function fitWithinBudget(items, budget) {
-  if (!Number.isFinite(budget) || budget <= 0) {
-    return [];
-  }
-  const sorted = items.map((item, index) => ({ ...item, index })).sort((a, b) => {
-    if (a.priority !== b.priority) {
-      return a.priority - b.priority;
-    }
-    return a.index - b.index;
-  });
-  let remaining = Math.floor(budget);
-  const fitted = [];
-  for (const item of sorted) {
-    if (!item.text.trim()) {
-      continue;
-    }
-    const cost = estimateTokens(item.text);
-    if (cost <= remaining) {
-      fitted.push({ text: item.text, source: item.source });
-      remaining -= cost;
-    }
-    if (remaining <= 0) {
-      break;
-    }
-  }
-  return fitted;
-}
 
 // src/commands/context.ts
 var DEFAULT_LIMIT = 5;
@@ -223,12 +196,8 @@ async function buildDailyContextItems(vault) {
     }
     const relativePath = path2.relative(vault.getPath(), document.path).split(path2.sep).join("/");
     const snippet = estimateSnippet(document.content);
-    const sourceId = `daily:${date}:${relativePath}`;
     items.push({
       priority: 2,
-      source: sourceId,
-      text: `${date}
-${snippet}`,
       entry: {
         title: `Daily note ${date}`,
         path: relativePath,
@@ -247,17 +216,13 @@ function buildObservationContextItems(vaultPath) {
   const observationMarkdown = readObservations(vaultPath, OBSERVATION_LOOKBACK_DAYS);
   const parsed = parseObservationLines(observationMarkdown);
   const items = [];
-  for (const [index, observation] of parsed.entries()) {
+  for (const observation of parsed) {
     const priority = observationPriorityToRank(observation.priority);
     const modifiedDate = asDate(observation.date, /* @__PURE__ */ new Date());
     const date = observation.date || modifiedDate.toISOString().slice(0, 10);
     const snippet = estimateSnippet(observation.content);
-    const sourceId = `observation:${priority}:${date}:${index}`;
     items.push({
       priority,
-      source: sourceId,
-      text: `${observation.priority} ${date}
-${snippet}`,
       entry: {
         title: `${observation.priority} observation (${date})`,
         path: `observations/${date}.md`,
@@ -273,7 +238,7 @@ ${snippet}`,
   return items;
 }
 function buildSearchContextItems(vault, results) {
-  return results.map((result, index) => {
+  return results.map((result) => {
     const relativePath = path2.relative(vault.getPath(), result.document.path).split(path2.sep).join("/");
     const entry = {
       title: result.document.title,
@@ -287,34 +252,53 @@ function buildSearchContextItems(vault, results) {
     };
     return {
       priority: 3,
-      source: `search:${index}:${entry.path}`,
-      text: `${entry.title}
-${entry.snippet}`,
       entry
     };
   });
 }
-function applyTokenBudget(items, budget) {
+function renderEntryBlock(entry) {
+  return `### ${entry.title} (${entry.source}, score: ${entry.score.toFixed(2)}, ${entry.age})
+${entry.snippet}
+
+`;
+}
+function truncateToBudget(text, budget) {
+  if (!Number.isFinite(budget) || budget <= 0) {
+    return "";
+  }
+  const maxChars = Math.max(0, Math.floor(budget) * 4);
+  if (text.length <= maxChars) {
+    return text;
+  }
+  return text.slice(0, maxChars).trimEnd();
+}
+function applyTokenBudget(items, task, budget) {
+  const fullContext = items.map((item) => item.entry);
+  const fullMarkdown = formatContextMarkdown(task, fullContext);
   if (budget === void 0) {
-    return items.map((item) => item.entry);
+    return { context: fullContext, markdown: fullMarkdown };
   }
-  const selected = fitWithinBudget(
-    items.map((item) => ({
-      text: item.text,
-      priority: item.priority,
-      source: item.source
-    })),
-    budget
-  );
-  const bySource = new Map(items.map((item) => [item.source, item.entry]));
+  const normalizedBudget = Math.max(1, Math.floor(budget));
+  const header = `## Relevant Context for: ${task}
+
+`;
+  let remaining = normalizedBudget - estimateTokens(header);
   const selectedEntries = [];
-  for (const selectedItem of selected) {
-    const entry = bySource.get(selectedItem.source);
-    if (entry) {
-      selectedEntries.push(entry);
+  for (const item of [...items].sort((a, b) => a.priority - b.priority)) {
+    if (remaining <= 0) {
+      break;
+    }
+    const cost = estimateTokens(renderEntryBlock(item.entry));
+    if (cost <= remaining) {
+      selectedEntries.push(item.entry);
+      remaining -= cost;
     }
   }
-  return selectedEntries;
+  const markdown = truncateToBudget(formatContextMarkdown(task, selectedEntries), normalizedBudget);
+  return {
+    context: selectedEntries,
+    markdown
+  };
 }
 async function buildContext(task, options) {
   const normalizedTask = task.trim();
@@ -343,12 +327,12 @@ async function buildContext(task, options) {
     ...yellowObservations,
     ...greenObservations
   ];
-  const context = applyTokenBudget(ordered, options.budget);
+  const { context, markdown } = applyTokenBudget(ordered, normalizedTask, options.budget);
   return {
     task: normalizedTask,
     generated: (/* @__PURE__ */ new Date()).toISOString(),
     context,
-    markdown: formatContextMarkdown(normalizedTask, context)
+    markdown
   };
 }
 async function contextCommand(task, options) {

package/dist/{chunk-PBLNXOPM.js → chunk-EQ2AZVBX.js}

@@ -1,7 +1,7 @@
 // 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(decid(?:e|ed|ing|ion)|error|fail(?:ed|ure)?|prefer(?:ence)?|block(?:ed|er)?|must|required?|urgent)\b/i;
+var CRITICAL_RE = /(?:\b(?:decision|decided|chose|selected)\s*:|\bdecid(?:e|ed|ing|ion)\b|\berror\b|\bfail(?:ed|ure)?\b|\bprefer(?:ence)?\b|\bblock(?:ed|er)?\b|\bmust\b|\brequired?\b|\burgent\b)/i;
 var NOTABLE_RE = /\b(context|pattern|architecture|approach|trade[- ]?off|milestone|notable)\b/i;
 var Compressor = class {
   model;
@@ -191,13 +191,40 @@ ${cleaned}`;
     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 = existingSections.get(date) ?? [];
-      current.push(...lines);
+      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);
     }
     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);
+    }
+    return deduped;
+  }
+  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;
@@ -398,7 +425,10 @@ var CATEGORY_PATTERNS = [
     category: "people",
     patterns: [
       /\b(said|asked|told|mentioned|emailed|called|messaged|met with)\b/i,
-      /\b(client|partner|team|colleague|contact)\b/i
+      /\b(client|partner|team|colleague|contact)\b/i,
+      /\b(?:Pedro|Justin|Maria|Sarah|[A-Z][a-z]+ (?:said|asked|told|mentioned))\b/,
+      /\b(?:talked to|met with)\s+[A-Z][a-z]+\b/i,
+      /\b[A-Z][a-z]+\s+from\b/
     ]
   },
   {
@@ -503,6 +533,8 @@ ${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;
@@ -538,9 +570,14 @@ var Observer = class {
       return;
     }
     const todayPath = this.getObservationPath(this.now());
-    const existing = this.readObservationFile(todayPath);
-    const compressed = (await this.compressor.compress(this.pendingMessages, existing)).trim();
+    const existingRaw = this.readObservationFile(todayPath);
+    const existing = this.deduplicateObservationMarkdown(existingRaw);
+    if (existingRaw.trim() !== existing) {
+      this.writeObservationFile(todayPath, existing);
+    }
+    const compressedRaw = (await this.compressor.compress(this.pendingMessages, existing)).trim();
     this.pendingMessages = [];
+    const compressed = this.deduplicateObservationMarkdown(compressedRaw);
     if (!compressed) {
       return;
     }
@@ -561,9 +598,14 @@ var Observer = class {
       return { observations: this.observationsCache, routingSummary: this.lastRoutingSummary };
     }
     const todayPath = this.getObservationPath(this.now());
-    const existing = this.readObservationFile(todayPath);
-    const compressed = (await this.compressor.compress(this.pendingMessages, existing)).trim();
+    const existingRaw = this.readObservationFile(todayPath);
+    const existing = this.deduplicateObservationMarkdown(existingRaw);
+    if (existingRaw.trim() !== existing) {
+      this.writeObservationFile(todayPath, existing);
+    }
+    const compressedRaw = (await this.compressor.compress(this.pendingMessages, existing)).trim();
     this.pendingMessages = [];
+    const compressed = this.deduplicateObservationMarkdown(compressedRaw);
     if (compressed) {
       this.writeObservationFile(todayPath, compressed);
       this.observationsCache = compressed;
@@ -612,6 +654,74 @@ var Observer = class {
     }
     return files.map((filePath) => this.readObservationFile(filePath)).filter(Boolean).join("\n\n");
   }
+  deduplicateObservationMarkdown(markdown) {
+    const parsed = this.parseSections(markdown);
+    if (parsed.size === 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 current = sections.get(currentDate) ?? [];
+      current.push({
+        priority: lineMatch[1],
+        content: lineMatch[2].trim()
+      });
+      sections.set(currentDate, current);
+    }
+    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();
+  }
   async reflectIfNeeded() {
     const corpus = this.readObservationCorpus();
     if (this.estimateTokens(corpus) < this.reflectThreshold) {

package/dist/{chunk-P3KFRS2W.js → chunk-JATU7JVY.js}

@@ -1,7 +1,7 @@
 import {
   Observer,
   parseSessionFile
-} from "./chunk-PBLNXOPM.js";
+} from "./chunk-EQ2AZVBX.js";
 
 // src/commands/observe.ts
 import * as fs2 from "fs";
@@ -16,13 +16,17 @@ var SessionWatcher = class {
   watchPath;
   observer;
   ignoreInitial;
+  debounceMs;
   watcher = null;
   fileOffsets = /* @__PURE__ */ new Map();
+  pendingPaths = /* @__PURE__ */ new Set();
+  debounceTimer = null;
   processingQueue = Promise.resolve();
   constructor(watchPath, observer, options = {}) {
     this.watchPath = path.resolve(watchPath);
     this.observer = observer;
     this.ignoreInitial = options.ignoreInitial ?? false;
+    this.debounceMs = options.debounceMs ?? 500;
   }
   async start() {
     if (!fs.existsSync(this.watchPath)) {
@@ -37,18 +41,44 @@ var SessionWatcher = class {
       }
     });
     const enqueue = (changedPath) => {
-      this.processingQueue = this.processingQueue.then(() => this.consumeFile(changedPath)).catch(() => void 0);
+      this.pendingPaths.add(path.resolve(changedPath));
+      this.scheduleDrain();
     };
     this.watcher.on("add", enqueue);
     this.watcher.on("change", enqueue);
     this.watcher.on("unlink", (deletedPath) => {
-      this.fileOffsets.delete(path.resolve(deletedPath));
+      const resolved = path.resolve(deletedPath);
+      this.fileOffsets.delete(resolved);
+      this.pendingPaths.delete(resolved);
+    });
+    await new Promise((resolve3, reject) => {
+      this.watcher?.once("ready", () => resolve3());
+      this.watcher?.once("error", (error) => reject(error));
     });
   }
   async stop() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    this.pendingPaths.clear();
+    await this.processingQueue.catch(() => void 0);
     await this.watcher?.close();
     this.watcher = null;
   }
+  scheduleDrain() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(() => {
+      this.debounceTimer = null;
+      const nextPaths = [...this.pendingPaths];
+      this.pendingPaths.clear();
+      for (const changedPath of nextPaths) {
+        this.processingQueue = this.processingQueue.then(() => this.consumeFile(changedPath)).catch(() => void 0);
+      }
+    }, this.debounceMs);
+  }
   async consumeFile(filePath) {
     const resolved = path.resolve(filePath);
     if (!fs.existsSync(resolved)) {

package/dist/commands/context.js

@@ -3,7 +3,7 @@ import {
   contextCommand,
   formatContextMarkdown,
   registerContextCommand
-} from "../chunk-S3TOK4VI.js";
+} from "../chunk-AVPHNEDB.js";
 import "../chunk-3HFB7EMU.js";
 import "../chunk-MIIXBNO3.js";
 export {

package/dist/commands/observe.js

@@ -1,8 +1,8 @@
 import {
   observeCommand,
   registerObserveCommand
-} from "../chunk-P3KFRS2W.js";
-import "../chunk-PBLNXOPM.js";
+} from "../chunk-JATU7JVY.js";
+import "../chunk-EQ2AZVBX.js";
 export {
   observeCommand,
   registerObserveCommand

package/dist/commands/sleep.js

@@ -13,7 +13,7 @@ import {
 import {
   Observer,
   parseSessionFile
-} from "../chunk-PBLNXOPM.js";
+} from "../chunk-EQ2AZVBX.js";
 
 // src/commands/sleep.ts
 import * as fs from "fs";

package/dist/index.d.ts

@@ -307,6 +307,10 @@ declare class Observer {
     private writeObservationFile;
     private getObservationFiles;
     private readObservationCorpus;
+    private deduplicateObservationMarkdown;
+    private parseSections;
+    private renderSections;
+    private normalizeObservationContent;
     private reflectIfNeeded;
 }
 
@@ -329,6 +333,8 @@ declare class Compressor {
     private normalizeLlmOutput;
     private fallbackCompression;
     private mergeObservations;
+    private deduplicateObservationLines;
+    private normalizeObservationContent;
     private parseSections;
     private renderSections;
     private inferPriority;
@@ -356,17 +362,22 @@ declare class Reflector {
 
 interface SessionWatcherOptions {
     ignoreInitial?: boolean;
+    debounceMs?: number;
 }
 declare class SessionWatcher {
     private readonly watchPath;
     private readonly observer;
     private readonly ignoreInitial;
+    private readonly debounceMs;
     private watcher;
     private fileOffsets;
+    private pendingPaths;
+    private debounceTimer;
     private processingQueue;
     constructor(watchPath: string, observer: Observer, options?: SessionWatcherOptions);
     start(): Promise<void>;
     stop(): Promise<void>;
+    private scheduleDrain;
     private consumeFile;
 }
 

package/dist/index.js

@@ -16,7 +16,7 @@ import {
   contextCommand,
   formatContextMarkdown,
   registerContextCommand
-} from "./chunk-S3TOK4VI.js";
+} from "./chunk-AVPHNEDB.js";
 import {
   ClawVault,
   createVault,
@@ -41,13 +41,13 @@ import {
   SessionWatcher,
   observeCommand,
   registerObserveCommand
-} from "./chunk-P3KFRS2W.js";
+} from "./chunk-JATU7JVY.js";
 import {
   Compressor,
   Observer,
   Reflector,
   parseSessionFile
-} from "./chunk-PBLNXOPM.js";
+} from "./chunk-EQ2AZVBX.js";
 
 // src/index.ts
 import * as fs from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawvault",
-  "version": "1.9.2",
+  "version": "1.9.3",
   "description": "ClawVault™ - 🐘 An elephant never forgets. Structured memory for OpenClaw agents. Context death resilience, Obsidian-compatible markdown, local semantic search.",
   "type": "module",
   "main": "dist/index.cjs",