hippo-memory 1.60.0 → 1.61.0

package/dist/importers/sources.js

@@ -0,0 +1,229 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { importEntries, isJsonString, isJsonPlainObject } from './core.js';
+import { parseFrontmatter, collectMarkdownFiles } from './markdown-parse.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)) {
+        return String(candidate['content'] ?? candidate['text'] ?? '');
+    }
+    return '';
+}
+/**
+ * Parse ChatGPT memory export file.
+ * Supports:
+ *   - JSON array of strings: ["memory 1", "memory 2"]
+ *   - JSON array of objects: [{"content": "...", "created": "..."}]
+ *   - ChatGPT export format: {"memories": [{"content": "...", "created_at": "..."}]}
+ *   - Plain text: one memory per line
+ */
+function parseChatGPTFile(filePath) {
+    const raw = fs.readFileSync(filePath, 'utf8').trim();
+    // Try JSON first
+    if (raw.startsWith('[') || raw.startsWith('{')) {
+        try {
+            const parsed = JSON.parse(raw);
+            // {"memories": [...]} - ChatGPT export format
+            if (isJsonPlainObject(parsed) && Array.isArray(parsed.memories)) {
+                return parsed.memories.map(extractMemoryText).filter(Boolean);
+            }
+            // Array format
+            if (Array.isArray(parsed)) {
+                return parsed.map(extractMemoryText).filter(Boolean);
+            }
+        }
+        catch {
+            // Fall through to plain text
+        }
+    }
+    // Plain text: one memory per line
+    return raw.split('\n').map((l) => l.trim()).filter(Boolean);
+}
+export function importChatGPT(filePath, options) {
+    const chunks = parseChatGPTFile(filePath);
+    return importEntries(chunks, 'import:chatgpt', ['imported', 'chatgpt'], options);
+}
+// ---------------------------------------------------------------------------
+// Claude importer
+// ---------------------------------------------------------------------------
+const HIPPO_START = '<!-- hippo:start -->';
+const HIPPO_END = '<!-- hippo:end -->';
+/**
+ * Strip the hippo hook block from markdown content.
+ */
+function stripHippoBlock(content) {
+    const startIdx = content.indexOf(HIPPO_START);
+    const endIdx = content.indexOf(HIPPO_END);
+    if (startIdx === -1 || endIdx === -1)
+        return content;
+    return content.slice(0, startIdx) + content.slice(endIdx + HIPPO_END.length);
+}
+/**
+ * Split markdown into meaningful chunks (headings + bullet points).
+ */
+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;
+        }
+        // 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;
+        }
+        // Numbered list item
+        if (/^\d+\.\s+/.test(trimmed)) {
+            if (current.trim()) {
+                chunks.push(current.trim());
+                current = '';
+            }
+            current = trimmed.replace(/^\d+\.\s+/, '').trim();
+            continue;
+        }
+        // Empty line
+        if (!trimmed) {
+            if (current.trim()) {
+                chunks.push(current.trim());
+                current = '';
+            }
+            continue;
+        }
+        // Regular line: append to current
+        current = current ? current + ' ' + trimmed : trimmed;
+    }
+    if (current.trim())
+        chunks.push(current.trim());
+    return chunks.filter(Boolean);
+}
+/**
+ * Parse CLAUDE.md or Claude memory.json.
+ */
+function parseClaudeFile(filePath) {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    // JSON memory file
+    if (filePath.endsWith('.json')) {
+        try {
+            const parsed = JSON.parse(raw.trim());
+            if (Array.isArray(parsed)) {
+                return parsed.map(extractMemoryText).filter(Boolean);
+            }
+        }
+        catch {
+            // Fall through to markdown
+        }
+    }
+    // Markdown file: strip hippo block and split
+    const cleaned = stripHippoBlock(raw);
+    return splitMarkdown(cleaned);
+}
+export function importClaude(filePath, options) {
+    const chunks = parseClaudeFile(filePath);
+    return importEntries(chunks, 'import:claude', ['imported', 'claude'], options);
+}
+// ---------------------------------------------------------------------------
+// Cursor importer
+// ---------------------------------------------------------------------------
+/**
+ * Split cursor rules file into chunks.
+ * Priority: numbered items, then bullet points, then double newlines.
+ */
+function parseCursorFile(content) {
+    const chunks = [];
+    const lines = content.split('\n');
+    let current = '';
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip comment-only lines that are empty after stripping #
+        if (!trimmed || trimmed === '#') {
+            if (current.trim()) {
+                chunks.push(current.trim());
+                current = '';
+            }
+            continue;
+        }
+        // Numbered item: 1. 2. 3.
+        if (/^\d+\.\s+/.test(trimmed)) {
+            if (current.trim()) {
+                chunks.push(current.trim());
+                current = '';
+            }
+            current = trimmed.replace(/^\d+\.\s+/, '').trim();
+            continue;
+        }
+        // Bullet: - or *
+        if (/^[-*]\s+/.test(trimmed)) {
+            if (current.trim()) {
+                chunks.push(current.trim());
+                current = '';
+            }
+            current = trimmed.replace(/^[-*]\s+/, '').trim();
+            continue;
+        }
+        // Regular line
+        current = current ? current + ' ' + trimmed : trimmed;
+    }
+    if (current.trim())
+        chunks.push(current.trim());
+    // Also split on double newlines within chunks if they somehow ended up there
+    return chunks.flatMap((c) => {
+        const parts = c.split(/\n{2,}/);
+        return parts.map((p) => p.trim()).filter(Boolean);
+    });
+}
+const CURSOR_RULE_FILE = /\.mdc?$/i;
+/** Import `.cursorrules`, one rule file, or a `.cursor/rules` tree of `.mdc` and `.md` rules. */
+export function importCursor(sourcePath, options) {
+    const files = fs.statSync(sourcePath).isDirectory()
+        ? collectMarkdownFiles(sourcePath, options.hippoRoot, CURSOR_RULE_FILE).map((rel) => path.join(sourcePath, rel))
+        : [sourcePath];
+    const chunks = files.flatMap((file) => {
+        const raw = fs.readFileSync(file, 'utf8');
+        return parseCursorFile(CURSOR_RULE_FILE.test(file) ? parseFrontmatter(raw).body : raw);
+    });
+    return importEntries(chunks, 'import:cursor', ['imported', 'cursor'], options);
+}
+// ---------------------------------------------------------------------------
+// Generic file importer
+// ---------------------------------------------------------------------------
+/**
+ * Split a generic file into chunks.
+ * Markdown: split on headings and bullet points.
+ * Plain text: split on double newlines or one-per-line.
+ */
+function parseGenericFile(filePath) {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const isMarkdown = filePath.endsWith('.md') || filePath.endsWith('.mdx');
+    if (isMarkdown) {
+        return splitMarkdown(raw);
+    }
+    // Plain text: try double newlines first
+    const byParagraph = raw.split(/\n{2,}/).map((p) => p.trim()).filter(Boolean);
+    if (byParagraph.length > 1)
+        return byParagraph;
+    // Fall back to one-per-line
+    return raw.split('\n').map((l) => l.trim()).filter(Boolean);
+}
+export function importGenericFile(filePath, options) {
+    const chunks = parseGenericFile(filePath);
+    return importEntries(chunks, 'import:file', ['imported'], options);
+}
+//# sourceMappingURL=sources.js.map

