clawvault 2.6.0 → 3.0.0

package/dist/plugin/vault.d.cts

@@ -0,0 +1,68 @@
+import { Observation } from './observe.cjs';
+
+/**
+ * Template-Aware Vault File Writing for ClawVault
+ *
+ * Writes vault files with proper frontmatter based on template schemas.
+ * Validates enum fields, applies defaults, and adds timestamps.
+ */
+
+interface WriteOptions {
+    primitiveType?: string;
+    title?: string;
+    content?: string;
+    extraFields?: Record<string, unknown>;
+    source?: string;
+    sessionId?: string;
+    directory?: string;
+    filename?: string;
+    overwrite?: boolean;
+}
+interface WriteResult {
+    success: boolean;
+    path: string;
+    primitiveType: string;
+    errors: string[];
+    created: boolean;
+    updated: boolean;
+}
+interface LedgerEntry {
+    timestamp: Date;
+    category: string;
+    actor?: string;
+    content: string;
+    primitiveType?: string;
+    tags?: string[];
+}
+declare function writeVaultFile(vaultPath: string, options: WriteOptions): WriteResult;
+declare function writeObservation(vaultPath: string, observation: Observation, options?: {
+    source?: string;
+    sessionId?: string;
+}): WriteResult;
+declare function writeObservations(vaultPath: string, observations: Observation[], options?: {
+    source?: string;
+    sessionId?: string;
+}): WriteResult[];
+declare function appendToLedger(vaultPath: string, entry: LedgerEntry): void;
+declare function appendObservationToLedger(vaultPath: string, observation: Observation, actor?: string): void;
+interface BatchWriteResult {
+    total: number;
+    successful: number;
+    failed: number;
+    results: WriteResult[];
+}
+declare function batchWriteObservations(vaultPath: string, observations: Observation[], options?: {
+    source?: string;
+    sessionId?: string;
+    writeLedger?: boolean;
+    writeFiles?: boolean;
+    actor?: string;
+}): BatchWriteResult;
+declare function ensureVaultStructure(vaultPath: string): void;
+declare function getVaultStats(vaultPath: string): {
+    directories: string[];
+    fileCount: number;
+    primitiveTypes: Record<string, number>;
+};
+
+export { type BatchWriteResult, type LedgerEntry, type WriteOptions, type WriteResult, appendObservationToLedger, appendToLedger, batchWriteObservations, ensureVaultStructure, getVaultStats, writeObservation, writeObservations, writeVaultFile };

package/dist/plugin/vault.d.ts

@@ -0,0 +1,68 @@
+import { Observation } from './observe.js';
+
+/**
+ * Template-Aware Vault File Writing for ClawVault
+ *
+ * Writes vault files with proper frontmatter based on template schemas.
+ * Validates enum fields, applies defaults, and adds timestamps.
+ */
+
+interface WriteOptions {
+    primitiveType?: string;
+    title?: string;
+    content?: string;
+    extraFields?: Record<string, unknown>;
+    source?: string;
+    sessionId?: string;
+    directory?: string;
+    filename?: string;
+    overwrite?: boolean;
+}
+interface WriteResult {
+    success: boolean;
+    path: string;
+    primitiveType: string;
+    errors: string[];
+    created: boolean;
+    updated: boolean;
+}
+interface LedgerEntry {
+    timestamp: Date;
+    category: string;
+    actor?: string;
+    content: string;
+    primitiveType?: string;
+    tags?: string[];
+}
+declare function writeVaultFile(vaultPath: string, options: WriteOptions): WriteResult;
+declare function writeObservation(vaultPath: string, observation: Observation, options?: {
+    source?: string;
+    sessionId?: string;
+}): WriteResult;
+declare function writeObservations(vaultPath: string, observations: Observation[], options?: {
+    source?: string;
+    sessionId?: string;
+}): WriteResult[];
+declare function appendToLedger(vaultPath: string, entry: LedgerEntry): void;
+declare function appendObservationToLedger(vaultPath: string, observation: Observation, actor?: string): void;
+interface BatchWriteResult {
+    total: number;
+    successful: number;
+    failed: number;
+    results: WriteResult[];
+}
+declare function batchWriteObservations(vaultPath: string, observations: Observation[], options?: {
+    source?: string;
+    sessionId?: string;
+    writeLedger?: boolean;
+    writeFiles?: boolean;
+    actor?: string;
+}): BatchWriteResult;
+declare function ensureVaultStructure(vaultPath: string): void;
+declare function getVaultStats(vaultPath: string): {
+    directories: string[];
+    fileCount: number;
+    primitiveTypes: Record<string, number>;
+};
+
+export { type BatchWriteResult, type LedgerEntry, type WriteOptions, type WriteResult, appendObservationToLedger, appendToLedger, batchWriteObservations, ensureVaultStructure, getVaultStats, writeObservation, writeObservations, writeVaultFile };

