@openanonymity/nanomem 0.1.0 → 0.1.2

package/src/omf.js

@@ -0,0 +1,343 @@
+/** @import { ExportRecord, OmfDocument, OmfImportOptions, OmfImportPreview, OmfImportResult, StorageFacade } from './types.js' */
+
+import {
+    parseBullets,
+    inferTopicFromPath,
+    isExpiredBullet,
+    todayIsoDate,
+    ensureBulletMetadata,
+    compactBullets,
+    renderCompactedDocument,
+    normalizeFactText,
+} from './bullets/index.js';
+
+const SUPPORTED_OMF_VERSIONS = ['1.0'];
+const DEFAULT_SOURCE_APP = 'nanomem';
+
+function categoryFromPath(filePath) {
+    if (!filePath) return null;
+    let category = filePath.replace(/\.md$/i, '');
+    category = category.replace(/\/about$/, '');
+    return category || null;
+}
+
+function targetPathForItem(item) {
+    const appExtensions = item.extensions?.['oa-chat'] || item.extensions?.nanomem || null;
+    if (appExtensions?.file_path) {
+        return appExtensions.file_path;
+    }
+
+    if (item.category) {
+        const category = String(item.category).replace(/^\/+|\/+$/g, '').trim();
+        if (category) {
+            if (category.includes('/')) {
+                return `${category}.md`;
+            }
+            return `${category}/about.md`;
+        }
+    }
+
+    return 'personal/imported.md';
+}
+
+function isDocumentItem(item) {
+    const extensions = item.extensions?.['oa-chat'] || item.extensions?.nanomem || null;
+    if (extensions?.document) return true;
+    return item.content.length > 500 && item.content.includes('\n');
+}
+
+function statusToSection(status) {
+    if (status === 'archived' || status === 'expired') return 'history';
+    return 'long_term';
+}
+
+/**
+ * @param {unknown} doc
+ * @returns {{ valid: boolean, error?: string }}
+ */
+export function validateOmf(doc) {
+    if (!doc || typeof doc !== 'object') {
+        return { valid: false, error: 'Not a valid JSON object' };
+    }
+    const d = /** @type {any} */ (doc);
+    if (!d.omf) {
+        return { valid: false, error: 'Missing "omf" version field. Is this an OMF file?' };
+    }
+    if (!SUPPORTED_OMF_VERSIONS.includes(String(d.omf))) {
+        return {
+            valid: false,
+            error: `Unsupported OMF version "${d.omf}". Supported: ${SUPPORTED_OMF_VERSIONS.join(', ')}`
+        };
+    }
+    if (!Array.isArray(d.memories)) {
+        return { valid: false, error: 'Missing or invalid "memories" array' };
+    }
+    for (let index = 0; index < d.memories.length; index += 1) {
+        const memory = d.memories[index];
+        if (!memory || typeof memory !== 'object') {
+            return { valid: false, error: `Memory item at index ${index} is not an object` };
+        }
+        if (!memory.content || typeof memory.content !== 'string' || !memory.content.trim()) {
+            return { valid: false, error: `Memory item at index ${index} has empty or missing "content"` };
+        }
+    }
+    return { valid: true };
+}
+
+/**
+ * @param {string} text
+ * @returns {OmfDocument}
+ */
+export function parseOmfText(text) {
+    return JSON.parse(text);
+}
+
+/**
+ * @param {StorageFacade} storage
+ * @param {{ sourceApp?: string }} [options]
+ * @returns {Promise<OmfDocument>}
+ */
+export async function buildOmfExport(storage, options = {}) {
+    const allFiles = await storage.exportAll();
+    const today = todayIsoDate();
+    const memories = [];
+
+    for (const file of allFiles) {
+        if (file.path.endsWith('_tree.md')) continue;
+        if (!file.content?.trim()) continue;
+
+        const category = categoryFromPath(file.path);
+        const bullets = parseBullets(file.content);
+
+        if (bullets.length > 0) {
+            for (const bullet of bullets) {
+                if (!bullet.text?.trim()) continue;
+
+                const item = { content: bullet.text };
+                if (category) item.category = category;
+
+                const inferredTopic = inferTopicFromPath(file.path);
+                if (bullet.topic && bullet.topic !== inferredTopic) {
+                    item.tags = [bullet.topic];
+                }
+
+                if (isExpiredBullet(bullet, today)) {
+                    item.status = 'expired';
+                } else if (bullet.section === 'history' || bullet.section === 'archive') {
+                    item.status = 'archived';
+                }
+
+                if (file.createdAt) {
+                    item.created_at = new Date(file.createdAt).toISOString().slice(0, 10);
+                }
+                if (bullet.updatedAt) item.updated_at = bullet.updatedAt;
+                if (bullet.expiresAt) item.expires_at = bullet.expiresAt;
+
+                item.extensions = {
+                    nanomem: {
+                        file_path: file.path,
+                        heading: bullet.heading || null,
+                    },
+                };
+
+                memories.push(item);
+            }
+            continue;
+        }
+
+        const item = { content: file.content.trim() };
+        if (category) item.category = category;
+        if (file.createdAt) {
+            item.created_at = new Date(file.createdAt).toISOString().slice(0, 10);
+        }
+        if (file.updatedAt) {
+            item.updated_at = new Date(file.updatedAt).toISOString().slice(0, 10);
+        }
+        item.extensions = {
+            nanomem: {
+                file_path: file.path,
+                document: true,
+            },
+        };
+        memories.push(item);
+    }
+
+    return {
+        omf: SUPPORTED_OMF_VERSIONS[0],
+        exported_at: new Date().toISOString(),
+        source: {
+            app: options.sourceApp || DEFAULT_SOURCE_APP,
+        },
+        memories,
+    };
+}
+
+/**
+ * @param {StorageFacade} storage
+ * @param {OmfDocument} doc
+ * @param {OmfImportOptions} [options]
+ * @returns {Promise<OmfImportPreview>}
+ */
+export async function previewOmfImport(storage, doc, options = {}) {
+    const { includeArchived = true } = options;
+    const validation = validateOmf(doc);
+    if (!validation.valid) {
+        throw new Error(validation.error);
+    }
+
+    const total = doc.memories.length;
+    let filtered = 0;
+    let duplicates = 0;
+    const byFile = /** @type {Record<string, {new: number, duplicate: number, document?: boolean}>} */ ({});
+
+    for (const item of doc.memories) {
+        if (!includeArchived && (item.status === 'archived' || item.status === 'expired')) {
+            filtered += 1;
+            continue;
+        }
+
+        if (isDocumentItem(item)) {
+            const path = targetPathForItem(item);
+            byFile[path] = byFile[path] || { new: 0, duplicate: 0, document: true };
+            byFile[path].new += 1;
+            continue;
+        }
+
+        const path = targetPathForItem(item);
+        byFile[path] = byFile[path] || { new: 0, duplicate: 0 };
+
+        const existing = await storage.read(path);
+        if (existing) {
+            const existingBullets = parseBullets(existing);
+            const normalizedNew = normalizeFactText(item.content);
+            const isDuplicate = existingBullets.some((bullet) => normalizeFactText(bullet.text) === normalizedNew);
+            if (isDuplicate) {
+                duplicates += 1;
+                byFile[path].duplicate += 1;
+            } else {
+                byFile[path].new += 1;
+            }
+        } else {
+            byFile[path].new += 1;
+        }
+    }
+
+    const existingFiles = new Set();
+    const newFiles = new Set();
+    for (const path of Object.keys(byFile)) {
+        if (await storage.exists(path)) {
+            existingFiles.add(path);
+        } else {
+            newFiles.add(path);
+        }
+    }
+
+    return {
+        total,
+        filtered,
+        toImport: total - filtered - duplicates,
+        duplicates,
+        newFiles: newFiles.size,
+        existingFiles: existingFiles.size,
+        byFile,
+    };
+}
+
+/**
+ * @param {StorageFacade} storage
+ * @param {OmfDocument} doc
+ * @param {OmfImportOptions} [options]
+ * @returns {Promise<OmfImportResult>}
+ */
+export async function importOmf(storage, doc, options = {}) {
+    const { includeArchived = true } = options;
+    const validation = validateOmf(doc);
+    if (!validation.valid) {
+        throw new Error(validation.error);
+    }
+
+    const today = todayIsoDate();
+    const errors = [];
+    let skipped = 0;
+    const groups = new Map();
+
+    for (const item of doc.memories) {
+        if (!includeArchived && (item.status === 'archived' || item.status === 'expired')) {
+            skipped += 1;
+            continue;
+        }
+
+        const path = targetPathForItem(item);
+        if (!groups.has(path)) {
+            groups.set(path, []);
+        }
+        groups.get(path).push(item);
+    }
+
+    let imported = 0;
+    let duplicates = 0;
+    let filesWritten = 0;
+
+    for (const [path, items] of groups.entries()) {
+        try {
+            const documentItems = items.filter(isDocumentItem);
+            const bulletItems = items.filter((item) => !isDocumentItem(item));
+            const defaultTopic = inferTopicFromPath(path);
+
+            if (documentItems.length > 0 && bulletItems.length === 0) {
+                const documentItem = documentItems[documentItems.length - 1];
+                await storage.write(path, documentItem.content);
+                imported += documentItems.length;
+                filesWritten += 1;
+                continue;
+            }
+
+            const existing = await storage.read(path);
+            const existingBullets = existing ? parseBullets(existing) : [];
+
+            const incomingBullets = bulletItems.map((item) => ensureBulletMetadata({
+                text: item.content,
+                topic: item.tags?.[0] || null,
+                updatedAt: item.updated_at || today,
+                expiresAt: item.expires_at || null,
+                section: statusToSection(item.status),
+            }, { updatedAt: today, defaultTopic }));
+
+            const existingNormalized = new Set(existingBullets.map((bullet) => normalizeFactText(bullet.text)));
+            let itemDuplicates = 0;
+            for (const bullet of incomingBullets) {
+                if (existingNormalized.has(normalizeFactText(bullet.text))) {
+                    itemDuplicates += 1;
+                }
+            }
+            duplicates += itemDuplicates;
+
+            const allBullets = [...existingBullets, ...incomingBullets];
+            const compacted = compactBullets(allBullets, { today, defaultTopic });
+            const markdown = renderCompactedDocument(
+                compacted.working,
+                compacted.longTerm,
+                compacted.history
+            );
+
+            await storage.write(path, markdown);
+            imported += bulletItems.length - itemDuplicates;
+            filesWritten += 1;
+
+            if (documentItems.length > 0) {
+                imported += documentItems.length;
+            }
+        } catch (error) {
+            errors.push(`Error writing ${path}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+
+    return {
+        total: doc.memories.length,
+        imported,
+        duplicates,
+        skipped,
+        filesWritten,
+        errors,
+    };
+}

package/src/prompt_sets/conversation/ingestion.js

@@ -1,10 +1,58 @@
 /**
  * Prompt set for conversation ingestion.
  *
- * Strict mode: only saves facts the user explicitly stated.
- * Used when importing chat history, conversation logs, or live sessions.
+ * ingestionPrompt — general import: full discretion over create/append/update.
+ * addPrompt       — `nanomem add`: only write NEW facts (create or append, no updates).
+ * updatePrompt    — `nanomem update`: only edit EXISTING facts (no new files).
  */
 
+export const addPrompt = `You are a memory manager. Save NEW facts from the text that do not yet exist in memory.
+
+CRITICAL: Only save facts the user explicitly stated. Do NOT infer, extrapolate, or fabricate.
+
+Current memory index:
+\`\`\`
+{INDEX}
+\`\`\`
+
+For each new fact, decide:
+- Use append_memory if an existing file already covers the same domain or topic.
+- Use create_new_file only if no existing file is thematically close.
+
+Do NOT save:
+- Facts already present in memory
+- Transient details (greetings, one-off questions with no lasting answer)
+- Sensitive secrets (passwords, tokens, keys)
+
+Bullet format: "- Fact text | topic=topic-name | source=user_statement | confidence=high | updated_at=YYYY-MM-DD"
+
+If nothing new is worth saving, stop without calling any tools.`;
+
+export const updatePrompt = `You are a memory manager. Update the user's memory based on the text below.
+
+CRITICAL: Only save facts the user explicitly stated. Do NOT infer, extrapolate, or fabricate.
+
+Current memory index:
+\`\`\`
+{INDEX}
+\`\`\`
+
+Steps:
+1. Identify which existing file(s) might hold facts that are stale or contradicted by the new information.
+2. Use read_file to read the current content and find the exact bullet text to replace.
+3. If a matching old fact exists, use update_bullets with all corrections for that file in a single call, passing the exact old fact text and the corrected fact text for each.
+4. If no existing fact matches — the information is entirely new — use append_memory to add it to an existing file that covers the same domain, or create_new_file if no existing file is thematically close.
+
+Rules:
+- Prefer update_bullets when an existing fact is directly contradicted or corrected.
+- Only change bullets that are directly contradicted or corrected by the new information.
+- Do not touch any other bullets in the file.
+- Pass old_fact exactly as it appears in the file (including pipe-delimited metadata is fine).
+- Pass new_fact as plain text only — no metadata.
+- When appending or creating, use this bullet format: "- Fact text | topic=topic-name | source=user_statement | confidence=high | updated_at=YYYY-MM-DD"
+
+If nothing new or changed is worth saving, stop without calling any tools.`;
+
 export const ingestionPrompt = `You are a memory manager. After reading a conversation, decide if any concrete, reusable facts should be saved to the user's memory files.
 
 CRITICAL: Only save facts the user explicitly stated. Do NOT infer, extrapolate, or fabricate information.
@@ -13,7 +61,7 @@ Save information that is likely to help in a future conversation. Be selective
 
 Do NOT save:
 - Anything the user did not explicitly say (no inferences, no extrapolations, no "likely" facts)
-- Information already present in existing files (the system deduplicates automatically)
+- Information already present in existing files
 - Transient details (greetings, "help me with this", "thanks", questions without lasting answers)
 - The assistant's own reasoning, suggestions, or knowledge — only what the user stated
 - Sensitive secrets (passwords, auth tokens, private keys, full payment data, government IDs)
@@ -28,24 +76,75 @@ Current memory index:
 
 Instructions:
 1. Read the conversation below and identify facts the user explicitly stated.
-2. Check the memory index above. Default to append_memory when an existing file covers the same domain or a closely related topic. Only use create_new_file when no existing file is thematically close. Do not read files before writing — the system deduplicates automatically.
-3. Use this bullet format: "- Fact text | topic=topic-name | source=SOURCE | confidence=LEVEL | updated_at=YYYY-MM-DD"
-4. Source values:
+2. Do not read files before writing. The memory index is sufficient to decide where to append. Only read a file if the index entry is ambiguous and you need the exact current content to avoid duplicating a fact.
+3. If no relevant file exists yet, create_new_file directly.
+4. Default to append_memory when an existing file covers the same domain or a closely related topic. Only use create_new_file when no existing file is thematically close.
+5. Use this bullet format: "- Fact text | topic=topic-name | source=SOURCE | confidence=LEVEL | updated_at=YYYY-MM-DD"
+6. Source values:
    - source=user_statement — the user directly said this. This is the PRIMARY source. Use it for the vast majority of saved facts.
    - source=llm_infer — use ONLY when combining multiple explicit user statements into an obvious conclusion (e.g. user said "I work at Acme" and "Acme is in SF" → "Works in SF"). Never use this to guess, extrapolate, or fill in gaps. When in doubt, do not save.
-5. Confidence: high for direct user statements, medium for llm_infer. Never save low-confidence items.
-6. You may optionally add tier=working for clearly short-term or in-progress context. If you are unsure, omit tier and just save the fact.
-7. Facts worth saving: allergies, health conditions, location, job/role, tech stack, pets, family members, durable preferences, and active plans — but ONLY if the user explicitly mentioned them.
-8. If a fact is time-sensitive, include date context in the text. You may optionally add review_at or expires_at.
-9. If nothing new is worth remembering, simply stop without calling any write tools. Saving nothing is better than saving something wrong.
+7. Confidence: high for direct user statements, medium for llm_infer. Never save low-confidence items.
+8. You may optionally add tier=working for clearly short-term or in-progress context. If you are unsure, omit tier and just save the fact.
+9. Facts worth saving: allergies, health conditions, location, job/role, tech stack, pets, family members, durable preferences, and active plans — but ONLY if the user explicitly mentioned them.
+10. If a fact is time-sensitive, include date context in the text. You may optionally add review_at or expires_at.
+11. If nothing new is worth remembering, simply stop without calling any write tools. Saving nothing is better than saving something wrong.
 
 Rules:
 - Write facts in a timeless, archival format: use absolute dates (YYYY-MM-DD) rather than relative terms like "recently", "currently", "just", or "last week". A fact must be interpretable correctly even years after it was written.
 - Favor broad thematic files. A file can hold multiple related sub-topics — only truly unrelated facts need separate files.
 - Only create a new file when nothing in the index is thematically close. When in doubt, append.
 - When creating a new file, choose a broad, thematic name that can absorb future related facts — not a narrow label for a single detail.
-- Use update_memory only if a fact is now stale or contradicted.
+- Use update_bullets only if a fact is now stale or contradicted. Pass all corrections for a file in one call.
 - When a new explicit user statement contradicts an older one on the same topic, prefer the newer statement. If a user statement conflicts with an inference, the user statement always wins.
 - If a conflict is ambiguous, preserve both versions rather than deleting one.
 - Do not skip obvious facts just because the schema supports extra metadata.
 - Content should be raw facts only — no filler commentary.`;
+
+export const deletePrompt = `You are a memory manager performing a TARGETED deletion.
+
+The user wants to remove: "{QUERY}"
+
+RULES — read carefully before acting:
+1. Delete all bullets that are ABOUT the subject(s) or entity mentioned in the deletion request.
+   - If the query names a specific entity (a pet, person, place, project), delete every fact about that entity — not just the one line that introduces it.
+   - Example: "I have dog mochi" → delete ALL facts about Mochi (habits, toys, traits, the introduction line, etc.).
+2. Do NOT delete facts about unrelated subjects, even if they appear in the same file.
+3. When genuinely unsure whether a bullet is about the target subject, SKIP it.
+4. Never delete an entire file — only individual bullets via delete_bullet.
+5. Pass the EXACT bullet text as it appears in the file, including all | metadata after the fact.
+
+Current memory index:
+\`\`\`
+{INDEX}
+\`\`\`
+
+Steps:
+1. Identify which file(s) likely contain the content to delete from the index above.
+2. Use retrieve_file or list_directory if the relevant file is not obvious from the index.
+3. Use read_file to read the identified file(s).
+4. Call delete_bullet for each bullet that is about the subject(s) in the deletion request.
+5. If nothing matches, stop without calling delete_bullet.`;
+
+export const deepDeletePrompt = `You are a memory manager performing a COMPREHENSIVE deletion across ALL memory files.
+
+The user wants to remove: "{QUERY}"
+
+RULES — read carefully before acting:
+1. Delete all bullets that are ABOUT the subject(s) or entity mentioned in the deletion request.
+   - If the query names a specific entity (a pet, person, place, project), delete every fact about that entity across every file — not just the one line that introduces it.
+   - Example: "I have dog mochi" → delete ALL facts about Mochi wherever they appear.
+2. Do NOT delete facts about unrelated subjects.
+3. When genuinely unsure whether a bullet is about the target subject, SKIP it.
+4. Never delete an entire file — only individual bullets via delete_bullet.
+5. Pass the EXACT bullet text as it appears in the file, including all | metadata after the fact.
+
+You MUST read every file listed below and check it for matching content.
+
+Files to check:
+{FILE_LIST}
+
+Steps:
+1. Use read_file to read each file listed above, one by one.
+2. For each file, call delete_bullet for any bullet that is about the subject(s) in the deletion request.
+3. Continue until every file has been checked.
+4. If a file has no matching bullets, move on without calling delete_bullet for it.`;

package/src/prompt_sets/document/ingestion.js

@@ -1,10 +1,55 @@
 /**
  * Prompt set for document ingestion.
  *
- * Relaxed mode: extracts and reasonably infers facts from reference material.
- * Used when importing notes, READMEs, articles, code repositories, or knowledge bases.
+ * ingestionPrompt  — general import: full discretion over create/append/update.
+ * addPrompt        — `nanomem add --format markdown`: only write NEW facts (create or append, no updates).
+ * updatePrompt     — `nanomem update --format markdown`: only edit EXISTING facts (no new files).
  */
 
+export const addPrompt = `You are a memory manager. Extract NEW facts from the document that do not yet exist in memory.
+
+You may extract and reasonably infer facts from what the document shows — not just word-for-word statements. Use good judgment: extract what is clearly supported by the content, avoid speculation.
+
+Current memory index:
+\`\`\`
+{INDEX}
+\`\`\`
+
+For each new fact, decide:
+- Use append_memory if an existing file already covers the same domain or topic.
+- Use create_new_file only if no existing file is thematically close.
+
+Do NOT save:
+- Facts already present in memory
+- Boilerplate (installation steps, license text, generic disclaimers)
+- Sensitive secrets (passwords, tokens, keys)
+
+Bullet format: "- Fact text | topic=topic-name | source=document | confidence=high | updated_at=YYYY-MM-DD"
+
+If nothing new is worth saving, stop without calling any tools.`;
+
+export const updatePrompt = `You are a memory manager. Correct or update facts already saved in memory based on the document below.
+
+CRITICAL: Only edit files that already exist. Do NOT create new files. Do NOT rewrite whole files.
+
+Current memory index:
+\`\`\`
+{INDEX}
+\`\`\`
+
+Steps:
+1. Identify which existing file(s) hold facts that are now stale or contradicted by the document.
+2. Use read_file to read the current content and find the exact bullet text to replace.
+3. Use update_bullets with all corrections for that file in a single call, passing the exact old fact text and the corrected fact text for each.
+
+Rules:
+- Only change bullets that are directly contradicted or corrected by the new information.
+- Do not touch any other bullets in the file.
+- Pass old_fact exactly as it appears in the file (including pipe-delimited metadata is fine).
+- Pass new_fact as plain text only — no metadata.
+
+If nothing needs updating, stop without calling any tools.`;
+
 export const ingestionPrompt = `You are a memory manager. You are reading documents (notes, README files, code repositories, articles) and extracting facts about the subject into a structured memory bank.
 
 Unlike conversation ingestion, you may extract and reasonably infer facts from what the documents show — not just what was explicitly stated word-for-word. Use good judgment: extract what is clearly supported by the content, avoid speculation.
@@ -14,7 +59,7 @@ Save information that would be useful when answering questions about this subjec
 Do NOT save:
 - Speculation or guesses not supported by the content
 - Boilerplate (installation steps, license text, generic disclaimers)
-- Information already present in existing files (use read_file to check first)
+- Information already present in existing files
 - Sensitive secrets (passwords, auth tokens, private keys)
 
 Current memory index:
@@ -26,7 +71,7 @@ Current memory index:
 
 Instructions:
 1. Read the document content and identify concrete, reusable facts about the subject.
-2. If a matching file already exists in the index, use read_file first to avoid duplicates.
+2. Do not read files before writing. The memory index is sufficient to decide where to append or create. Only read a file if the index entry is ambiguous and you need the exact current content to avoid duplicating a fact.
 3. Use create_new_file for new topics, append_memory to add to existing files.
 4. Use this bullet format: "- Fact text | topic=topic-name | source=SOURCE | confidence=LEVEL | updated_at=YYYY-MM-DD"
 5. Source values (IMPORTANT — never use source=user_statement here):
@@ -41,3 +86,52 @@ Rules:
 - One file per distinct topic. Do NOT put unrelated facts in the same file.
 - Create new files freely — focused files are better than bloated ones.
 - Content should be raw facts only — no filler commentary.`;
+
+export const deletePrompt = `You are a memory manager performing a TARGETED deletion.
+
+The user wants to remove: "{QUERY}"
+
+RULES — read carefully before acting:
+1. Delete all bullets that are ABOUT the subject(s) or entity mentioned in the deletion request.
+   - If the query names a specific entity (a person, project, tool, concept), delete every fact about that entity — not just the one line that introduces it.
+   - Example: "project recipe-app" → delete ALL facts about the recipe-app project (tech stack, goals, status, etc.).
+2. Do NOT delete facts about unrelated subjects, even if they appear in the same file.
+3. When genuinely unsure whether a bullet is about the target subject, SKIP it.
+4. Never delete an entire file — only individual bullets via delete_bullet.
+5. Pass the EXACT bullet text as it appears in the file, including all | metadata after the fact.
+
+Current memory index:
+\`\`\`
+{INDEX}
+\`\`\`
+
+Steps:
+1. Identify which file(s) likely contain the content to delete from the index above.
+2. Use retrieve_file or list_directory if the relevant file is not obvious from the index.
+3. Use read_file to read the identified file(s).
+4. Call delete_bullet for each bullet that is about the subject(s) in the deletion request.
+5. If nothing matches, stop without calling delete_bullet.`;
+
+export const deepDeletePrompt = `You are a memory manager performing a COMPREHENSIVE deletion across ALL memory files.
+
+The user wants to remove: "{QUERY}"
+
+RULES — read carefully before acting:
+1. Delete all bullets that are ABOUT the subject(s) or entity mentioned in the deletion request.
+   - If the query names a specific entity (a person, project, tool, concept), delete every fact about that entity wherever it appears.
+   - Example: "project recipe-app" → delete ALL facts about the recipe-app project across every file.
+2. Do NOT delete facts about unrelated subjects.
+3. When genuinely unsure whether a bullet is about the target subject, SKIP it.
+4. Never delete an entire file — only individual bullets via delete_bullet.
+5. Pass the EXACT bullet text as it appears in the file, including all | metadata after the fact.
+
+You MUST read every file listed below and check it for matching content.
+
+Files to check:
+{FILE_LIST}
+
+Steps:
+1. Use read_file to read each file listed above, one by one.
+2. For each file, call delete_bullet for any bullet that is about the subject(s) in the deletion request.
+3. Continue until every file has been checked.
+4. If a file has no matching bullets, move on without calling delete_bullet for it.`;

package/src/prompt_sets/index.js

@@ -8,13 +8,21 @@
  * then add it to PROMPT_SETS below.
  */
 
-import { ingestionPrompt as conversationIngestion } from './conversation/ingestion.js';
-import { ingestionPrompt as documentIngestion } from './document/ingestion.js';
+import { ingestionPrompt as conversationIngestion, addPrompt, updatePrompt, deletePrompt, deepDeletePrompt } from './conversation/ingestion.js';
+import { ingestionPrompt as documentIngestion, addPrompt as documentAddPrompt, updatePrompt as documentUpdatePrompt, deletePrompt as documentDeletePrompt, deepDeletePrompt as documentDeepDeletePrompt } from './document/ingestion.js';
 
 /** @type {Record<string, { ingestionPrompt: string }>} */
 const PROMPT_SETS = {
-    conversation: { ingestionPrompt: conversationIngestion },
-    document:     { ingestionPrompt: documentIngestion },
+    conversation:    { ingestionPrompt: conversationIngestion },
+    document:        { ingestionPrompt: documentIngestion },
+    add:             { ingestionPrompt: addPrompt },
+    update:          { ingestionPrompt: updatePrompt },
+    document_add:    { ingestionPrompt: documentAddPrompt },
+    document_update: { ingestionPrompt: documentUpdatePrompt },
+    delete:          { ingestionPrompt: deletePrompt },
+    deep_delete:     { ingestionPrompt: deepDeletePrompt },
+    document_delete:      { ingestionPrompt: documentDeletePrompt },
+    document_deep_delete: { ingestionPrompt: documentDeepDeletePrompt },
 };
 
 /**