clawvault 1.9.5 → 1.10.0

package/README.md

@@ -31,12 +31,6 @@ bun install -g qmd   # or: npm install -g qmd
 npm install -g clawvault
 ```
 
-## Blog & Resources
-
-- **Blog:** [clawvault.dev/blog](https://clawvault.dev/blog/)
-- **RSS:** [feed.xml](https://clawvault.dev/blog/feed.xml)
-- **Sitemap:** [sitemap.xml](https://clawvault.dev/sitemap.xml)
-
 ## Why ClawVault?
 
 AI agents forget things. Context windows overflow, sessions end, important details get lost. ClawVault fixes that:
@@ -75,6 +69,43 @@ echo 'export CLAWVAULT_PATH="$HOME/memory"' >> ~/.bashrc
 eval "$(clawvault shell-init)"
 ```
 
+## Observational Memory
+
+Automatically compress conversations into prioritized observations:
+
+```bash
+# One-shot: compress a conversation file
+clawvault observe --compress session.md
+
+# Watch mode: monitor a directory for new session files
+clawvault observe --watch ./sessions/
+
+# Background daemon
+clawvault observe --daemon
+```
+
+Observations use emoji priorities:
+- 🔴 **Critical** — decisions, errors, blockers, deadlines
+- 🟡 **Notable** — preferences, architecture discussions, people interactions
+- 🟢 **Info** — routine updates, deployments, general progress
+
+Critical and notable observations are automatically routed to vault categories (`decisions/`, `lessons/`, `people/`, etc.). The system uses LLM compression (Gemini, Anthropic, or OpenAI) with a rule-based fallback.
+
+Integrated into the sleep/wake lifecycle:
+```bash
+clawvault sleep "task summary" --session-transcript conversation.md
+# → observations auto-generated and routed
+
+clawvault wake
+# → recent 🔴/🟡 observations included in context
+```
+
+Token-budget-aware context injection:
+```bash
+clawvault context "what decisions were made" --budget 2000
+# → fits within token budget, 🔴 items first
+```
+
 ## ClawVault Cloud
 
 ClawVault Cloud extends local memory with org-linked decision traces. The local vault stays your source of truth, and cloud sync adds cross-agent visibility plus centralized audit trails.
@@ -101,23 +132,13 @@ clawvault trace emit --summary "Approved 20% discount for ACME"
 clawvault sync
 ```
 
-## Search: qmd vs memory_search
+## Search
 
-**Use `qmd` (or `clawvault search`) — not `memory_search`**
-
-| Tool | Backend | Speed | API Limits |
-|------|---------|-------|------------|
-| `qmd search` / `clawvault search` | Local BM25 | Instant | None |
-| `qmd vsearch` / `clawvault vsearch` | Local embeddings | Fast | None |
-| `memory_search` | Gemini API | Variable | **Yes, hits quotas** |
+ClawVault provides local search via qmd (BM25 + semantic). Works alongside OpenClaw's built-in `memory_search`.
 
 ```bash
-# ✅ Use this
-qmd search "query" -c my-memory
-clawvault search "query"
-
-# ❌ Avoid (API quotas)
-memory_search
+clawvault search "query"           # BM25 keyword search
+clawvault vsearch "what did I decide" # Semantic search (local embeddings)
 ```
 
 ## Vault Structure
@@ -250,10 +271,6 @@ clawvault sleep "..." --next "..."
 clawvault checkpoint --working-on "..." --focus "..." --blocked "..."
 \`\`\`
 
-### Why qmd over memory_search?
-- Local embeddings — no API quotas
-- Always works — no external dependencies
-- Fast — instant BM25, quick semantic
 ```
 
 ## Templates

package/dist/{chunk-RTIBMFCQ.js → chunk-2MP4EHJ7.js}

@@ -1,7 +1,7 @@
 import {
   Observer,
   parseSessionFile
-} from "./chunk-ITN7XQPX.js";
+} from "./chunk-SIDM2I2C.js";
 
 // src/commands/observe.ts
 import * as fs2 from "fs";
@@ -12,21 +12,25 @@ import { spawn } from "child_process";
 import * as fs from "fs";
 import * as path from "path";
 import chokidar from "chokidar";
