@openanonymity/nanomem 0.1.0

package/types/bullets/compaction.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Compact a list of bullets: deduplicate, assign tiers, enforce limits.
+ * @param {Bullet[]} bullets
+ * @param {CompactBulletsOptions} [options]
+ * @returns {CompactionResult}
+ */
+export function compactBullets(bullets: Bullet[], options?: CompactBulletsOptions): CompactionResult;
+import type { Bullet } from '../types.js';
+import type { CompactBulletsOptions } from '../types.js';
+import type { CompactionResult } from '../types.js';

package/types/bullets/index.d.ts

@@ -0,0 +1,36 @@
+export * from "./normalize.js";
+export * from "./parser.js";
+export * from "./scoring.js";
+export * from "./compaction.js";
+/**
+ * Barrel re-export for all bullet utilities.
+ */
+export type Tier = import("../types.js").Tier;
+/**
+ * Barrel re-export for all bullet utilities.
+ */
+export type Status = import("../types.js").Status;
+/**
+ * Barrel re-export for all bullet utilities.
+ */
+export type Source = import("../types.js").Source;
+/**
+ * Barrel re-export for all bullet utilities.
+ */
+export type Confidence = import("../types.js").Confidence;
+/**
+ * Barrel re-export for all bullet utilities.
+ */
+export type Bullet = import("../types.js").Bullet;
+/**
+ * Barrel re-export for all bullet utilities.
+ */
+export type EnsureBulletMetadataOptions = import("../types.js").EnsureBulletMetadataOptions;
+/**
+ * Barrel re-export for all bullet utilities.
+ */
+export type CompactionResult = import("../types.js").CompactionResult;
+/**
+ * Barrel re-export for all bullet utilities.
+ */
+export type CompactBulletsOptions = import("../types.js").CompactBulletsOptions;

package/types/bullets/normalize.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Normalization utilities for memory bullet metadata.
+ * @import { Tier, Status, Source, Confidence, Bullet, EnsureBulletMetadataOptions } from '../types.js'
+ */
+/**
+ * @param {string | number | null | undefined} value
+ * @returns {string | null}
+ */
+export function safeDateIso(value: string | number | null | undefined): string | null;
+/** @returns {string} */
+export function todayIsoDate(): string;
+/**
+ * @param {string} path
+ * @returns {string}
+ */
+export function inferTopicFromPath(path: string): string;
+/**
+ * @param {string} value
+ * @param {string} [fallback]
+ * @returns {string}
+ */
+export function normalizeTopic(value: string, fallback?: string): string;
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+export function normalizeFactText(value: string): string;
+/**
+ * @param {string | null | undefined} value
+ * @param {Tier} [fallback]
+ * @returns {Tier}
+ */
+export function normalizeTier(value: string | null | undefined, fallback?: Tier): Tier;
+/**
+ * @param {string | null | undefined} value
+ * @param {Status} [fallback]
+ * @returns {Status}
+ */
+export function normalizeStatus(value: string | null | undefined, fallback?: Status): Status;
+/**
+ * @param {string | null | undefined} value
+ * @param {Source} [fallback]
+ * @returns {Source}
+ */
+export function normalizeSource(value: string | null | undefined, fallback?: Source): Source;
+/**
+ * @param {string | null | undefined} value
+ * @param {Confidence} [fallback]
+ * @returns {Confidence}
+ */
+export function normalizeConfidence(value: string | null | undefined, fallback?: Confidence): Confidence;
+/**
+ * @param {Source | string | null | undefined} source
+ * @returns {Confidence}
+ */
+export function defaultConfidenceForSource(source: Source | string | null | undefined): Confidence;
+/**
+ * @param {string} section
+ * @returns {Tier}
+ */
+export function inferTierFromSection(section: string): Tier;
+/**
+ * @param {string} section
+ * @returns {Status}
+ */
+export function inferStatusFromSection(section: string): Status;
+/**
+ * @param {string} value
+ * @returns {Tier}
+ */
+export function normalizeTierToSection(value: string): Tier;
+/**
+ * @param {Partial<Bullet>} bullet
+ * @param {Tier} [fallback]
+ * @returns {Tier}
+ */
+export function inferTierFromBullet(bullet: Partial<Bullet>, fallback?: Tier): Tier;
+/**
+ * @param {Partial<Bullet>} bullet
+ * @param {EnsureBulletMetadataOptions} [options]
+ * @returns {Bullet}
+ */
+export function ensureBulletMetadata(bullet: Partial<Bullet>, options?: EnsureBulletMetadataOptions): Bullet;
+/**
+ * @param {Bullet} bullet
+ * @param {string} [today]
+ * @returns {boolean}
+ */
+export function isExpiredBullet(bullet: Bullet, today?: string): boolean;
+import type { Tier } from '../types.js';
+import type { Status } from '../types.js';
+import type { Source } from '../types.js';
+import type { Confidence } from '../types.js';
+import type { Bullet } from '../types.js';
+import type { EnsureBulletMetadataOptions } from '../types.js';