package/dist/importers/vault.d.ts

@@ -0,0 +1,11 @@
+import { type ImportResult, type ImportOptions } from './core.js';
+/**
+ * Import a markdown vault FOLDER as `kind='raw'` memories.
+ *
+ * NOT re-entrant: idempotency rests on the in-memory `existing` Map loaded once
+ * at the top. Two concurrent importVault runs over the same vault could both see
+ * a note as absent and double-insert (the connector pattern relies on a single
+ * sequential writer; same caveat applies here).
+ */
+export declare function importVault(folderPath: string, options: ImportOptions): ImportResult;
+//# sourceMappingURL=vault.d.ts.map

package/dist/importers/vault.js

@@ -0,0 +1,352 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { createHash } from 'node:crypto';
+import { createMemory } from '../memory.js';
+import { initStore } from '../store/open.js';
+import { remember, archiveRaw, isPrivateScope } from '../api.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 { isJsonString } from './core.js';
+import { parseFrontmatter, frontmatterList, parseWikilinks, collectMarkdownFiles, realpathOrResolve } from './markdown-parse.js';
+// ---------------------------------------------------------------------------
+// K1 vault importer (markdown-vault FOLDER → kind='raw' memories)
+//
+// MIRRORS THE CONNECTOR PATTERN (src/connectors/slack|github), NOT the
+// single-file importers above. Each note becomes a single kind='raw' row with
+// provenance in TAGS (`source:vault` + `vault:<name>`), an artifactRef cursor
+// key, and a content-hash tag. Changes APPEND a new raw row after archiveRaw of
+// the old one; deletions archiveRaw the orphaned rows. We NEVER `supersede` a
+// raw row (supersede yields kind='distilled', losing raw-append-only protection
+// and escaping the kind='raw' deletion rescan) — all raw deletions route through
+// `archiveRaw` (the only trigger-legit raw delete).
+// ---------------------------------------------------------------------------
+/** Escape LIKE wildcards in operator-supplied text (mirror of
+ *  src/project-briefs.ts:477 / src/store/search-rows.ts, kept local since neither is
+ *  exported). Used so a `%`/`_`/`\` in the vault name cannot over-match the
+ *  loader prefix and archive another vault's rows. */
+function escapeLike(term) {
+    return term.replace(/[%_\\]/g, '\\$&');
+}
+/**
+ * Import a markdown vault FOLDER as `kind='raw'` memories.
+ *
+ * NOT re-entrant: idempotency rests on the in-memory `existing` Map loaded once
+ * at the top. Two concurrent importVault runs over the same vault could both see
+ * a note as absent and double-insert (the connector pattern relies on a single
+ * sequential writer; same caveat applies here).
+ */
+export function importVault(folderPath, options) {
+    const hippoRoot = options.hippoRoot;
+    const tenantId = options.tenantId ?? 'default';
+    const { vaultName, scope } = vaultIdentityOrThrow(options);
+    const extraTags = options.extraTags ?? [];
+    const dryRun = options.dryRun ?? false;
+    if (options.global) {
+        // The raw-archive path is tenant-local; global mode would put raw vault rows
+        // in the wrong store. Reject for SDK callers too (the CLI also rejects
+        // --global) rather than silently writing local (codex P2).
+        throw new Error('importVault does not support global mode (raw rows are tenant-local).');
+    }
+    // Self-store no-op guard (codex R8 P1). MUST run BEFORE the existing-rows load
+    // and the deletion-sync pass below. If the vault folder IS the store (or lives
+    // inside it), there are no real vault notes - only the store's own markdown
+    // mirror files. Letting collectMarkdownFiles return [] for this case is NOT
+    // safe: an empty scan is indistinguishable from "every note was deleted", so
+    // deletion-sync would archive every live vault:<name>:* row, and raw-archive
+    // content redaction makes that loss IRREVERSIBLE. The only safe reading of
+    // "import the store into itself" is "do nothing". Canonicalize both paths
+    // (realpath: dereference junctions/symlinks + normalize Windows case) so an
+    // aliased path to the store is still caught (codex R9 P2).
+    const resolvedStore = realpathOrResolve(hippoRoot);
+    const resolvedFolder = realpathOrResolve(folderPath);
+    if (resolvedFolder === resolvedStore || resolvedFolder.startsWith(resolvedStore + path.sep)) {
+        return { total: 0, imported: 0, skipped: 0, rejected: 0, archived: 0, entries: [] };
+    }
+    const ctx = {
+        hippoRoot,
+        tenantId,
+        // Process-local actor; the vault importer is a CLI/SDK ingestion path, not
+        // a bearer-authed request. archiveRaw / remember thread this into audit.
+        actor: { subject: 'connector:vault', role: 'admin' },
+    };
+    const existing = loadVaultRows(hippoRoot, tenantId, vaultName);
+    const relpaths = collectMarkdownFiles(folderPath, hippoRoot);
+    const tally = { total: 0, imported: 0, skipped: 0, rejected: 0, archived: 0, redacted: 0, entries: [] };
+    const baseHalfLifeDays = loadConfig(hippoRoot).defaultHalfLifeDays;
+    const seen = new Set();
+    // AT1 P2 fix: dry-run never called remember(), so it never probed
+    // tombstones — every note that reached the write step counted as
+    // `imported` even when a real run would refuse it. Probe (read-only) via
+    // the same guard remember()/writeEntry uses, without ever writing.
+    const dryRunDb = dryRun ? openHippoDb(hippoRoot) : null;
+    try {
+        const run = {
+            ctx, folderPath, vaultName, scope, extraTags, dryRun, dryRunDb, existing, seen, baseHalfLifeDays, tally,
+        };
+        for (const relpath of relpaths)
+            importVaultNote(run, relpath);
+    }
+    finally {
+        if (dryRunDb)
+            closeHippoDb(dryRunDb);
+    }
+    // Deletion-sync: any artifactRef present in the Map but NOT seen this run is a
+    // note that vanished from the source folder → archive its raw row. Per-file
+    // archiveRaw (own handle); no outer SAVEPOINT (no cross-file idempotency row
+    // to commit atomically, unlike github's multi-row case).
+    for (const [artifactRef, rows] of existing) {
+        if (seen.has(artifactRef))
+            continue;
+        for (const row of rows) {
+            tally.archived++; // count even in dryRun so the preview reflects destructive deletes
+            if (!dryRun)
+                archiveRaw(ctx, row.id, `source_deleted:${artifactRef}`);
+        }
+    }
+    const { total, imported, skipped, rejected, archived, redacted, entries } = tally;
+    return { total, imported, skipped, rejected, archived, redacted, entries };
+}
+function vaultIdentityOrThrow(options) {
+    // Vault NAME is the identity key for the destructive deletion-sync below, so it
+    // must be explicit. Defaulting to the folder basename meant two unrelated vaults
+    // sharing a basename (e.g. work/notes and personal/notes) collided on the same
+    // `vault:<name>:*` prefix - importing the second loaded the first's rows and the
+    // deletion-sync archived them (codex R10 P2). Require a deliberate name instead
+    // of inferring a path-unstable one.
+    const vaultName = options.name?.trim();
+    if (!vaultName) {
+        throw new Error('importVault requires an explicit vault name (options.name): it is the identity key for source-deletion sync and must not be inferred from the folder basename.');
+    }
+    if (vaultName.includes(':')) {
+        // ':' is the artifactRef delimiter (vault:<name>:<relpath>); a name
+        // containing it lets a different vault's prefix scan over-match and archive
+        // its rows (codex P2). Reject rather than silently corrupt the keys.
+        throw new Error(`vault name must not contain ':' (artifactRef delimiter): ${vaultName}`);
+    }
+    const scope = options.scope ?? null;
+    // Privacy footgun guard (codex R13 P2): hippo's recall filter only default-denies
+    // scopes shaped `<source>:private:*` (see isPrivateScope / PRIVATE_SCOPE_RE in
+    // scope.ts). A bare `private` (or `private:<x>`) first segment is NOT recognized
+    // as private, so notes a user believes are private would still be returned to
+    // no-scope recall callers. Reject the alias and point at the source-prefixed form
+    // rather than silently storing public-visible "private" notes. Use recall's own
+    // isPrivateScope as the single source of truth: reject a scope that names a
+    // `private` segment yet is NOT a valid `<source>:private:*` (catches `private`,
+    // `private:x`, and `vault:private` with a missing trailing segment).
+    if (scope !== null && scope.split(':').includes('private') && !isPrivateScope(scope)) {
+        throw new Error(`vault scope '${scope}' is not recognized as private by recall (only '<source>:private:*' scopes are default-denied). Use a source-prefixed scope such as 'vault:private:${vaultName}'.`);
+    }
+    return { vaultName, scope };
+}
+function loadVaultRows(hippoRoot, tenantId, vaultName) {
+    // Load ONCE: every existing raw row for this vault, tenant-scoped. The same
+    // Map serves both per-file idempotency AND the deletion diff (no second
+    // query). LIKE-escape the vault name so a `%`/`_` in it can't over-match.
+    initStore(hippoRoot);
+    // artifactRef -> ALL its live raw rows. >1 only after a concurrent double-insert
+    // (the importer is not re-entrant; see the JSDoc). The buckets matter: a later
+    // changed/deletion pass must archive EVERY matching row, not just the last one
+    // scanned, or older raw vault content lingers live + searchable (codex P2).
+    const existing = new Map();
+    const db = openHippoDb(hippoRoot);
+    try {
+        const likeParam = `vault:${escapeLike(vaultName)}:%`;
+        // SAFETY: query selects exactly the columns of VaultRow, in the same
+        // names, from the memories table this module owns.
+        const rows = db
+            .prepare(`SELECT id, artifact_ref, tags_json, scope FROM memories
+           WHERE artifact_ref LIKE ? ESCAPE '\\' AND tenant_id = ? AND kind = 'raw'`)
+            .all(likeParam, tenantId);
+        // SQLite LIKE is case-insensitive for ASCII, so the query over-fetches
+        // (vault 'A' also matches 'vault:a:%'). Filter to the EXACT-case prefix in
+        // JS so deletion-sync never archives a different-cased vault's rows (codex P2).
+        const exactPrefix = `vault:${vaultName}:`;
+        for (const row of rows) {
+            if (row.artifact_ref && row.artifact_ref.startsWith(exactPrefix)) {
+                const bucket = existing.get(row.artifact_ref);
+                if (bucket)
+                    bucket.push(row);
+                else
+                    existing.set(row.artifact_ref, [row]);
+            }
+        }
+    }
+    finally {
+        closeHippoDb(db);
+    }
+    return existing;
+}
+function importVaultNote(run, relpath) {
+    const { ctx, tally } = run;
+    tally.total++;
+    const artifactRef = `vault:${run.vaultName}:${relpath}`;
+    run.seen.add(artifactRef);
+    // Content-hash is computed from the RAW file bytes (deterministic; no
+    // Date/random in the content path) so idempotency survives frontmatter
+    // edits identically to body edits.
+    const rawFileContent = readVaultNote(run, relpath);
+    if (rawFileContent === null)
+        return;
+    const hash = createHash('sha256').update(rawFileContent).digest('hex');
+    const hashTag = `content-hash:${hash}`;
+    // Load every live raw row for this ref (>1 only after a concurrent double-
+    // insert). The idempotency decision happens below, AFTER the full tag set is
+    // built, so it can compare the complete envelope rather than a subset.
+    const priors = run.existing.get(artifactRef) ?? [];
+    const { fm, body } = parseFrontmatter(rawFileContent);
+    // Empty / frontmatter-only note: nothing storable (createMemory enforces a
+    // min content length). The note's CONTENT was deleted at source, so this is a
+    // content-deletion: archive any prior row(s) - the old body must not stay live
+    // and searchable after the source no longer holds it (codex R12 P2) - then
+    // skip the write. Archiving here is safe precisely because we then skip
+    // remember() entirely: there is no archive-then-throw-on-empty-body hazard
+    // (the original reason this branch did not archive). The note stays in `seen`
+    // so deletion-sync does not double-process it.
+    if (body.trim().length < 3) {
+        archivePriors(run, priors, `emptied:${artifactRef}`);
+        tally.skipped++;
+        return;
+    }
+    const tags = vaultNoteTags(run, hashTag, fm, body);
+    if (vaultEnvelopeUnchanged(priors, tags, run.scope)) {
+        // Unchanged file + envelope → skip (idempotent re-import).
+        tally.skipped++;
+        return;
+    }
+    // Changed file → archive EVERY old raw row for this ref (normally one; >1
+    // only after a concurrent double-insert), then append the new one. NEVER
+    // supersede (would yield kind='distilled'). archiveRaw commits + closes its
+    // handle before remember() runs, so there is no double-live row; a crash
+    // between them self-heals (file re-imported as fresh raw next run).
+    archivePriors(run, priors, `changed:${artifactRef}`);
+    // remember() owns the actual write. We build an `echo` of the SAME content +
+    // tags via createMemory purely for the ImportResult, then reconcile its id to
+    // remember()'s real row id so entries[] reflects the row that landed.
+    const content = vetSecrets(body, tags, true).content;
+    const echo = createMemory(content, {
+        kind: 'raw',
+        tags,
+        scope: run.scope,
+        owner: 'agent:vault-import',
+        artifact_ref: artifactRef,
+        tenantId: ctx.tenantId,
+        baseHalfLifeDays: run.baseHalfLifeDays,
+    });
+    if (!storeVaultNote(run, echo, content, tags, artifactRef)) {
+        tally.rejected++;
+        return;
+    }
+    tally.entries.push(echo);
+    tally.imported++;
+    if (content !== body)
+        tally.redacted++;
+}
+function readVaultNote(run, relpath) {
+    try {
+        return fs.readFileSync(path.join(run.folderPath, relpath), 'utf8');
+    }
+    catch {
+        // File vanished between enumeration and read (TOCTOU), or a transient
+        // IO/permission error. Skip this one file rather than aborting the whole
+        // import (incl. the deletion-sync pass); an idempotent re-run picks it up.
+        run.tally.skipped++;
+        return null;
+    }
+}
+function archivePriors(run, priors, reason) {
+    for (const p of priors) {
+        run.tally.archived++; // count the would-be archive even in dryRun (true preview)
+        if (!run.dryRun)
+            archiveRaw(run.ctx, p.id, reason);
+    }
+}
+function vaultNoteTags(run, hashTag, fm, body) {
+    // Build the FULL tag envelope this import would write, BEFORE the idempotency
+    // decision. De-duplicate (createMemory stores tags verbatim, so a collision
+    // between, e.g., a frontmatter tag and an extraTag would otherwise produce a
+    // duplicate). Order-preserving.
+    const frontmatterTags = [
+        ...frontmatterList(fm['tags']),
+        ...frontmatterList(fm['aliases']).map((a) => `alias:${a}`),
+    ];
+    const wikilinkTags = parseWikilinks(body).map((t) => `wikilink-candidate:${t}`);
+    return Array.from(new Set([
+        'source:vault',
+        `vault:${run.vaultName}`,
+        hashTag,
+        ...frontmatterTags,
+        ...wikilinkTags,
+        ...run.extraTags,
+    ]));
+}
+function vaultEnvelopeUnchanged(priors, tags, scope) {
+    // Unchanged iff EVERY live raw row carries the EXACT same tag set AND scope.
+    // Comparing the COMPLETE set (not the content-hash + a subset of extra tags)
+    // means every envelope change registers: content (via the content-hash tag),
+    // frontmatter, wikilinks, an ADDED extra tag, or a REMOVED one - the earlier
+    // piecemeal checks missed scope (R10 P2) then tag removal (R11 P2). Set
+    // equality is order-independent and both sides are deduped. (`length > 0`
+    // guard: a never-seen file must import, not skip; archiving ALL priors on a
+    // mismatch also clears any concurrent-double-insert duplicates.)
+    const wantTags = new Set(tags);
+    return (priors.length > 0 &&
+        priors.every((p) => {
+            if ((p.scope ?? null) !== scope)
+                return false;
+            const priorTags = parseJsonArrayLoose(p.tags_json);
+            return priorTags.length === wantTags.size && priorTags.every((t) => wantTags.has(t));
+        }));
+}
+/** Returns false when the rejection guard refuses the note; any other error propagates. */
+function storeVaultNote(run, echo, content, tags, artifactRef) {
+    try {
+        // dryRun preview: count what WOULD import, but make no writes (codex P2).
+        if (!run.dryRun) {
+            // AT1 (plan §3 containment): a rejected note must not abort the rest
+            // of the vault scan (deletion-sync pass included). The priors above
+            // are already archived by this point — same self-heal story as any
+            // other crash between archiveRaw and remember() (comment above): a
+            // re-run with the file still rejected hits the same refusal again,
+            // loud each time via the rejected count.
+            const result = remember(run.ctx, {
+                content,
+                kind: 'raw',
+                artifactRef,
+                owner: 'agent:vault-import',
+                scope: run.scope ?? undefined,
+                tags,
+            });
+            echo.id = result.id;
+        }
+        else if (run.dryRunDb) {
+            // AT1 P2 fix: probe the tombstone without writing so the preview's
+            // `rejected` count matches what a real run would refuse.
+            checkRejectionGuard(run.dryRunDb, run.ctx.tenantId, echo.id, echo.content);
+        }
+        return true;
+    }
+    catch (err) {
+        if (err instanceof RejectedValueError)
+            return false;
+        throw err;
+    }
+}
+/** Local tolerant JSON-array parse for the loader's `tags_json` column. The
+ *  store's own `parseJsonArray` is not exported; this matches its contract
+ *  (returns [] on null/garbage). */
+function parseJsonArrayLoose(value) {
+    if (!value)
+        return [];
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed.filter(isJsonString) : [];
+    }
+    catch (err) {
+        log.debug(`import: unreadable tags_json read as no tags: ${err instanceof Error ? err.message : String(err)}`);
+        return [];
+    }
+}
+//# sourceMappingURL=vault.js.map