+var DEFAULT_FLUSH_THRESHOLD_CHARS = 500;
 var SessionWatcher = class {
   watchPath;
   observer;
   ignoreInitial;
   debounceMs;
+  flushThresholdChars;
   watcher = null;
   fileOffsets = /* @__PURE__ */ new Map();
   pendingPaths = /* @__PURE__ */ new Set();
   debounceTimer = null;
   processingQueue = Promise.resolve();
+  bufferedChars = 0;
   constructor(watchPath, observer, options = {}) {
     this.watchPath = path.resolve(watchPath);
     this.observer = observer;
     this.ignoreInitial = options.ignoreInitial ?? false;
     this.debounceMs = options.debounceMs ?? 500;
+    this.flushThresholdChars = Math.max(1, options.flushThresholdChars ?? DEFAULT_FLUSH_THRESHOLD_CHARS);
   }
   async start() {
     if (!fs.existsSync(this.watchPath)) {
@@ -55,14 +59,22 @@ var SessionWatcher = class {
       this.watcher?.once("ready", () => resolve3());
       this.watcher?.once("error", (error) => reject(error));
     });
+    if (this.ignoreInitial) {
+      this.primeInitialOffsets();
+    }
   }
   async stop() {
     if (this.debounceTimer) {
       clearTimeout(this.debounceTimer);
       this.debounceTimer = null;
+      this.drainPendingPaths();
     }
-    this.pendingPaths.clear();
     await this.processingQueue.catch(() => void 0);
+    if (this.bufferedChars > 0) {
+      await this.observer.flush();
+      this.bufferedChars = 0;
+    }
+    this.pendingPaths.clear();
     await this.watcher?.close();
     this.watcher = null;
   }
@@ -72,13 +84,16 @@ var SessionWatcher = class {
     }
     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.drainPendingPaths();
     }, this.debounceMs);
   }
+  drainPendingPaths() {
+    const nextPaths = [...this.pendingPaths];
+    this.pendingPaths.clear();
+    for (const changedPath of nextPaths) {
+      this.processingQueue = this.processingQueue.then(() => this.consumeFile(changedPath)).catch(() => void 0);
+    }
+  }
   async consumeFile(filePath) {
     const resolved = path.resolve(filePath);
     if (!fs.existsSync(resolved)) {
@@ -109,6 +124,45 @@ var SessionWatcher = class {
       return;
     }
     await this.observer.processMessages(messages);
+    this.bufferedChars += chunk.length;
+    if (this.bufferedChars >= this.flushThresholdChars) {
+      await this.observer.flush();
+      this.bufferedChars = 0;
+    }
+  }
+  primeInitialOffsets() {
+    for (const filePath of this.collectFiles(this.watchPath)) {
+      try {
+        const stats = fs.statSync(filePath);
+        if (stats.isFile()) {
+          this.fileOffsets.set(filePath, stats.size);
+        }
+      } catch {
+      }
+    }
+  }
+  collectFiles(targetPath) {
+    if (!fs.existsSync(targetPath)) {
+      return [];
+    }
+    const resolved = path.resolve(targetPath);
+    const stats = fs.statSync(resolved);
+    if (stats.isFile()) {
+      return [resolved];
+    }
+    if (!stats.isDirectory()) {
+      return [];
+    }
+    const collected = [];
+    for (const entry of fs.readdirSync(resolved, { withFileTypes: true })) {
+      const childPath = path.join(resolved, entry.name);
+      if (entry.isDirectory()) {
+        collected.push(...this.collectFiles(childPath));
+      } else if (entry.isFile()) {
+        collected.push(path.resolve(childPath));
+      }
+    }
+    return collected;
   }
 };
 

package/dist/{chunk-ITN7XQPX.js → chunk-SIDM2I2C.js}

@@ -1,8 +1,9 @@
 // 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)?\b|\bprefer(?:ence)?\b|\bblock(?:ed|er)?\b|\bmust\b|\brequired?\b|\burgent\b|\bdeadline\b|\bbreaking\b|\bcritical\b|\b\w+\s+chosen\s+(?:for|over|as)\b)/i;