package/dist/plugin/vault.js

@@ -0,0 +1,22 @@
+import {
+  appendObservationToLedger,
+  appendToLedger,
+  batchWriteObservations,
+  ensureVaultStructure,
+  getVaultStats,
+  writeObservation,
+  writeObservations,
+  writeVaultFile
+} from "../chunk-MFM6K7PU.js";
+import "../chunk-GQSLDZTS.js";
+import "../chunk-3RG5ZIWI.js";
+export {
+  appendObservationToLedger,
+  appendToLedger,
+  batchWriteObservations,
+  ensureVaultStructure,
+  getVaultStats,
+  writeObservation,
+  writeObservations,
+  writeVaultFile
+};

package/dist/{types-C74wgGL1.d.ts → types-Y2_Um2Ls.d.cts}

@@ -70,6 +70,49 @@ interface SearchOptions {
     fullContent?: boolean;
     /** Boost recent documents in ranking */
     temporalBoost?: boolean;
+    /**
+     * v2.7 — Enable chunk-level BM25 pre-filtering before semantic search.
+     * Chunks documents into ~600-char sentence windows and ranks chunks by
+     * keyword overlap so that relevant content deep in long documents isn't
+     * silently dropped by fixed-N embedding limits.
+     */
+    chunkPrefilter?: boolean;
+    /**
+     * v2.7 — Exhaustive threshold-based retrieval for aggregation queries.
+     * Instead of a fixed top_k, keeps pulling results until the normalised
+     * relevance score drops below this threshold (0-1).  Set to e.g. 0.01
+     * for aggregation / "list all" queries.  Overrides `limit` when set.
+     */
+    relevanceThreshold?: number;
+    /**
+     * v2.7 — Maximum results when using relevanceThreshold.
+     * Prevents runaway result sets. Default 40.
+     */
+    thresholdMaxResults?: number;
+}
+/**
+ * v2.7 — A date reference extracted from document content at ingest time.
+ */
+interface ExtractedDate {
+    /** ISO date string (YYYY-MM-DD) or "duration:<value>" */
+    date: string;
+    /** Surrounding context snippet (~150 chars) */
+    context: string;
+    /** Document id the date was extracted from */
+    documentId: string;
+}
+/**
+ * v2.7 — An extracted user preference from conversation content.
+ */
+interface ExtractedPreference {
+    /** The preference category (tool, hobby, brand, etc.) */
+    category: string;
+    /** The preference value */
+    value: string;
+    /** Document id it was extracted from */
+    documentId: string;
+    /** Surrounding context snippet */
+    context: string;
 }
 interface StoreOptions {
     /** Category to store in */
@@ -159,4 +202,4 @@ interface SessionRecap {
 }
 declare const DEFAULT_CONFIG: Partial<VaultConfig>;
 
-export { type Category as C, type Document as D, type HandoffDocument as H, type MemoryType as M, type StoreOptions as S, TYPE_TO_CATEGORY as T, type VaultConfig as V, type SearchOptions as a, type SearchResult as b, type SyncOptions as c, type SyncResult as d, type SessionRecap as e, DEFAULT_CATEGORIES as f, DEFAULT_CONFIG as g, MEMORY_TYPES as h, type VaultMeta as i };
+export { type Category as C, type Document as D, type ExtractedDate as E, type HandoffDocument as H, type MemoryType as M, type StoreOptions as S, TYPE_TO_CATEGORY as T, type VaultConfig as V, type SearchOptions as a, type SearchResult as b, type SyncOptions as c, type SyncResult as d, type SessionRecap as e, type ExtractedPreference as f, DEFAULT_CATEGORIES as g, DEFAULT_CONFIG as h, MEMORY_TYPES as i, type VaultMeta as j };

package/dist/types-Y2_Um2Ls.d.ts

@@ -0,0 +1,205 @@
+/**
+ * ClawVault Types - The elephant's memory structure
+ */
+interface VaultConfig {
+    /** Root path of the vault */
+    path: string;
+    /** Name of the vault */
+    name: string;
+    /** Categories to create on init */
+    categories: string[];
+    /** qmd collection name (defaults to vault name if not set) */
+    qmdCollection?: string;
+    /** Root path for qmd collection (defaults to vault path) */
+    qmdRoot?: string;
+    /** Custom templates path (optional) */
+    templatesPath?: string;
+}
+interface VaultMeta {
+    name: string;
+    version: string;
+    created: string;
+    lastUpdated: string;
+    categories: string[];
+    documentCount: number;
+    /** qmd collection name (defaults to vault name if not set) */
+    qmdCollection?: string;
+    /** Root path for qmd collection (defaults to vault path) */
+    qmdRoot?: string;
+}
+interface Document {
+    /** Unique ID (relative path without extension) */
+    id: string;
+    /** Full file path */
+    path: string;
+    /** Category (folder name) */
+    category: string;
+    /** Document title */
+    title: string;
+    /** Raw content */
+    content: string;
+    /** Frontmatter metadata */
+    frontmatter: Record<string, unknown>;
+    /** Extracted wiki-links [[like-this]] */
+    links: string[];
+    /** Tags extracted from content */
+    tags: string[];
+    /** Last modified timestamp */
+    modified: Date;
+}
+interface SearchResult {
+    /** Document that matched */
+    document: Document;
+    /** Relevance score (0-1) */
+    score: number;
+    /** Matching snippet */
+    snippet: string;
+    /** Which terms matched */
+    matchedTerms: string[];
+}
+interface SearchOptions {
+    /** Max results to return */
+    limit?: number;
+    /** Minimum score threshold (0-1) */
+    minScore?: number;
+    /** Filter by category */
+    category?: string;
+    /** Filter by tags */
+    tags?: string[];
+    /** Include full content in results */
+    fullContent?: boolean;
+    /** Boost recent documents in ranking */
+    temporalBoost?: boolean;
+    /**
+     * v2.7 — Enable chunk-level BM25 pre-filtering before semantic search.
+     * Chunks documents into ~600-char sentence windows and ranks chunks by
+     * keyword overlap so that relevant content deep in long documents isn't
+     * silently dropped by fixed-N embedding limits.
+     */
+    chunkPrefilter?: boolean;
+    /**
+     * v2.7 — Exhaustive threshold-based retrieval for aggregation queries.
+     * Instead of a fixed top_k, keeps pulling results until the normalised
+     * relevance score drops below this threshold (0-1).  Set to e.g. 0.01
+     * for aggregation / "list all" queries.  Overrides `limit` when set.
+     */
+    relevanceThreshold?: number;
+    /**
+     * v2.7 — Maximum results when using relevanceThreshold.
+     * Prevents runaway result sets. Default 40.
+     */
+    thresholdMaxResults?: number;
+}
+/**
+ * v2.7 — A date reference extracted from document content at ingest time.
+ */
+interface ExtractedDate {
+    /** ISO date string (YYYY-MM-DD) or "duration:<value>" */
+    date: string;
+    /** Surrounding context snippet (~150 chars) */
+    context: string;
+    /** Document id the date was extracted from */
+    documentId: string;
+}
+/**
+ * v2.7 — An extracted user preference from conversation content.
+ */
+interface ExtractedPreference {
+    /** The preference category (tool, hobby, brand, etc.) */
+    category: string;
+    /** The preference value */
+    value: string;
+    /** Document id it was extracted from */
+    documentId: string;
+    /** Surrounding context snippet */
+    context: string;
+}
+interface StoreOptions {
+    /** Category to store in */
+    category: string;
+    /** Document title (used for filename) */
+    title: string;
+    /** Content body */
+    content: string;
+    /** Frontmatter metadata */
+    frontmatter?: Record<string, unknown>;
+    /** Override existing file */
+    overwrite?: boolean;
+    /** Trigger qmd update after storing */
+    qmdUpdate?: boolean;
+    /** Trigger qmd embed after storing (implies qmdUpdate) */
+    qmdEmbed?: boolean;
+    /** Optional qmd index name override (defaults to configured/global index) */
+    qmdIndexName?: string;
+}
+interface SyncOptions {
+    /** Target directory to sync to */
+    target: string;
+    /** Delete files in target not in source */
+    deleteOrphans?: boolean;
+    /** Dry run - don't actually sync */
+    dryRun?: boolean;
+}
+interface SyncResult {
+    copied: string[];
+    deleted: string[];
+    unchanged: string[];
+    errors: string[];
+}
+type Category = 'preferences' | 'decisions' | 'rules' | 'patterns' | 'people' | 'projects' | 'goals' | 'transcripts' | 'inbox' | 'templates' | 'facts' | 'feelings' | 'lessons' | 'commitments' | 'handoffs' | string;
+declare const DEFAULT_CATEGORIES: Category[];
+/**
+ * Memory Type Taxonomy (Benthic's 8 categories)
+ * Knowing WHAT KIND of thing helps you know WHERE to put it
+ */
+type MemoryType = 'fact' | 'feeling' | 'decision' | 'lesson' | 'commitment' | 'preference' | 'relationship' | 'project';
+declare const MEMORY_TYPES: MemoryType[];
+/**
+ * Memory type to category mapping
+ */
+declare const TYPE_TO_CATEGORY: Record<MemoryType, Category>;
+/**
+ * Handoff document - bridges sessions
+ */
+interface HandoffDocument {
+    /** When this handoff was created */
+    created: string;
+    /** Session key or identifier */
+    sessionKey?: string;
+    /** What I was working on */
+    workingOn: string[];
+    /** What is currently blocked */
+    blocked: string[];
+    /** What comes next */
+    nextSteps: string[];
+    /** Emotional state/energy */
+    feeling?: string;
+    /** Key decisions made */
+    decisions?: string[];
+    /** Open questions */
+    openQuestions?: string[];
+}
+/**
+ * Session recap - who I was when I woke up
+ */
+interface SessionRecap {
+    /** When recap was generated */
+    generated: string;
+    /** Recent handoffs (last N) */
+    recentHandoffs: HandoffDocument[];
+    /** Active projects */
+    activeProjects: string[];
+    /** Pending commitments */
+    pendingCommitments: string[];
+    /** Recent decisions made */
+    recentDecisions?: string[];
+    /** Recent lessons learned */
+    recentLessons: string[];
+    /** Key relationships to remember */
+    keyRelationships: string[];
+    /** Current emotional arc */
+    emotionalArc?: string;
+}
+declare const DEFAULT_CONFIG: Partial<VaultConfig>;
+
+export { type Category as C, type Document as D, type ExtractedDate as E, type HandoffDocument as H, type MemoryType as M, type StoreOptions as S, TYPE_TO_CATEGORY as T, type VaultConfig as V, type SearchOptions as a, type SearchResult as b, type SyncOptions as c, type SyncResult as d, type SessionRecap as e, type ExtractedPreference as f, DEFAULT_CATEGORIES as g, DEFAULT_CONFIG as h, MEMORY_TYPES as i, type VaultMeta as j };

package/hooks/clawvault/handler.js

@@ -21,7 +21,7 @@ const MAX_CONTEXT_PROMPT_LENGTH = 500;
 const MAX_CONTEXT_SNIPPET_LENGTH = 220;
 const MAX_RECAP_RESULTS = 6;
 const MAX_RECAP_SNIPPET_LENGTH = 220;
-const EVENT_NAME_SEPARATOR_RE = /[.:/]/g;
+const EVENT_NAME_SEPARATOR_RE = /[._:\/-]+/g;
 const OBSERVE_CURSOR_FILE = 'observe-cursors.json';
 const ONE_KIB = 1024;
 const ONE_MIB = ONE_KIB * ONE_KIB;
@@ -178,7 +178,7 @@ function shouldObserveActiveSessions(vaultPath, agentId) {
     const sessionId = typeof value.sessionId === 'string' ? value.sessionId.trim() : '';
     if (!/^[a-zA-Z0-9._-]{1,200}$/.test(sessionId)) continue;
 
-    const filePath = path.join(sessionsDir, `${sessionId}.jsonl`);
+    let filePath = path.join(sessionsDir, `${sessionId}.jsonl`);
     let stat;
     try {
       stat = fs.statSync(filePath);
@@ -187,6 +187,27 @@ function shouldObserveActiveSessions(vaultPath, agentId) {
     }
     if (!stat.isFile()) continue;
 
+    // After /new or /reset, the main .jsonl is emptied — fall back to reset file
+    if (stat.size < 100) {
+      const resetPrefix = `${sessionId}.jsonl.reset.`;
+      try {
+        const resetFiles = fs.readdirSync(sessionsDir)
+          .filter(f => f.startsWith(resetPrefix))
+          .sort()
+          .reverse();
+        if (resetFiles.length > 0) {
+          const resetPath = path.join(sessionsDir, resetFiles[0]);
+          const resetStat = fs.statSync(resetPath);
+          if (resetStat.isFile() && resetStat.size > stat.size) {
+            filePath = resetPath;
+            stat = resetStat;
+          }
+        }
+      } catch {
+        // Ignore — use original file
+      }
+    }
+
     const fileSize = stat.size;
     const cursorEntry = cursors[sessionId];
     const previousOffset = Number.isFinite(cursorEntry?.lastObservedOffset)
@@ -366,16 +387,28 @@ function normalizeEventToken(value) {
     .trim()
     .toLowerCase()
     .replace(/\s+/g, '')
-    .replace(EVENT_NAME_SEPARATOR_RE, ':');
+    .replace(EVENT_NAME_SEPARATOR_RE, ':')
+    .replace(/^:+|:+$/g, '');
+}
+
+function collapseEventToken(value) {
+  return normalizeEventToken(value).replace(/:/g, '');
 }
 
 function eventMatches(event, type, action) {
-  const normalizedExpected = `${normalizeEventToken(type)}:${normalizeEventToken(action)}`;
+  const normalizedExpected = [normalizeEventToken(type), normalizeEventToken(action)]
+    .filter(Boolean)
+    .join(':');
+  const collapsedExpected = collapseEventToken(normalizedExpected);
   const normalizedType = normalizeEventToken(event?.type);
   const normalizedAction = normalizeEventToken(event?.action);
 
   if (normalizedType && normalizedAction) {
-    if (`${normalizedType}:${normalizedAction}` === normalizedExpected) {
+    const normalizedEventPair = `${normalizedType}:${normalizedAction}`;
+    if (
+      normalizedEventPair === normalizedExpected
+      || collapseEventToken(normalizedEventPair) === collapsedExpected
+    ) {
       return true;
     }
   }
@@ -391,7 +424,10 @@ function eventMatches(event, type, action) {
   for (const alias of aliases) {
     const normalizedAlias = normalizeEventToken(alias);
     if (!normalizedAlias) continue;
-    if (normalizedAlias === normalizedExpected) {
+    if (
+      normalizedAlias === normalizedExpected
+      || collapseEventToken(normalizedAlias) === collapsedExpected
+    ) {
       return true;
     }
   }
@@ -402,6 +438,7 @@ function eventMatches(event, type, action) {
 function eventIncludesToken(event, token) {
   const normalizedToken = normalizeEventToken(token);
   if (!normalizedToken) return false;
+  const collapsedToken = collapseEventToken(normalizedToken);
 
   const values = [
     event?.type,
@@ -416,7 +453,12 @@ function eventIncludesToken(event, token) {
   return values
     .map((value) => normalizeEventToken(value))
     .filter(Boolean)
-    .some((value) => value.includes(normalizedToken));
+    .some((value) => {
+      if (value.includes(normalizedToken)) {
+        return true;
+      }
+      return collapseEventToken(value).includes(collapsedToken);
+    });
 }
 
 // Validate vault path - must be absolute and exist
@@ -450,6 +492,14 @@ function findVaultPath() {
   if (process.env.CLAWVAULT_PATH) {
     return validateVaultPath(process.env.CLAWVAULT_PATH);
   }
+  const configuredCandidates = [
+    process.env.OPENCLAW_MEMORY_PATH,
+    process.env.OPENCLAW_VAULT_PATH
+  ];
+  for (const candidate of configuredCandidates) {
+    const validated = validateVaultPath(candidate);
+    if (validated) return validated;
+  }
 
   // Walk up from cwd
   let dir = process.cwd();
@@ -466,6 +516,19 @@ function findVaultPath() {
     
     dir = path.dirname(dir);
   }
+
+  // Canonical local-first defaults for OpenClaw users.
+  const homeDir = normalizeAbsoluteEnvPath(process.env.HOME) || os.homedir();
+  const homeCandidates = [
+    path.join(homeDir, 'memory'),
+    path.join(homeDir, 'Memory'),
+    path.join(homeDir, 'vault'),
+    path.join(homeDir, 'Vault')
+  ];
+  for (const candidate of homeCandidates) {
+    const validated = validateVaultPath(candidate);
+    if (validated) return validated;
+  }
   
   return null;
 }

package/hooks/clawvault/handler.test.js

@@ -46,6 +46,8 @@ async function loadHandler() {
 afterEach(() => {
   vi.clearAllMocks();
   delete process.env.CLAWVAULT_PATH;
+  delete process.env.OPENCLAW_MEMORY_PATH;
+  delete process.env.OPENCLAW_VAULT_PATH;
   delete process.env.OPENCLAW_STATE_DIR;
   delete process.env.OPENCLAW_HOME;
   delete process.env.OPENCLAW_AGENT_ID;
@@ -105,6 +107,28 @@ describe('clawvault hook handler', () => {
     fs.rmSync(vaultPath, { recursive: true, force: true });
   });
 
+  it('supports slash-prefixed command actions for /new', async () => {
+    const vaultPath = makeVaultFixture();
+    process.env.CLAWVAULT_PATH = vaultPath;
+    execFileSyncMock.mockReturnValue('');
+
+    const handler = await loadHandler();
+    await handler({
+      type: 'command',
+      action: '/new',
+      sessionKey: 'agent:clawdious:main',
+      context: { commandSource: 'slash' }
+    });
+
+    expect(execFileSyncMock).toHaveBeenCalledWith(
+      'clawvault',
+      expect.arrayContaining(['checkpoint', '--working-on']),
+      expect.objectContaining({ shell: false })
+    );
+
+    fs.rmSync(vaultPath, { recursive: true, force: true });
+  });
+
   it('injects recap and memory context on session start alias event', async () => {
     const vaultPath = makeVaultFixture();
     process.env.CLAWVAULT_PATH = vaultPath;
@@ -241,6 +265,73 @@ describe('clawvault hook handler', () => {
     fs.rmSync(vaultPath, { recursive: true, force: true });
   });
 
+  it('supports compaction action separator variants', async () => {
+    const vaultPath = makeVaultFixture();
+    process.env.CLAWVAULT_PATH = vaultPath;
+    execFileSyncMock.mockReturnValue('');
+
+    const handler = await loadHandler();
+    await handler({
+      type: 'compaction',
+      action: 'memory_flush',
+      sessionKey: 'agent:clawdious:main'
+    });
+
+    expect(execFileSyncMock).toHaveBeenCalledWith(
+      'clawvault',
+      expect.arrayContaining(['observe', '--cron', '--min-new', '1']),
+      expect.objectContaining({ shell: false })
+    );
+
+    fs.rmSync(vaultPath, { recursive: true, force: true });
+  });
+
+  it('discovers canonical ~/memory vault when env and cwd do not provide one', async () => {
+    const fakeHome = fs.mkdtempSync(path.join(os.tmpdir(), 'clawvault-home-'));
+    const vaultPath = path.join(fakeHome, 'memory');
+    fs.mkdirSync(vaultPath, { recursive: true });
+    fs.writeFileSync(path.join(vaultPath, '.clawvault.json'), JSON.stringify({ name: 'home' }), 'utf-8');
+    const originalHome = process.env.HOME;
+    const originalClawvaultPath = process.env.CLAWVAULT_PATH;
+    const originalOpenclawMemory = process.env.OPENCLAW_MEMORY_PATH;
+    const originalOpenclawVault = process.env.OPENCLAW_VAULT_PATH;
+    process.env.HOME = fakeHome;
+    delete process.env.CLAWVAULT_PATH;
+    delete process.env.OPENCLAW_MEMORY_PATH;
+    delete process.env.OPENCLAW_VAULT_PATH;
+    // Mock cwd to a temp dir without a vault so walk-up doesn't find one
+    const fakeCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'clawvault-cwd-'));
+    const originalCwd = process.cwd;
+    process.cwd = () => fakeCwd;
+    try {
+      execFileSyncMock.mockReturnValue('');
+
+      const handler = await loadHandler();
+      await handler({
+        eventName: 'compaction:memoryFlush',
+        sessionKey: 'agent:main:main'
+      });
+
+      expect(execFileSyncMock).toHaveBeenCalledWith(
+        'clawvault',
+        expect.arrayContaining(['observe', '--cron', '-v', vaultPath]),
+        expect.objectContaining({ shell: false })
+      );
+    } finally {
+      if (originalHome === undefined) {
+        delete process.env.HOME;
+      } else {
+        process.env.HOME = originalHome;
+      }
+      if (originalClawvaultPath !== undefined) process.env.CLAWVAULT_PATH = originalClawvaultPath;
+      if (originalOpenclawMemory !== undefined) process.env.OPENCLAW_MEMORY_PATH = originalOpenclawMemory;
+      if (originalOpenclawVault !== undefined) process.env.OPENCLAW_VAULT_PATH = originalOpenclawVault;
+      process.cwd = originalCwd;
+      fs.rmSync(fakeHome, { recursive: true, force: true });
+      fs.rmSync(fakeCwd, { recursive: true, force: true });
+    }
+  });
+
   it('runs weekly reflection on cron.weekly at Sunday midnight', async () => {
     const vaultPath = makeVaultFixture();
     process.env.CLAWVAULT_PATH = vaultPath;