package/dist/incidents.d.ts

@@ -25,6 +25,7 @@
  * the row, default `[]`. On save, every id must exist in the SAME tenant; a
  * cross-tenant or nonexistent id is rejected (throw) before the insert.
  */
+import { type KeysetPosition } from './keyset.js';
 export type IncidentStatus = 'open' | 'resolved' | 'closed';
 export declare const VALID_INCIDENT_STATES: ReadonlySet<IncidentStatus>;
 export interface Incident {
@@ -57,6 +58,8 @@ export interface SaveIncidentOpts {
 export interface ListIncidentsOpts {
     status?: IncidentStatus;
     limit?: number;
+    /** Resume after this row: the position the previous page ended on. */
+    after?: KeysetPosition;
 }
 /**
  * Create an incident. Writes the memory mirror + the incidents row atomically

package/dist/incidents.js

@@ -27,11 +27,12 @@
  */
 import { BadRequestError, ConflictError, NotFoundError } from './api-errors.js';
 import { openHippoDb, closeHippoDb } from './db.js';
-import { writeEntry } from './store.js';
+import { writeEntry } from './store/entry-writes.js';
 import { assertTenantId } from './tenant.js';
 import { createMemory, Layer } from './memory.js';
 import { appendAuditEvent } from './audit.js';
 import { objectHalfLifeDays } from './half-life-migration.js';
+import { keysetAfter } from './keyset.js';
 export const VALID_INCIDENT_STATES = new Set([
     'open',
     'resolved',
@@ -286,6 +287,7 @@ export function loadIncidentById(hippoRoot, tenantId, id) {
 export function loadIncidents(hippoRoot, tenantId, opts = {}) {
     assertTenantId('loadIncidents', tenantId);
     const limit = opts.limit ?? 100;
+    const after = keysetAfter('created_at', 'id', opts.after);
     const db = openHippoDb(hippoRoot);
     try {
         let rows;
@@ -296,19 +298,19 @@ export function loadIncidents(hippoRoot, tenantId, opts = {}) {
             // SAFETY: rows' shape matches the columns named in INCIDENT_COLS above.
             rows = db.prepare(`
         SELECT ${INCIDENT_COLS} FROM incidents
-        WHERE tenant_id = ? AND status = ?
+        WHERE tenant_id = ? AND status = ?${after.sql}
         ORDER BY created_at DESC, id DESC
         LIMIT ?
-      `).all(tenantId, opts.status, limit);
+      `).all(tenantId, opts.status, ...after.params, limit);
         }
         else {
             // SAFETY: rows' shape matches the columns named in INCIDENT_COLS above.
             rows = db.prepare(`
         SELECT ${INCIDENT_COLS} FROM incidents
-        WHERE tenant_id = ?
+        WHERE tenant_id = ?${after.sql}
         ORDER BY created_at DESC, id DESC
         LIMIT ?
-      `).all(tenantId, limit);
+      `).all(tenantId, ...after.params, limit);
         }
         return rows.map(rowToIncident);
     }