package/types/bullets/parser.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @param {string} content
+ * @returns {Bullet[]}
+ */
+export function parseBullets(content: string): Bullet[];
+/**
+ * @param {string} content
+ * @returns {number}
+ */
+export function countBullets(content: string): number;
+/**
+ * @param {string} content
+ * @returns {string[]}
+ */
+export function extractTitles(content: string): string[];
+/**
+ * @param {Partial<Bullet>} bullet
+ * @returns {string}
+ */
+export function renderBullet(bullet: Partial<Bullet>): string;
+/**
+ * @param {Bullet[]} working
+ * @param {Bullet[]} longTerm
+ * @param {Bullet[]} history
+ * @param {{ titleTopic?: string }} [options]
+ * @returns {string}
+ */
+export function renderCompactedDocument(working: Bullet[], longTerm: Bullet[], history: Bullet[], options?: {
+    titleTopic?: string;
+}): string;
+import type { Bullet } from '../types.js';

package/types/bullets/scoring.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @param {Partial<Bullet>} bullet
+ * @param {string[]} [queryTerms]
+ * @returns {number}
+ */
+export function scoreBullet(bullet: Partial<Bullet>, queryTerms?: string[]): number;
+/**
+ * @param {string} query
+ * @returns {string[]}
+ */
+export function tokenizeQuery(query: string): string[];
+import type { Bullet } from '../types.js';

package/types/engine/compactor.d.ts

@@ -0,0 +1,27 @@
+export class MemoryCompactor {
+    constructor({ backend, bulletIndex, llmClient, model, onProgress }: {
+        backend: any;
+        bulletIndex: any;
+        llmClient: any;
+        model: any;
+        onProgress: any;
+    });
+    _backend: any;
+    _bulletIndex: any;
+    _llmClient: any;
+    _model: any;
+    _onProgress: any;
+    _running: boolean;
+    _fileSummaries: any[];
+    compactAll(): Promise<{
+        filesChanged: number;
+        filesTotal: any;
+    } | undefined>;
+    _compactFile(path: any, content: any): Promise<any>;
+    /**
+     * Ask the LLM which Working bullets are now stale/completed/superseded.
+     * Returns the same array with superseded bullets marked status=superseded.
+     */
+    _semanticReviewWorking(working: any, longTerm: any, path: any): Promise<any>;
+    _llmRewrite(path: any, raw: any): Promise<any>;
+}