-var NOTABLE_RE = /\b(context|pattern|architecture|approach|trade[- ]?off|milestone|notable)\b/i;
+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)/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)\b/i;
 var Compressor = class {
   model;
   now;
@@ -53,10 +54,12 @@ var Compressor = class {
       "- 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} MUST be used for: any decision (chose X, decided Y, selected Z, opted for, switched to), errors/failures, deadlines, blockers, preferences, breaking changes",
-      "- \u{1F7E1} for: architecture discussions, trade-offs, milestones, patterns, notable context",
+      "- \u{1F534} for: decisions between alternatives, errors/failures, blockers, deadlines with explicit dates, breaking changes",
+      "- \u{1F7E1} for: preferences, architecture discussions, trade-offs, milestones, people interactions, notable context, routine deadlines",
       "- \u{1F7E2} for: routine updates, deployments, builds, general info",
-      "- When someone chooses between options, that is ALWAYS \u{1F534} \u2014 even if the choice seems minor",
+      "- Preferences are \u{1F7E1} unless they indicate a breaking decision between alternatives.",
+      "- Each distinct error type or failure must be its own observation line; do not merge different errors.",
+      "- If multiple different errors occurred, list each separately with its specific error message.",
       "- Keep observations concise and factual.",
       "- Avoid duplicates when possible.",
       "",
@@ -161,7 +164,7 @@ ${cleaned}`;
   }
   /**
    * Post-process LLM output to enforce priority rules.
-   * Lines matching CRITICAL_RE get upgraded to 🔴, NOTABLE_RE to 🟡.
+   * Lines matching critical rules get upgraded to 🔴, notable rules to 🟡.
    */
   enforcePriorityRules(markdown) {
     return markdown.split(/\r?\n/).map((line) => {
@@ -169,10 +172,10 @@ ${cleaned}`;
       if (!match) return line;
       const currentPriority = match[1];
       const content = match[2];
-      if (CRITICAL_RE.test(content) && currentPriority !== "\u{1F534}") {
+      if (this.isCriticalContent(content) && currentPriority !== "\u{1F534}") {
         return line.replace(/^🟡|^🟢/u, "\u{1F534}");
       }
-      if (NOTABLE_RE.test(content) && currentPriority === "\u{1F7E2}") {
+      if (this.isNotableContent(content) && currentPriority === "\u{1F7E2}") {
         return line.replace(/^🟢/u, "\u{1F7E1}");
       }
       return line;
@@ -284,10 +287,16 @@ ${cleaned}`;
     return chunks.join("\n").trim();
   }
   inferPriority(text) {
-    if (CRITICAL_RE.test(text)) return "\u{1F534}";
-    if (NOTABLE_RE.test(text)) return "\u{1F7E1}";
+    if (this.isCriticalContent(text)) return "\u{1F534}";
+    if (this.isNotableContent(text)) return "\u{1F7E1}";
     return "\u{1F7E2}";
   }
+  isCriticalContent(text) {
+    return CRITICAL_RE.test(text) || DEADLINE_WITH_DATE_RE.test(text);
+  }
+  isNotableContent(text) {
+    return NOTABLE_RE.test(text);
+  }
   normalizeText(text) {
     return text.replace(/\s+/g, " ").replace(/\[[^\]]+\]/g, "").trim().slice(0, 280);
   }

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

@@ -58,11 +58,71 @@ 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;
 var MAX_SNIPPET_LENGTH = 320;
 var OBSERVATION_LOOKBACK_DAYS = 7;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "by",
+  "for",
+  "from",
+  "how",
+  "in",
+  "is",
+  "it",
+  "of",
+  "on",
+  "or",
+  "that",
+  "the",
+  "this",
+  "to",
+  "was",
+  "were",
+  "what",
+  "when",
+  "where",
+  "who",
+  "why",
+  "with",
+  "you",
+  "your"
+]);
 function formatRelativeAge(date, now = Date.now()) {
   const ageMs = Math.max(0, now - date.getTime());
   const days = Math.floor(ageMs / (24 * 60 * 60 * 1e3));
@@ -97,6 +157,35 @@ function formatContextMarkdown(task, entries) {
   }
   return output.trimEnd();
 }
+function extractKeywords(text) {
+  const raw = text.toLowerCase().match(/[a-z0-9]+/g) ?? [];
+  const seen = /* @__PURE__ */ new Set();
+  const keywords = [];
+  for (const token of raw) {
+    if (token.length < 2 || STOP_WORDS.has(token) || seen.has(token)) {
+      continue;
+    }
+    seen.add(token);
+    keywords.push(token);
+  }
+  return keywords;
+}
+function computeKeywordOverlapScore(queryKeywords, text) {
+  if (queryKeywords.length === 0) {
+    return 1;
+  }
+  const haystack = new Set(extractKeywords(text));
+  let matches = 0;
+  for (const keyword of queryKeywords) {
+    if (haystack.has(keyword)) {
+      matches += 1;
+    }
+  }
+  if (matches === 0) {
+    return 0.1;
+  }
+  return matches / queryKeywords.length;
+}
 function estimateSnippet(source) {
   const normalized = source.replace(/\s+/g, " ").trim();
   if (!normalized) {
@@ -134,11 +223,6 @@ function observationPriorityToRank(priority) {
   if (priority === "\u{1F7E1}") return 4;
   return 5;
 }
-function observationPriorityScore(priority) {
-  if (priority === "\u{1F534}") return 1;
-  if (priority === "\u{1F7E1}") return 0.7;
-  return 0.4;
-}
 function isLikelyDailyNote(document) {
   const normalizedPath = document.path.split(path2.sep).join("/").toLowerCase();
   if (normalizedPath.includes("/daily/")) {
@@ -212,7 +296,7 @@ async function buildDailyContextItems(vault) {
   }
   return items;
 }
-function buildObservationContextItems(vaultPath) {
+function buildObservationContextItems(vaultPath, queryKeywords) {
   const observationMarkdown = readObservations(vaultPath, OBSERVATION_LOOKBACK_DAYS);
   const parsed = parseObservationLines(observationMarkdown);
   const items = [];
@@ -227,7 +311,7 @@ function buildObservationContextItems(vaultPath) {
         title: `${observation.priority} observation (${date})`,
         path: `observations/${date}.md`,
         category: "observations",
-        score: observationPriorityScore(observation.priority),
+        score: computeKeywordOverlapScore(queryKeywords, observation.content),
         snippet,
         modified: modifiedDate.toISOString(),
         age: formatRelativeAge(modifiedDate),
@@ -279,21 +363,31 @@ function applyTokenBudget(items, task, budget) {
     return { context: fullContext, markdown: fullMarkdown };
   }
   const normalizedBudget = Math.max(1, Math.floor(budget));
+  if (estimateTokens(fullMarkdown) <= normalizedBudget) {
+    return { context: fullContext, markdown: fullMarkdown };
+  }
   const header = `## Relevant Context for: ${task}
 
 `;
-  let remaining = normalizedBudget - estimateTokens(header);
-  const selectedEntries = [];
-  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;
-    }
+  const headerCost = estimateTokens(header);
+  if (headerCost >= normalizedBudget) {
+    return {
+      context: [],
+      markdown: truncateToBudget(header.trimEnd(), normalizedBudget)
+    };
   }
+  const fitted = fitWithinBudget(
+    items.map((item, index) => ({
+      text: renderEntryBlock(item.entry),
+      priority: item.priority,
+      source: String(index)
+    })),
+    normalizedBudget - headerCost
+  );
+  const selectedEntries = fitted.map((item) => {
+    const index = Number.parseInt(item.source, 10);
+    return Number.isNaN(index) ? null : items[index]?.entry ?? null;
+  }).filter((entry) => Boolean(entry));
   const markdown = truncateToBudget(formatContextMarkdown(task, selectedEntries), normalizedBudget);
   return {
     context: selectedEntries,
@@ -310,20 +404,24 @@ async function buildContext(task, options) {
   const limit = Math.max(1, options.limit ?? DEFAULT_LIMIT);
   const recent = options.recent ?? true;
   const includeObservations = options.includeObservations ?? true;
+  const queryKeywords = extractKeywords(normalizedTask);
   const searchResults = await vault.vsearch(normalizedTask, {
     limit,
     temporalBoost: recent
   });
   const searchItems = buildSearchContextItems(vault, searchResults);
   const dailyItems = await buildDailyContextItems(vault);
-  const observationItems = includeObservations ? buildObservationContextItems(vault.getPath()) : [];
-  const redObservations = observationItems.filter((item) => item.priority === 1);
-  const yellowObservations = observationItems.filter((item) => item.priority === 4);
-  const greenObservations = observationItems.filter((item) => item.priority === 5);
+  const observationItems = includeObservations ? buildObservationContextItems(vault.getPath(), queryKeywords) : [];
+  const byScoreDesc = (left, right) => right.entry.score - left.entry.score;
+  const redObservations = observationItems.filter((item) => item.priority === 1).sort(byScoreDesc);
+  const yellowObservations = observationItems.filter((item) => item.priority === 4).sort(byScoreDesc);
+  const greenObservations = observationItems.filter((item) => item.priority === 5).sort(byScoreDesc);
+  const sortedDailyItems = [...dailyItems].sort(byScoreDesc);
+  const sortedSearchItems = [...searchItems].sort(byScoreDesc);
   const ordered = [
     ...redObservations,
-    ...dailyItems,
-    ...searchItems,
+    ...sortedDailyItems,
+    ...sortedSearchItems,
     ...yellowObservations,
     ...greenObservations
   ];

package/dist/commands/context.js

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

package/dist/commands/observe.js

@@ -1,8 +1,8 @@
 import {
   observeCommand,
   registerObserveCommand
-} from "../chunk-RTIBMFCQ.js";
-import "../chunk-ITN7XQPX.js";
+} from "../chunk-2MP4EHJ7.js";
+import "../chunk-SIDM2I2C.js";
 export {
   observeCommand,
   registerObserveCommand

package/dist/commands/sleep.js

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

package/dist/commands/wake.js

@@ -15,6 +15,9 @@ import * as fs from "fs";
 import * as path from "path";
 var DEFAULT_HANDOFF_LIMIT = 3;
 var OBSERVATION_HIGHLIGHT_RE = /^(🔴|🟡)\s+(.+)$/u;
+var MAX_WAKE_RED_OBSERVATIONS = 20;
+var MAX_WAKE_YELLOW_OBSERVATIONS = 10;
+var MAX_WAKE_OUTPUT_LINES = 100;
 function formatSummaryItems(items, maxItems = 2) {
   const cleaned = items.map((item) => item.trim()).filter(Boolean);
   if (cleaned.length === 0) return "";
@@ -60,23 +63,53 @@ function readRecentObservationHighlights(vaultPath) {
   }
   return highlights;
 }
+function timeFromObservationText(text) {
+  const match = text.match(/^([01]\d|2[0-3]):([0-5]\d)\b/);
+  if (!match) {
+    return -1;
+  }
+  return Number.parseInt(match[1], 10) * 60 + Number.parseInt(match[2], 10);
+}
+function compareByRecency(left, right) {
+  if (left.date !== right.date) {
+    return right.date.localeCompare(left.date);
+  }
+  return timeFromObservationText(right.text) - timeFromObservationText(left.text);
+}
 function formatRecentObservations(highlights) {
   if (highlights.length === 0) {
     return "_No critical or notable observations from today or yesterday._";
   }
+  const sorted = [...highlights].sort(compareByRecency);
+  const red = sorted.filter((item) => item.priority === "\u{1F534}").slice(0, MAX_WAKE_RED_OBSERVATIONS);
+  const yellow = sorted.filter((item) => item.priority === "\u{1F7E1}").slice(0, MAX_WAKE_YELLOW_OBSERVATIONS);
+  const visible = [...red, ...yellow].sort(compareByRecency);
+  const omittedCount = Math.max(0, highlights.length - visible.length);
   const byDate = /* @__PURE__ */ new Map();
-  for (const item of highlights) {
+  for (const item of visible) {
     const bucket = byDate.get(item.date) ?? [];
     bucket.push(item);
     byDate.set(item.date, bucket);
   }
   const lines = [];
+  const bodyLineBudget = Math.max(1, MAX_WAKE_OUTPUT_LINES - (omittedCount > 0 ? 1 : 0));
   for (const [date, items] of byDate.entries()) {
+    if (lines.length >= bodyLineBudget) {
+      break;
+    }
     lines.push(`### ${date}`);
     for (const item of items) {
+      if (lines.length >= bodyLineBudget) {
+        break;
+      }
       lines.push(`- ${item.priority} ${item.text}`);
     }
-    lines.push("");
+    if (lines.length < bodyLineBudget) {
+      lines.push("");
+    }
+  }
+  if (omittedCount > 0) {
+    lines.push(`... and ${omittedCount} more observations (use \`clawvault context\` to query)`);
   }
   return lines.join("\n").trim();
 }

package/dist/index.d.ts

@@ -333,7 +333,7 @@ declare class Compressor {
     private normalizeLlmOutput;
     /**
      * Post-process LLM output to enforce priority rules.
-     * Lines matching CRITICAL_RE get upgraded to 🔴, NOTABLE_RE to 🟡.
+     * Lines matching critical rules get upgraded to 🔴, notable rules to 🟡.
      */
     private enforcePriorityRules;
     private fallbackCompression;
@@ -343,6 +343,8 @@ declare class Compressor {
     private parseSections;
     private renderSections;
     private inferPriority;
+    private isCriticalContent;
+    private isNotableContent;
     private normalizeText;
     private extractDate;
     private extractTime;
@@ -368,22 +370,28 @@ declare class Reflector {
 interface SessionWatcherOptions {
     ignoreInitial?: boolean;
     debounceMs?: number;
+    flushThresholdChars?: number;
 }
 declare class SessionWatcher {
     private readonly watchPath;
     private readonly observer;
     private readonly ignoreInitial;
     private readonly debounceMs;
+    private readonly flushThresholdChars;
     private watcher;
     private fileOffsets;
     private pendingPaths;
     private debounceTimer;
     private processingQueue;
+    private bufferedChars;
     constructor(watchPath: string, observer: Observer, options?: SessionWatcherOptions);
     start(): Promise<void>;
     stop(): Promise<void>;
     private scheduleDrain;
+    private drainPendingPaths;
     private consumeFile;
+    private primeInitialOffsets;
+    private collectFiles;
 }
 
 declare function parseSessionFile(filePath: string): string[];

package/dist/index.js

@@ -16,7 +16,7 @@ import {
   contextCommand,
   formatContextMarkdown,
   registerContextCommand
-} from "./chunk-AVPHNEDB.js";
+} from "./chunk-UBRYOIII.js";
 import {
   ClawVault,
   createVault,
@@ -41,13 +41,13 @@ import {
   SessionWatcher,
   observeCommand,
   registerObserveCommand
-} from "./chunk-RTIBMFCQ.js";
+} from "./chunk-2MP4EHJ7.js";
 import {
   Compressor,
   Observer,
   Reflector,
   parseSessionFile
-} from "./chunk-ITN7XQPX.js";
+} from "./chunk-SIDM2I2C.js";
 
 // src/index.ts
 import * as fs from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawvault",
-  "version": "1.9.5",
+  "version": "1.10.0",
   "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",

package/dashboard/test-crash.mjs

@@ -1,37 +0,0 @@
-import puppeteer from 'puppeteer';
-
-async function test() {
-  console.log('Launching browser...');
-  const browser = await puppeteer.launch({ headless: true, args: ['--no-sandbox'] });
-  const page = await browser.newPage();
-  
-  const errors = [];
-  page.on('console', msg => {
-    if (msg.type() === 'error') errors.push(msg.text());
-  });
-  page.on('pageerror', err => errors.push(err.message));
-  
-  console.log('Loading dashboard...');
-  try {
-    await page.goto('http://localhost:3377', { timeout: 30000, waitUntil: 'networkidle0' });
-    console.log('Page loaded, waiting 10s...');
-    await new Promise(r => setTimeout(r, 10000));
-    
-    const nodeCount = await page.evaluate(() => {
-      const stats = document.querySelector('#stats')?.textContent || '';
-      return stats;
-    });
-    console.log('Stats:', nodeCount);
-    console.log('Errors:', errors.length ? errors : 'none');
-    
-    await page.screenshot({ path: 'dashboard/test-screenshot.png' });
-    console.log('Screenshot saved to dashboard/test-screenshot.png');
-  } catch (e) {
-    console.log('CRASH:', e.message);
-  }
-  
-  await browser.close();
-  console.log('Test complete');
-}
-
-test();