hippo-memory 1.68.0 → 1.70.0

package/dist/hooks/opencode.js

@@ -1,7 +1,8 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { isJsonObject, homeDir } from './shared.js';
-import { isJsonString } from '../json.js';
+import { homeDir } from './shared.js';
+import { writeFileAtomic } from '../util/atomic-write.js';
+import { isJsonString, isJsonObjectLiteral } from '../util/json.js';
 const HIPPO_OPENCODE_PLUGIN_MARKER = 'HIPPO_OPENCODE_PLUGIN_V1';
 /**
  * The opencode plugin file we install at ~/.config/opencode/plugins/hippo.ts.
@@ -91,7 +92,7 @@ function resolveOpencodeConfigPath() {
  */
 const HIPPO_OWNED_COMMAND_RE = /^\s*hippo\s+(session-end|last-sleep|sleep|capture|context)(?=\s|$)/;
 function hookIsHippoOwned(hook) {
-    if (!isJsonObject(hook))
+    if (!isJsonObjectLiteral(hook))
         return false;
     const cmd = hook.command;
     return isJsonString(cmd) && HIPPO_OWNED_COMMAND_RE.test(cmd);
@@ -127,7 +128,7 @@ function migrateLegacyOpencodeHooksBlock() {
     const hooks = settings.hooks;
     // Non-object hooks values (string, array, null) are user content we don't
     // recognise — leave them alone, return migrated=false.
-    if (!isJsonObject(hooks)) {
+    if (!isJsonObjectLiteral(hooks)) {
         return { migrated: false, jsonRepairFailed: false };
     }
     const hooksObj = hooks;
@@ -135,26 +136,9 @@ function migrateLegacyOpencodeHooksBlock() {
     for (const key of Object.keys(hooksObj)) {
         if (!Array.isArray(hooksObj[key]))
             continue;
-        const survivingEntries = [];
-        for (const entry of hooksObj[key]) {
-            if (!isJsonObject(entry)) {
-                survivingEntries.push(entry);
-                continue;
-            }
-            const innerHooks = entry.hooks;
-            if (!Array.isArray(innerHooks)) {
-                survivingEntries.push(entry);
-                continue;
-            }
-            const beforeInner = innerHooks.length;
-            const survivingInner = innerHooks.filter((h) => !hookIsHippoOwned(h));
-            if (survivingInner.length !== beforeInner)
-                changed = true;
-            if (survivingInner.length === 0)
-                continue; // drop entry, nothing left
-            entry.hooks = survivingInner;
-            survivingEntries.push(entry);
-        }
+        const { survivingEntries, strippedAny } = stripHippoHooksFromEntries(hooksObj[key]);
+        if (strippedAny)
+            changed = true;
         if (survivingEntries.length !== hooksObj[key].length)
             changed = true;
         hooksObj[key] = survivingEntries;
@@ -165,9 +149,34 @@ function migrateLegacyOpencodeHooksBlock() {
         return { migrated: false, jsonRepairFailed: false };
     if (Object.keys(hooksObj).length === 0)
         delete settings.hooks;
-    fs.writeFileSync(configPath, JSON.stringify(settings, null, 2) + '\n', 'utf8');
+    writeFileAtomic(configPath, JSON.stringify(settings, null, 2) + '\n');
     return { migrated: true, jsonRepairFailed: false };
 }
+/** One event's entries with every hippo-owned hook taken out, and whether any was. */
+function stripHippoHooksFromEntries(entries) {
+    const survivingEntries = [];
+    let strippedAny = false;
+    for (const entry of entries) {
+        if (!isJsonObjectLiteral(entry)) {
+            survivingEntries.push(entry);
+            continue;
+        }
+        const innerHooks = entry.hooks;
+        if (!Array.isArray(innerHooks)) {
+            survivingEntries.push(entry);
+            continue;
+        }
+        const beforeInner = innerHooks.length;
+        const survivingInner = innerHooks.filter((h) => !hookIsHippoOwned(h));
+        if (survivingInner.length !== beforeInner)
+            strippedAny = true;
+        if (survivingInner.length === 0)
+            continue; // drop entry, nothing left
+        entry.hooks = survivingInner;
+        survivingEntries.push(entry);
+    }
+    return { survivingEntries, strippedAny };
+}
 export function installOpencodePlugin() {
     const pluginPath = resolveOpencodePluginPath();
     const { migrated, jsonRepairFailed } = migrateLegacyOpencodeHooksBlock();
@@ -181,8 +190,7 @@ export function installOpencodePlugin() {
             return { installed: false, pluginPath, migratedLegacyHooks: migrated, jsonRepairFailed };
         }
     }
-    fs.mkdirSync(path.dirname(pluginPath), { recursive: true });
-    fs.writeFileSync(pluginPath, OPENCODE_PLUGIN_SOURCE, 'utf8');
+    writeFileAtomic(pluginPath, OPENCODE_PLUGIN_SOURCE);
     return { installed: true, pluginPath, migratedLegacyHooks: migrated, jsonRepairFailed };
 }
 export function uninstallOpencodePlugin() {

package/dist/hooks/shared.d.ts

@@ -1,7 +1,3 @@
-import type { JsonObject } from '../working-memory.js';
-import type { JsonValue } from '../json.js';
-/** JSON-value plain-object check (excludes arrays and null); `constructor` avoids the `typeof` tag banned by anti-slop/no-runtime-typeof. */
-export declare function isJsonObject(value: JsonValue | undefined): value is JsonObject;
 export type JsonHookTarget = 'claude-code' | 'codex' | 'copilot';
 export interface ToolDetection {
     name: string;
@@ -30,7 +26,13 @@ export declare function copilotHomeDir(home?: string, env?: Readonly<Record<stri
 export declare function claudeConfigDir(home?: string, env?: Readonly<Record<string, string | undefined>>): string;
 /** Codex counts as installed only when its config folder exists: Codex itself refuses a CODEX_HOME that is not a folder. */
 export declare function isCodexPresent(home?: string): boolean;
-/** Copilot counts as installed only when its config folder exists, so setup never creates ~/.copilot on a machine without it. */
+/** hippo's own hooks file, in the hooks folder the Copilot CLI reads. */
+export declare function copilotHooksFile(): string;
+/** Where VS Code's agent finds hippo.json: its docs name ~/.copilot/hooks as the user hooks folder, whatever COPILOT_HOME says. */
+export declare function vscodeUserHooksFile(home?: string): string;
+/** The VS Code User folders that exist; Stable and Insiders keep their own, and only an edition the user has run has one. */
+export declare function vscodeUserDirs(env?: Readonly<Record<string, string | undefined>>, home?: string): string[];
+/** Copilot counts as installed only when its config folder or a VS Code User folder exists, so setup never creates ~/.copilot on a machine with neither. */
 export declare function isCopilotPresent(home?: string): boolean;
 /** Codex hashes each hook and skips new or changed ones until the user reviews them in `/hooks`, so the reminder says what they would trust. */
 export declare const CODEX_TRUST_LINE = "The per-prompt hook sends your pinned memories plus up to 5 that match the prompt. Codex runs hippo's hooks only after you trust them once in `/hooks`.";

package/dist/hooks/shared.js

@@ -1,11 +1,8 @@
-import { envHomeDir, processEnv } from '../env.js';
+import { envHomeDir, processEnv } from '../util/env.js';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
-/** JSON-value plain-object check (excludes arrays and null); `constructor` avoids the `typeof` tag banned by anti-slop/no-runtime-typeof. */
-export function isJsonObject(value) {
-    return value !== undefined && value !== null && !Array.isArray(value) && value.constructor === Object;
-}
+import { vscodeDataFolders } from '../agent-memories/copilot.js';
 export const HIPPO_SLEEP_MARKER = 'hippo sleep';
 export const HIPPO_LAST_SLEEP_MARKER = 'hippo last-sleep';
 export const HIPPO_CAPTURE_MARKER = 'hippo capture --last-session';
@@ -36,9 +33,23 @@ export function claudeConfigDir(home = os.homedir(), env = processEnv()) {
 export function isCodexPresent(home = homeDir()) {
     return fs.statSync(codexHomeDir(home), { throwIfNoEntry: false })?.isDirectory() === true;
 }
-/** Copilot counts as installed only when its config folder exists, so setup never creates ~/.copilot on a machine without it. */
+/** hippo's own hooks file, in the hooks folder the Copilot CLI reads. */
+export function copilotHooksFile() {
+    return path.join(copilotHomeDir(), 'hooks', 'hippo.json');
+}
+/** Where VS Code's agent finds hippo.json: its docs name ~/.copilot/hooks as the user hooks folder, whatever COPILOT_HOME says. */
+export function vscodeUserHooksFile(home = os.homedir()) {
+    return path.join(home, '.copilot', 'hooks', 'hippo.json');
+}
+/** The VS Code User folders that exist; Stable and Insiders keep their own, and only an edition the user has run has one. */
+export function vscodeUserDirs(env = processEnv(), home = os.homedir()) {
+    return vscodeDataFolders({ env, home, platform: process.platform })
+        .map((dir) => path.join(dir, 'User'))
+        .filter((dir) => fs.statSync(dir, { throwIfNoEntry: false })?.isDirectory() === true);
+}
+/** Copilot counts as installed only when its config folder or a VS Code User folder exists, so setup never creates ~/.copilot on a machine with neither. */
 export function isCopilotPresent(home = os.homedir()) {
-    return fs.statSync(copilotHomeDir(home), { throwIfNoEntry: false })?.isDirectory() === true;
+    return fs.statSync(copilotHomeDir(home), { throwIfNoEntry: false })?.isDirectory() === true || vscodeUserDirs(processEnv(), home).length > 0;
 }
 /** Codex hashes each hook and skips new or changed ones until the user reviews them in `/hooks`, so the reminder says what they would trust. */
 export const CODEX_TRUST_LINE = "The per-prompt hook sends your pinned memories plus up to 5 that match the prompt. Codex runs hippo's hooks only after you trust them once in `/hooks`.";
@@ -76,7 +87,7 @@ export function detectInstalledTools() {
         { name: 'opencode', configDir: '~/.config/opencode', detected: exists('.config', 'opencode'), kind: 'plugin', notes: 'installs a TS plugin at ~/.config/opencode/plugins/hippo.ts' },
         { name: 'openclaw', configDir: '~/.openclaw', detected: exists('.openclaw'), kind: 'plugin', notes: 'install via `openclaw plugins install hippo-memory`' },
         { name: 'codex', configDir: '~/.codex', detected: isCodexPresent(home), kind: 'wrapper', notes: 'memory hooks in hooks.json, and wraps the detected codex launcher for session-end consolidation' },
-        { name: 'copilot', configDir: copilotHomeDir(), detected: isCopilotPresent(), kind: 'json-hook', notes: 'hooks in hooks/hippo.json, the MCP server in mcp-config.json and a block in copilot-instructions.md' },
+        { name: 'copilot', configDir: copilotHomeDir(), detected: isCopilotPresent(), kind: 'json-hook', notes: 'hooks in hooks/hippo.json, the MCP server in mcp-config.json and a block in copilot-instructions.md; for VS Code, the server in each User mcp.json and prompts/hippo.instructions.md' },
         { name: 'cursor', configDir: '~/.cursor', detected: exists('.cursor'), kind: 'markdown-instruction', notes: 'no hook API - patches AGENTS.md in the project' },
         { name: 'pi', configDir: '~/.pi', detected: exists('.pi'), kind: 'markdown-instruction', notes: 'no hook API - patches AGENTS.md in the project' },
     ];

package/dist/importers/core.d.ts

@@ -2,8 +2,7 @@
  * Memory importers for Hippo.
  * Imports memories from ChatGPT, Claude, Cursor, generic files, and structured markdown.
  */
-import { MemoryEntry } from '../memory.js';
-import type { JsonValue } from '../json.js';
+import { MemoryEntry } from '../core/memory.js';
 export interface ImportResult {
     total: number;
     imported: number;
@@ -45,7 +44,7 @@ export interface ImportOptions {
      * sharing a basename would collide and clobber each other). importVault throws
      * if it is missing or blank. Optional in this shared type only because the
      * other importers ignore it. Operator-supplied, so the loader query LIKE-escapes
-     * it (`escapeLike` in src/escape.ts).
+     * it (`escapeLike` in src/util/escape.ts).
      */
     name?: string;
     /**
@@ -59,7 +58,4 @@ export interface ImportOptions {
  * create MemoryEntry objects, write them (unless dry-run), and return a result.
  */
 export declare function importEntries(chunks: string[], source: string, tags: string[], options: ImportOptions): ImportResult;
-export declare function isJsonPlainObject(x: JsonValue): x is {
-    [key: string]: JsonValue;
-};
 //# sourceMappingURL=core.d.ts.map

package/dist/importers/core.js

@@ -2,17 +2,17 @@
  * Memory importers for Hippo.
  * Imports memories from ChatGPT, Claude, Cursor, generic files, and structured markdown.
  */
-import { createMemory, Layer } from '../memory.js';
-import { writeEntryOn } from '../store/entry-writes.js';
-import { openStore } from '../store/open.js';
+import { createMemory, Layer } from '../core/memory.js';
+import { writeEntry } from '../store/entry-writes.js';
 import { loadAllEntries } from '../store/entry-reads.js';
-import { duplicateKey, storedTextKeys } from '../same-text.js';
-import { getGlobalRoot, initGlobal } from '../shared.js';
-import { openHippoDb, closeHippoDb } from '../db.js';
-import { RejectedValueError, checkRejectionGuard } from '../rejection.js';
-import { loadConfig } from '../config.js';
-import { vetSecrets } from '../secret-detect.js';
-import { log } from '../log.js';
+import { duplicateKey, storedTextKeys } from '../util/same-text.js';
+import { getGlobalRoot, initGlobal } from '../sharing/shared.js';
+import { withRequestStoresSync } from '../db/request-stores.js';
+import { RejectedValueError } from '../store/rejection.js';
+import { rejectionGuardRefuses } from '../store/rejected-values.js';
+import { loadConfig } from '../core/config.js';
+import { vetSecrets } from '../util/secret-detect.js';
+import { log } from '../util/log.js';
 // ---------------------------------------------------------------------------
 // Shared core: dedup + write
 // ---------------------------------------------------------------------------
@@ -21,12 +21,7 @@ import { log } from '../log.js';
  * create MemoryEntry objects, write them (unless dry-run), and return a result.
  */
 export function importEntries(chunks, source, tags, options) {
-    const targetRoot = options.global ? getGlobalRoot() : options.hippoRoot;
-    // Ensure store is ready
-    if (options.global) {
-        initGlobal();
-    }
-    const keys = storedTextKeys(loadAllEntries(targetRoot, options.global ? undefined : options.tenantId));
+    const { targetRoot, keys } = openImportTarget(options);
     const allTags = [...new Set([...tags, ...(options.extraTags ?? [])])];
     const baseHalfLifeDays = loadConfig(targetRoot).defaultHalfLifeDays;
     let total = 0;
@@ -35,24 +30,19 @@ export function importEntries(chunks, source, tags, options) {
     let rejected = 0;
     let redacted = 0;
     const entries = [];
-    // A dry run probes the rejection guard read-only; a real run writes every chunk on this one handle.
-    const db = options.dryRun ? openHippoDb(targetRoot) : openStore(targetRoot);
-    try {
+    // One scope, so the store opens once however many chunks land: each write, or a dry run's guard probe, shares its handle.
+    return withRequestStoresSync(() => {
         for (const raw of chunks) {
             const { chunk, wasRedacted } = prepareImportChunk(raw, allTags);
-            // Skip empty or too-short chunks
-            if (!chunk || chunk.length < 10) {
-                skipped++;
-                continue;
-            }
-            total++;
-            // Dedup check: skip only when the same text is already stored
-            if (keys.has(duplicateKey(chunk))) {
+            const skip = skipReason(chunk, keys);
+            if (skip !== 'too-short')
+                total++;
+            if (skip !== null) {
                 skipped++;
                 continue;
             }
             const entry = createImportEntry(chunk, source, allTags, options, baseHalfLifeDays);
-            if (!writeOrProbeImport(db, targetRoot, entry, options)) {
+            if (!writeOrProbeImport(targetRoot, entry, options)) {
                 rejected++;
                 continue;
             }
@@ -65,10 +55,26 @@ export function importEntries(chunks, source, tags, options) {
                 redacted++;
         }
         return { total, imported, skipped, rejected, redacted, entries };
+    });
+}
+/** The store the import writes to, made ready, with the text keys it already holds. */
+function openImportTarget(options) {
+    const targetRoot = options.global ? getGlobalRoot() : options.hippoRoot;
+    // Ensure store is ready
+    if (options.global) {
+        initGlobal();
     }
-    finally {
-        closeHippoDb(db);
-    }
+    const keys = storedTextKeys(loadAllEntries(targetRoot, options.global ? undefined : options.tenantId));
+    return { targetRoot, keys };
+}
+function skipReason(chunk, keys) {
+    // Skip empty or too-short chunks
+    if (!chunk || chunk.length < 10)
+        return 'too-short';
+    // Dedup check: skip only when the same text is already stored
+    if (keys.has(duplicateKey(chunk)))
+        return 'duplicate';
+    return null;
 }
 /** The secret-vetted chunk capped at 1000 chars, and whether vetting changed it. */
 function prepareImportChunk(raw, allTags) {
@@ -102,13 +108,12 @@ function createImportEntry(chunk, source, allTags, options, baseHalfLifeDays) {
     });
 }
 /** Writes the entry, or on a dry run only probes the guard; false when a rejected value refuses it. */
-function writeOrProbeImport(db, targetRoot, entry, options) {
+function writeOrProbeImport(targetRoot, entry, options) {
+    if (options.dryRun)
+        return !rejectionGuardRefuses(targetRoot, entry.tenantId ?? 'default', entry.id, entry.content);
     // A rejection refuses one chunk, not the whole import, so siblings still land.
     try {
-        if (options.dryRun)
-            checkRejectionGuard(db, entry.tenantId ?? 'default', entry.id, entry.content);
-        else
-            writeEntryOn(db, targetRoot, entry);
+        writeEntry(targetRoot, entry);
     }
     catch (err) {
         if (err instanceof RejectedValueError)
@@ -120,7 +125,4 @@ function writeOrProbeImport(db, targetRoot, entry, options) {
 // ---------------------------------------------------------------------------
 // ChatGPT importer
 // ---------------------------------------------------------------------------
-export function isJsonPlainObject(x) {
-    return x !== null && !Array.isArray(x) && typeof x === 'object';
-}
 //# sourceMappingURL=core.js.map

package/dist/importers/markdown-parse.d.ts

@@ -6,7 +6,7 @@ interface FrontmatterParseResult {
     fm: Record<string, string>;
     body: string;
 }
-export declare function parseFrontmatter(raw: string): FrontmatterParseResult;
+export declare function splitMarkdownFrontmatter(raw: string): FrontmatterParseResult;
 /** Pull a frontmatter field that may be a YAML flow list (`[a, b]`), a
  *  comma-separated scalar (`a, b`), or a single token, into a string[]. Quotes
  *  and surrounding brackets are stripped; empty entries dropped. */
@@ -28,14 +28,5 @@ export declare function parseWikilinks(body: string): string[];
  *  importVault (a no-op early return), NOT here: returning [] for it would feed
  *  the deletion-sync an empty scan that mass-archives every live row (codex R8). */
 export declare function collectMarkdownFiles(root: string, hippoRoot: string, match?: RegExp): string[];
-/** Canonicalize a path for the self-store comparison: dereference symlinks /
- *  junctions and normalize case (Windows) via the OS realpath, so a junction or
- *  a case-variant path to the store is still recognized as self-store (codex R9
- *  P2: path.resolve does neither, so an aliased store path slipped past the
- *  guard and triggered the mass-archive). Falls back to path.resolve when the
- *  path does not exist yet - an uninitialized store or a typo'd vault path
- *  cannot be a live self-store, and a non-existent vault folder fails later in
- *  the walk (readdirSync) before deletion-sync can archive anything. */
-export declare function realpathOrResolve(p: string): string;
 export {};
 //# sourceMappingURL=markdown-parse.d.ts.map

package/dist/importers/markdown-parse.js

@@ -1,7 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { log } from '../log.js';
-export function parseFrontmatter(raw) {
+import { realpathOrResolve } from '../util/real-path.js';
+export function splitMarkdownFrontmatter(raw) {
     // Must start with `---` on its own line. Accept CRLF or LF.
     const m = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
     if (!m)
@@ -112,21 +112,4 @@ export function collectMarkdownFiles(root, hippoRoot, match = /\.md$/i) {
     out.sort();
     return out;
 }
-/** Canonicalize a path for the self-store comparison: dereference symlinks /
- *  junctions and normalize case (Windows) via the OS realpath, so a junction or
- *  a case-variant path to the store is still recognized as self-store (codex R9
- *  P2: path.resolve does neither, so an aliased store path slipped past the
- *  guard and triggered the mass-archive). Falls back to path.resolve when the
- *  path does not exist yet - an uninitialized store or a typo'd vault path
- *  cannot be a live self-store, and a non-existent vault folder fails later in
- *  the walk (readdirSync) before deletion-sync can archive anything. */
-export function realpathOrResolve(p) {
-    try {
-        return fs.realpathSync.native(p);
-    }
-    catch (err) {
-        log.debug(`import: realpath fell back to resolve for ${p}: ${err instanceof Error ? err.message : String(err)}`);
-        return path.resolve(p);
-    }
-}
 //# sourceMappingURL=markdown-parse.js.map

package/dist/importers/markdown.js

@@ -1,5 +1,6 @@
 import * as fs from 'fs';
 import { importEntries } from './core.js';
+const SLUG_MAX_CHARS = 50;
 // ---------------------------------------------------------------------------
 // Structured markdown importer (MEMORY.md / AGENTS.md format)
 // ---------------------------------------------------------------------------
@@ -14,7 +15,7 @@ function slugify(heading) {
         .trim()
         .replace(/\s+/g, '-')
         .replace(/-+/g, '-')
-        .slice(0, 50);
+        .slice(0, SLUG_MAX_CHARS);
 }
 /**
  * Parse structured markdown into {content, sectionSlug} pairs.

package/dist/importers/sources.js

@@ -1,14 +1,14 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { importEntries, isJsonPlainObject } from './core.js';
-import { parseFrontmatter, collectMarkdownFiles } from './markdown-parse.js';
-import { isJsonString } from '../json.js';
+import { importEntries } from './core.js';
+import { splitMarkdownFrontmatter, collectMarkdownFiles } from './markdown-parse.js';
+import { isJsonString, isJsonObject } from '../util/json.js';
 /** Coerce one imported record (string, `{content|text: ...}` object, or
  *  anything else) into the plain-text memory chunk it represents. */
 function extractMemoryText(candidate) {
     if (isJsonString(candidate))
         return candidate;
-    if (isJsonPlainObject(candidate)) {
+    if (isJsonObject(candidate)) {
         return String(candidate['content'] ?? candidate['text'] ?? '');
     }
     return '';
@@ -28,7 +28,7 @@ function parseChatGPTFile(filePath) {
         try {
             const parsed = JSON.parse(raw);
             // {"memories": [...]} - ChatGPT export format
-            if (isJsonPlainObject(parsed) && Array.isArray(parsed.memories)) {
+            if (isJsonObject(parsed) && Array.isArray(parsed.memories)) {
                 return parsed.memories.map(extractMemoryText).filter(Boolean);
             }
             // Array format
@@ -69,51 +69,55 @@ function splitMarkdown(content) {
     const chunks = [];
     const lines = content.split('\n');
     let current = '';
-    for (const line of lines) {
-        const trimmed = line.trim();
-        // Heading: start a new chunk
-        if (/^#{1,6}\s+/.test(trimmed)) {
-            if (current.trim())
-                chunks.push(current.trim());
-            current = trimmed;
-            continue;
+    for (const line of lines)
+        current = appendLine(chunks, current, line);
+    if (current.trim())
+        chunks.push(current.trim());
+    return chunks.filter(Boolean);
+}
+/** Takes one line into the chunk being built, pushing that chunk when the line ends it; returns the chunk still open. */
+function appendLine(chunks, open, line) {
+    let current = open;
+    const trimmed = line.trim();
+    // Heading: start a new chunk
+    if (/^#{1,6}\s+/.test(trimmed)) {
+        if (current.trim())
+            chunks.push(current.trim());
+        current = trimmed;
+        return current;
+    }
+    // Bullet point: each bullet is its own chunk (flush previous if not a bullet context)
+    if (/^[-*+]\s+/.test(trimmed)) {
+        if (current.trim() && !/^[-*+]\s+/.test(current.split('\n')[0])) {
+            chunks.push(current.trim());
+            current = '';
         }
-        // Bullet point: each bullet is its own chunk (flush previous if not a bullet context)
-        if (/^[-*+]\s+/.test(trimmed)) {
-            if (current.trim() && !/^[-*+]\s+/.test(current.split('\n')[0])) {
-                chunks.push(current.trim());
-                current = '';
-            }
-            if (current.trim()) {
-                chunks.push(current.trim());
-                current = '';
-            }
-            current = trimmed.replace(/^[-*+]\s+/, '').trim();
-            continue;
+        if (current.trim()) {
+            chunks.push(current.trim());
+            current = '';
         }
-        // Numbered list item
-        if (/^\d+\.\s+/.test(trimmed)) {
-            if (current.trim()) {
-                chunks.push(current.trim());
-                current = '';
-            }
-            current = trimmed.replace(/^\d+\.\s+/, '').trim();
-            continue;
+        current = trimmed.replace(/^[-*+]\s+/, '').trim();
+        return current;
+    }
+    // Numbered list item
+    if (/^\d+\.\s+/.test(trimmed)) {
+        if (current.trim()) {
+            chunks.push(current.trim());
+            current = '';
         }
-        // Empty line
-        if (!trimmed) {
-            if (current.trim()) {
-                chunks.push(current.trim());
-                current = '';
-            }
-            continue;
+        current = trimmed.replace(/^\d+\.\s+/, '').trim();
+        return current;
+    }
+    // Empty line
+    if (!trimmed) {
+        if (current.trim()) {
+            chunks.push(current.trim());
+            current = '';
         }
-        // Regular line: append to current
-        current = current ? current + ' ' + trimmed : trimmed;
+        return current;
     }
-    if (current.trim())
-        chunks.push(current.trim());
-    return chunks.filter(Boolean);
+    // Regular line: append to current
+    return current ? current + ' ' + trimmed : trimmed;
 }
 /**
  * Parse CLAUDE.md or Claude memory.json.
@@ -198,7 +202,7 @@ export function importCursor(sourcePath, options) {
         : [sourcePath];
     const chunks = files.flatMap((file) => {
         const raw = fs.readFileSync(file, 'utf8');
-        return parseCursorFile(CURSOR_RULE_FILE.test(file) ? parseFrontmatter(raw).body : raw);
+        return parseCursorFile(CURSOR_RULE_FILE.test(file) ? splitMarkdownFrontmatter(raw).body : raw);
     });
     return importEntries(chunks, 'import:cursor', ['imported', 'cursor'], options);
 }