package/types/engine/executors.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Build tool executors for the retrieval (read) flow.
+ * @param {StorageBackend} backend
+ */
+export function createRetrievalExecutors(backend: StorageBackend): {
+    list_directory: ({ dir_path }: {
+        dir_path: any;
+    }) => Promise<string>;
+    retrieve_file: ({ query }: {
+        query: any;
+    }) => Promise<string>;
+    read_file: ({ path }: {
+        path: any;
+    }) => Promise<string>;
+};
+/**
+ * Build tool executors for the extraction (write) flow.
+ * @param {StorageBackend} backend
+ * @param {ExtractionExecutorHooks} [hooks]
+ */
+export function createExtractionExecutors(backend: StorageBackend, hooks?: ExtractionExecutorHooks): {
+    read_file: ({ path }: {
+        path: any;
+    }) => Promise<string>;
+    create_new_file: ({ path, content }: {
+        path: any;
+        content: any;
+    }) => Promise<string>;
+    append_memory: ({ path, content }: {
+        path: any;
+        content: any;
+    }) => Promise<string>;
+    update_memory: ({ path, content }: {
+        path: any;
+        content: any;
+    }) => Promise<string>;
+    archive_memory: ({ path, item_text }: {
+        path: any;
+        item_text: any;
+    }) => Promise<string>;
+    delete_memory: ({ path }: {
+        path: any;
+    }) => Promise<string>;
+};
+import type { StorageBackend } from '../types.js';
+import type { ExtractionExecutorHooks } from '../types.js';

package/types/engine/ingester.d.ts

@@ -0,0 +1,29 @@
+export class MemoryIngester {
+    constructor({ backend, bulletIndex, llmClient, model, onToolCall }: {
+        backend: any;
+        bulletIndex: any;
+        llmClient: any;
+        model: any;
+        onToolCall: any;
+    });
+    _backend: any;
+    _bulletIndex: any;
+    _llmClient: any;
+    _model: any;
+    _onToolCall: any;
+    /**
+     * Ingest memory from a conversation.
+     *
+     * @param {Message[]} messages
+     * @param {IngestOptions} [options]
+     * @returns {Promise<IngestResult>}
+     */
+    ingest(messages: Message[], options?: IngestOptions): Promise<IngestResult>;
+    _buildConversationText(messages: any): string;
+    _buildDocumentText(messages: any): any;
+    _normalizeGeneratedContent(content: any, path: any, updatedAt: any, isDocument?: boolean): any;
+    _mergeWithExisting(existing: any, incoming: any, path: any, updatedAt: any, isDocument?: boolean): string;
+}
+import type { Message } from '../types.js';
+import type { IngestOptions } from '../types.js';
+import type { IngestResult } from '../types.js';

package/types/engine/retriever.d.ts

@@ -0,0 +1,50 @@
+export class MemoryRetriever {
+    constructor({ backend, bulletIndex, llmClient, model, onProgress, onModelText }: {
+        backend: any;
+        bulletIndex: any;
+        llmClient: any;
+        model: any;
+        onProgress: any;
+        onModelText: any;
+    });
+    _backend: any;
+    _bulletIndex: any;
+    _llmClient: any;
+    _model: any;
+    _onProgress: any;
+    _onModelText: any;
+    /**
+     * Retrieve relevant memory context for a user query.
+     *
+     * @param {string} query the user's message text
+     * @param {string} [conversationText] current session text for reference resolution
+     * @returns {Promise<RetrievalResult | null>}
+     */
+    retrieveForQuery(query: string, conversationText?: string): Promise<RetrievalResult | null>;
+    _toolCallingRetrieval(query: any, index: any, onProgress: any, conversationText: any, onModelText: any): Promise<{
+        files: {
+            path: any;
+            content: string;
+        }[];
+        paths: any[];
+        assembledContext: any;
+    } | null>;
+    _textSearchFallbackWithLoad(query: any, onProgress: any, conversationText: any): Promise<{
+        files: {
+            path: any;
+            content: any;
+        }[];
+        paths: any[];
+        assembledContext: string | null;
+    } | null>;
+    _textSearchFallback(query: any): Promise<any[]>;
+    _buildSnippetContext(paths: any, query: any, conversationText: any): Promise<string | null>;
+    _filterRedundantContext(assembledContext: any, conversationText: any): any;
+    _scoreRawLines(content: any, queryTerms: any): {
+        text: string;
+        score: number;
+    }[];
+    _buildRecentContext(conversationText: any): any;
+    _isMemoryEmpty(index: any): Promise<boolean>;
+}
+import type { RetrievalResult } from '../types.js';

package/types/engine/toolLoop.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Run an agentic tool-calling loop.
+ *
+ * @param {ToolLoopOptions} options
+ * @returns {Promise<ToolLoopResult>}
+ */
+export function runAgenticToolLoop(options: ToolLoopOptions): Promise<ToolLoopResult>;
+import type { ToolLoopOptions } from '../types.js';
+import type { ToolLoopResult } from '../types.js';

package/types/imports/chatgpt.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Detect whether parsed JSON is a ChatGPT export.
+ * ChatGPT exports are arrays of objects with `mapping` and `current_node`.
+ * @param {unknown} parsed
+ * @returns {boolean}
+ */
+export function isChatGptExport(parsed: unknown): boolean;
+/**
+ * Parse a ChatGPT export into normalized sessions.
+ * @param {unknown[]} conversations — the parsed JSON array
+ * @returns {ChatGptSession[]}
+ */
+export function parseChatGptExport(conversations: unknown[]): ChatGptSession[];
+import type { ChatGptSession } from '../types.js';

package/types/imports/index.d.ts

@@ -0,0 +1,3 @@
+export { parseMarkdownFiles } from "./markdown.js";
+export { extractSessionsFromOAFastchatExport, extractConversationFromOAFastchatExport, listOAFastchatSessions } from "./oaFastchat.js";
+export { isChatGptExport, parseChatGptExport } from "./chatgpt.js";

package/types/imports/markdown.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Plain markdown file importer.
+ *
+ * Converts markdown files into sessions that can be fed to ingest().
+ * Each file becomes a single-message conversation with the file content
+ * as a user message, so the LLM extracts structured facts from it.
+ *
+ * Usage (library):
+ *   import { parseMarkdownFiles } from '@openanonymity/nanomem/imports'
+ *   const sessions = parseMarkdownFiles([{ path: 'notes/health.md', content: '...' }])
+ *   for (const session of sessions) await mem.ingest(session.messages)
+ *
+ * Usage (CLI):
+ *   memory import notes.md --format markdown
+ *   memory import notes-dir/ --format markdown
+ */
+/** @import { Message, ChatGptSession } from '../types.js' */
+/**
+ * Parse one or more markdown documents into sessions for ingestion.
+ *
+ * Accepts either a single markdown string or an array of { path, content } records
+ * (e.g. from reading a directory of .md files).
+ *
+ * @param {string | { path: string; content: string }[]} input
+ * @returns {ChatGptSession[]}
+ */
+export function parseMarkdownFiles(input: string | {
+    path: string;
+    content: string;
+}[]): ChatGptSession[];
+import type { ChatGptSession } from '../types.js';

package/types/imports/oaFastchat.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @param {any} exportJson
+ * @returns {SessionSummary[]}
+ */
+export function listOAFastchatSessions(exportJson: any): SessionSummary[];
+/**
+ * @param {any} exportJson
+ * @param {{ sessionId?: string, sessionTitle?: string }} [options]
+ * @returns {SessionWithConversation[]}
+ */
+export function extractSessionsFromOAFastchatExport(exportJson: any, options?: {
+    sessionId?: string;
+    sessionTitle?: string;
+}): SessionWithConversation[];
+/**
+ * @param {any} exportJson
+ * @param {{ sessionId?: string, sessionTitle?: string }} [options]
+ * @returns {{ session: SessionSummary | null, sessions: SessionSummary[], conversation: Message[] }}
+ */
+export function extractConversationFromOAFastchatExport(exportJson: any, options?: {
+    sessionId?: string;
+    sessionTitle?: string;
+}): {
+    session: SessionSummary | null;
+    sessions: SessionSummary[];
+    conversation: Message[];
+};
+import type { SessionSummary } from '../types.js';
+import type { SessionWithConversation } from '../types.js';
+import type { Message } from '../types.js';

package/types/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Create a memory instance.
+ *
+ * @param {MemoryBankConfig} [config]
+ * @returns {MemoryBank}
+ */
+export function createMemoryBank(config?: MemoryBankConfig): MemoryBank;
+export * from "./types.js";
+export { createOpenAIClient } from "./llm/openai.js";
+export { createAnthropicClient } from "./llm/anthropic.js";
+export { InMemoryStorage } from "./backends/ram.js";
+export { BaseStorage } from "./backends/BaseStorage.js";
+export { MemoryBulletIndex } from "./bullets/bulletIndex.js";
+export { MemoryRetriever } from "./engine/retriever.js";
+export { MemoryIngester } from "./engine/ingester.js";
+export { MemoryCompactor } from "./engine/compactor.js";
+import type { MemoryBankConfig } from './types.js';
+import type { MemoryBank } from './types.js';
+export { createRetrievalExecutors, createExtractionExecutors } from "./engine/executors.js";
+export { serialize, deserialize, toZip } from "./utils/portability.js";
+export { extractSessionsFromOAFastchatExport, extractConversationFromOAFastchatExport, listOAFastchatSessions } from "./imports/oaFastchat.js";

package/types/llm/anthropic.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Anthropic Messages API client.
+ *
+ * Translates the standard LLM client interface (OpenAI Chat Completions format)
+ * into Anthropic's Messages API format, so the memory system can use Claude models.
+ *
+ * Uses `fetch` (built into Node 18+ and browsers).
+ */
+/** @import { ChatCompletionParams, ChatCompletionResponse, LLMClient, LLMClientOptions, LLMMessage, ToolCall, ToolDefinition } from '../types.js' */
+/**
+ * @param {LLMClientOptions} [options]
+ * @returns {LLMClient}
+ */
+export function createAnthropicClient({ apiKey, baseUrl, headers }?: LLMClientOptions): LLMClient;
+import type { LLMClientOptions } from '../types.js';
+import type { LLMClient } from '../types.js';

package/types/llm/openai.d.ts

@@ -0,0 +1,16 @@
+/**
+ * OpenAI-compatible HTTP client.
+ *
+ * Works with OpenAI, Tinfoil, OpenRouter, or any provider
+ * that implements the OpenAI Chat Completions API format.
+ *
+ * Uses `fetch` (built into Node 18+ and browsers).
+ */
+/** @import { ChatCompletionParams, ChatCompletionResponse, LLMClient, LLMClientOptions, ToolCall } from '../types.js' */
+/**
+ * @param {LLMClientOptions} [options]
+ * @returns {LLMClient}
+ */
+export function createOpenAIClient({ apiKey, baseUrl, headers }?: LLMClientOptions): LLMClient;
+import type { LLMClientOptions } from '../types.js';
+import type { LLMClient } from '../types.js';

package/types/prompt_sets/conversation/ingestion.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Prompt set for conversation ingestion.
+ *
+ * Strict mode: only saves facts the user explicitly stated.
+ * Used when importing chat history, conversation logs, or live sessions.
+ */
+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.\n\nCRITICAL: Only save facts the user explicitly stated. Do NOT infer, extrapolate, or fabricate information.\n\nSave information that is likely to help in a future conversation. Be selective \u2014 only save durable facts, not transient conversation details.\n\nDo NOT save:\n- Anything the user did not explicitly say (no inferences, no extrapolations, no \"likely\" facts)\n- Information already present in existing files (the system deduplicates automatically)\n- Transient details (greetings, \"help me with this\", \"thanks\", questions without lasting answers)\n- The assistant's own reasoning, suggestions, or knowledge \u2014 only what the user stated\n- Sensitive secrets (passwords, auth tokens, private keys, full payment data, government IDs)\n- Opinions the assistant expressed unless the user explicitly agreed with them\n\nCurrent memory index:\n```\n{INDEX}\n```\n\n**Key principle: Prefer fewer, broader files over many narrow ones.** Organize files into folders by domain (e.g. health/, work/, personal/). Within each folder, group related facts into the same file rather than splitting every sub-topic into its own file. Before creating a new file, check whether an existing file in the same domain could absorb the facts. A single file with many bullets on related sub-topics is better than many files with one or two bullets each.\n\nInstructions:\n1. Read the conversation below and identify facts the user explicitly stated.\n2. 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 \u2014 the system deduplicates automatically.\n3. Use this bullet format: \"- Fact text | topic=topic-name | source=SOURCE | confidence=LEVEL | updated_at=YYYY-MM-DD\"\n4. Source values:\n   - source=user_statement \u2014 the user directly said this. This is the PRIMARY source. Use it for the vast majority of saved facts.\n   - source=llm_infer \u2014 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\" \u2192 \"Works in SF\"). Never use this to guess, extrapolate, or fill in gaps. When in doubt, do not save.\n5. Confidence: high for direct user statements, medium for llm_infer. Never save low-confidence items.\n6. 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.\n7. Facts worth saving: allergies, health conditions, location, job/role, tech stack, pets, family members, durable preferences, and active plans \u2014 but ONLY if the user explicitly mentioned them.\n8. If a fact is time-sensitive, include date context in the text. You may optionally add review_at or expires_at.\n9. If nothing new is worth remembering, simply stop without calling any write tools. Saving nothing is better than saving something wrong.\n\nRules:\n- 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.\n- Favor broad thematic files. A file can hold multiple related sub-topics \u2014 only truly unrelated facts need separate files.\n- Only create a new file when nothing in the index is thematically close. When in doubt, append.\n- When creating a new file, choose a broad, thematic name that can absorb future related facts \u2014 not a narrow label for a single detail.\n- Use update_memory only if a fact is now stale or contradicted.\n- 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.\n- If a conflict is ambiguous, preserve both versions rather than deleting one.\n- Do not skip obvious facts just because the schema supports extra metadata.\n- Content should be raw facts only \u2014 no filler commentary.";

package/types/prompt_sets/document/ingestion.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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.
+ */
+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.\n\nUnlike conversation ingestion, you may extract and reasonably infer facts from what the documents show \u2014 not just what was explicitly stated word-for-word. Use good judgment: extract what is clearly supported by the content, avoid speculation.\n\nSave information that would be useful when answering questions about this subject in the future. Be generous \u2014 capture expertise, projects, preferences, philosophy, and patterns that emerge from the documents.\n\nDo NOT save:\n- Speculation or guesses not supported by the content\n- Boilerplate (installation steps, license text, generic disclaimers)\n- Information already present in existing files (use read_file to check first)\n- Sensitive secrets (passwords, auth tokens, private keys)\n\nCurrent memory index:\n```\n{INDEX}\n```\n\n**Key principle: Create a NEW file for each distinct topic.** Organize into domain folders (e.g. projects/, expertise/, education/, philosophy/) with topic-specific files within them.\n\nInstructions:\n1. Read the document content and identify concrete, reusable facts about the subject.\n2. If a matching file already exists in the index, use read_file first to avoid duplicates.\n3. Use create_new_file for new topics, append_memory to add to existing files.\n4. Use this bullet format: \"- Fact text | topic=topic-name | source=SOURCE | confidence=LEVEL | updated_at=YYYY-MM-DD\"\n5. Source values (IMPORTANT \u2014 never use source=user_statement here):\n   - source=document \u2014 the fact is directly stated or clearly shown in the document. Use for the majority of facts.\n   - source=document_infer \u2014 a reasonable inference from what multiple parts of the document collectively show (e.g. a repo with only C files and a README praising simplicity \u2192 \"prefers low-level, minimal implementations\"). Use sparingly.\n6. Confidence: high for source=document facts, medium for source=document_infer.\n7. Facts worth extracting: skills and expertise, projects built, stated opinions and philosophy, tools and languages used, patterns across work, goals and motivations, background and experience.\n8. If nothing meaningful can be extracted from a document, stop without calling any write tools.\n\nRules:\n- 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.\n- One file per distinct topic. Do NOT put unrelated facts in the same file.\n- Create new files freely \u2014 focused files are better than bloated ones.\n- Content should be raw facts only \u2014 no filler commentary.";

package/types/prompt_sets/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Resolve the prompt set for a given mode.
+ * Falls back to 'conversation' for unknown modes.
+ *
+ * @param {string} [mode]
+ * @returns {{ ingestionPrompt: string }}
+ */
+export function resolvePromptSet(mode?: string): {
+    ingestionPrompt: string;
+};
+export const AVAILABLE_MODES: string[];