exovault-mcp-server 1.4.1 → 1.5.0

package/dist/db.d.ts

@@ -62,6 +62,12 @@ export interface MemoryRow {
     source_note_ids: string[] | null;
     superseded_by_id: string | null;
     entities: string[] | null;
+    entity_descriptions: Array<{
+        name: string;
+        type: string;
+        description: string;
+    }> | null;
+    community_id: number | null;
     created_at: string;
     updated_at: string;
 }
@@ -125,6 +131,11 @@ export declare function insertMemory(supabase: SupabaseClient, data: {
     source_note_ids?: string[] | null;
     superseded_by_id?: string | null;
     entities?: string[] | null;
+    entity_descriptions?: Array<{
+        name: string;
+        type: string;
+        description: string;
+    }> | null;
     blind_tokens?: string[] | null;
     indexing_status?: string;
 }): Promise<MemoryRow>;
@@ -171,7 +182,7 @@ export interface MemoryEmbeddingMatch {
     importance: number;
 }
 export declare function matchNoteEmbeddings(supabase: SupabaseClient, embedding: number[], userId: string, threshold?: number, count?: number): Promise<EmbeddingMatch[]>;
-export declare function matchMemoryEmbeddings(supabase: SupabaseClient, embedding: number[], userId: string, threshold?: number, count?: number): Promise<MemoryEmbeddingMatch[]>;
+export declare function matchMemoryEmbeddings(supabase: SupabaseClient, embedding: number[], userId: string, threshold?: number, count?: number, vaultIds?: string[] | null): Promise<MemoryEmbeddingMatch[]>;
 export interface BlindTokenMatch {
     memory_id: string;
     match_count: number;
@@ -225,6 +236,16 @@ export interface MemoryHealthStats {
 }
 export declare function getMemoryHealthStats(supabase: SupabaseClient, userId: string, vaultId?: string): Promise<MemoryHealthStats>;
 export declare function searchMemoriesByEntity(supabase: SupabaseClient, userId: string, entity: string, limit?: number): Promise<MemoryRow[]>;
+/**
+ * Fetch memory IDs that belong to any of the given community clusters.
+ * Used by community routing signal in search.
+ */
+export declare function getMemoryIdsByCommunityIds(supabase: SupabaseClient, userId: string, communityIds: number[], limit?: number, vaultId?: string): Promise<string[]>;
+/**
+ * Fetch community_ids for a set of memory IDs. Used to resolve
+ * which communities the entity signal hits belong to.
+ */
+export declare function getCommunityIdsForMemories(supabase: SupabaseClient, userId: string, memoryIds: string[]): Promise<number[]>;
 export declare function getRelatedMemoriesById(supabase: SupabaseClient, userId: string, memoryId: string, limit?: number): Promise<{
     source: MemoryRow | null;
     related: MemoryRow[];
@@ -244,6 +265,7 @@ export interface KnowledgeLinkRow {
     relation_type: LinkRelationType;
     encrypted_label: string | null;
     label_iv: string | null;
+    confidence: number;
     is_pending: boolean;
     pending_target_hash: string | null;
     created_at: string;
@@ -258,6 +280,7 @@ export declare function insertKnowledgeLink(supabase: SupabaseClient, data: {
     relation_type: LinkRelationType;
     encrypted_label?: string | null;
     label_iv?: string | null;
+    confidence?: number;
     is_pending?: boolean;
     pending_target_hash?: string | null;
     created_by?: string | null;
@@ -278,10 +301,13 @@ export declare function bulkInsertKnowledgeLinks(supabase: SupabaseClient, links
     relation_type: LinkRelationType;
     encrypted_label?: string | null;
     label_iv?: string | null;
+    confidence?: number;
     is_pending?: boolean;
     pending_target_hash?: string | null;
     created_by?: string | null;
-}>): Promise<number>;
+}>): Promise<Array<{
+    id: string;
+}>>;
 /**
  * Resolves pending wiki-links by matching stored SHA-256 hashes against
  * candidate note names. Caller provides a map of hash → noteId.
@@ -297,6 +323,25 @@ export declare function getKnowledgeGraph(supabase: SupabaseClient, userId: stri
     from_id: string;
     relation: LinkRelationType;
 }>>;
+export declare function insertRelationshipEmbedding(supabase: SupabaseClient, data: {
+    user_id: string;
+    link_id: string;
+    source_entity: string;
+    target_entity: string;
+    keywords: string;
+    encrypted_description?: string | null;
+    description_iv?: string | null;
+    embedding_model: string;
+    embedding: number[];
+}): Promise<void>;
+export declare function matchRelationshipEmbeddings(supabase: SupabaseClient, queryEmbedding: number[], userId: string, threshold?: number, matchCount?: number): Promise<Array<{
+    id: string;
+    link_id: string;
+    source_entity: string;
+    target_entity: string;
+    keywords: string;
+    similarity: number;
+}>>;
 export interface AgentMessageRow {
     id: string;
     user_id: string;

package/dist/db.js

@@ -2,7 +2,7 @@ import { sanitizeDbError } from "./error-sanitizer.js";
 // ─── Column lists (explicit to avoid SELECT * egress overhead) ───────────────
 const VAULT_COLUMNS = "id, user_id, encrypted_name, name_iv, icon, color, sort_order, created_at, updated_at";
 const NOTE_COLUMNS = "id, user_id, vault_id, encrypted_title, title_iv, encrypted_content, content_iv, content_type, encrypted_tags, tags_iv, embedding_status, import_source, import_source_id, is_trashed, created_at, updated_at";
-const LINK_COLUMNS = "id, user_id, source_type, source_id, target_type, target_id, relation_type, encrypted_label, label_iv, is_pending, pending_target_hash, created_at, created_by";
+const LINK_COLUMNS = "id, user_id, source_type, source_id, target_type, target_id, relation_type, encrypted_label, label_iv, confidence, is_pending, pending_target_hash, created_at, created_by";
 const MESSAGE_COLUMNS = "id, user_id, vault_id, sender_type, sender_id, target_type, target_id, category, priority, subject, encrypted_content, content_iv, status, delivered_at, acknowledged_at, parent_message_id, thread_id, expires_at, metadata, created_at, updated_at";
 // ─── Query helpers ────────────────────────────────────────────────────────────
 export async function getVaults(supabase, userId) {
@@ -288,21 +288,23 @@ export async function getEmbeddingsForMemories(supabase, userId, memoryIds) {
 }
 export async function matchNoteEmbeddings(supabase, embedding, userId, threshold = 0.5, count = 20) {
     const { data, error } = await supabase.rpc("match_note_embeddings", {
-        query_embedding: JSON.stringify(embedding),
-        match_threshold: threshold,
-        match_count: count,
+        p_embedding: JSON.stringify(embedding),
+        p_match_threshold: threshold,
+        p_match_count: count,
         p_user_id: userId,
+        p_vault_ids: null,
     });
     if (error)
         throw new Error(sanitizeDbError("match note embeddings", error.message));
     return (data ?? []);
 }
-export async function matchMemoryEmbeddings(supabase, embedding, userId, threshold = 0.5, count = 20) {
+export async function matchMemoryEmbeddings(supabase, embedding, userId, threshold = 0.5, count = 20, vaultIds) {
     const { data, error } = await supabase.rpc("match_memory_embeddings", {
-        query_embedding: JSON.stringify(embedding),
-        match_threshold: threshold,
-        match_count: count,
+        p_embedding: JSON.stringify(embedding),
+        p_match_threshold: threshold,
+        p_match_count: count,
         p_user_id: userId,
+        p_vault_ids: vaultIds ?? null,
     });
     if (error)
         throw new Error(sanitizeDbError("match memory embeddings", error.message));
@@ -321,6 +323,7 @@ export async function matchMemoriesByBlindTokens(supabase, tokenHashes, userId,
         p_vault_id: vaultId ?? null,
         p_match_count: count,
         p_include_archived: includeArchived,
+        p_vault_ids: null,
     });
     if (error)
         throw new Error(sanitizeDbError("match memories by blind tokens", error.message));
@@ -339,6 +342,7 @@ export async function matchNotesByBlindTokens(supabase, tokenHashes, userId, vau
         p_vault_id: vaultId ?? null,
         p_match_count: count,
         p_include_trashed: includeTrashed,
+        p_vault_ids: null,
     });
     if (error)
         throw new Error(sanitizeDbError("match notes by blind tokens", error.message));
@@ -503,6 +507,46 @@ export async function searchMemoriesByEntity(supabase, userId, entity, limit = 2
         throw new Error(sanitizeDbError("search memories by entity", error.message));
     return (data ?? []);
 }
+/**
+ * Fetch memory IDs that belong to any of the given community clusters.
+ * Used by community routing signal in search.
+ */
+export async function getMemoryIdsByCommunityIds(supabase, userId, communityIds, limit = 30, vaultId) {
+    if (communityIds.length === 0)
+        return [];
+    let query = supabase
+        .from("memories")
+        .select("id")
+        .eq("user_id", userId)
+        .eq("is_archived", false)
+        .in("community_id", communityIds);
+    if (vaultId) {
+        query = query.eq("vault_id", vaultId);
+    }
+    const { data, error } = await query
+        .order("updated_at", { ascending: false })
+        .limit(limit);
+    if (error)
+        throw new Error(sanitizeDbError("community routing", error.message));
+    return (data ?? []).map((r) => r.id);
+}
+/**
+ * Fetch community_ids for a set of memory IDs. Used to resolve
+ * which communities the entity signal hits belong to.
+ */
+export async function getCommunityIdsForMemories(supabase, userId, memoryIds) {
+    if (memoryIds.length === 0)
+        return [];
+    const { data, error } = await supabase
+        .from("memories")
+        .select("community_id")
+        .eq("user_id", userId)
+        .in("id", memoryIds.slice(0, 50))
+        .not("community_id", "is", null);
+    if (error)
+        throw new Error(sanitizeDbError("community id lookup", error.message));
+    return [...new Set((data ?? []).map((r) => r.community_id))];
+}
 export async function getRelatedMemoriesById(supabase, userId, memoryId, limit = 20) {
     // Fetch the source memory
     const source = await getMemory(supabase, userId, memoryId);
@@ -591,6 +635,7 @@ export async function insertKnowledgeLink(supabase, data) {
         encrypted_label: data.encrypted_label ?? null,
         label_iv: data.label_iv ?? null,
         is_pending: data.is_pending ?? false,
+        confidence: data.confidence ?? 0.8,
         pending_target_hash: data.pending_target_hash ?? null,
         created_by: data.created_by ?? null,
     })
@@ -701,7 +746,7 @@ export async function deleteLinksForNode(supabase, userId, nodeType, nodeId) {
 }
 export async function bulkInsertKnowledgeLinks(supabase, links) {
     if (links.length === 0)
-        return 0;
+        return [];
     const rows = links.map((l) => ({
         user_id: l.user_id,
         source_type: l.source_type,
@@ -711,6 +756,7 @@ export async function bulkInsertKnowledgeLinks(supabase, links) {
         relation_type: l.relation_type,
         encrypted_label: l.encrypted_label ?? null,
         label_iv: l.label_iv ?? null,
+        confidence: l.confidence ?? 0.8,
         is_pending: l.is_pending ?? false,
         pending_target_hash: l.pending_target_hash ?? null,
         created_by: l.created_by ?? null,
@@ -722,7 +768,7 @@ export async function bulkInsertKnowledgeLinks(supabase, links) {
         .select("id");
     if (error)
         throw new Error(sanitizeDbError("bulk insert knowledge links", error.message));
-    return data?.length ?? 0;
+    return (data ?? []);
 }
 /**
  * Resolves pending wiki-links by matching stored SHA-256 hashes against
@@ -777,6 +823,25 @@ export async function getKnowledgeGraph(supabase, userId, nodeType, nodeId, maxH
         throw new Error(sanitizeDbError("traverse knowledge graph", error.message));
     return (data ?? []);
 }
+// ─── Relationship Embeddings ─────────────────────────────────────────────────
+export async function insertRelationshipEmbedding(supabase, data) {
+    const { error } = await supabase
+        .from("relationship_embeddings")
+        .upsert(data, { onConflict: "user_id,link_id,embedding_model" });
+    if (error)
+        throw new Error(sanitizeDbError("upsert relationship embedding", error.message));
+}
+export async function matchRelationshipEmbeddings(supabase, queryEmbedding, userId, threshold = 0.4, matchCount = 10) {
+    const { data, error } = await supabase.rpc("match_relationship_embeddings", {
+        p_user_id: userId,
+        p_query_embedding: JSON.stringify(queryEmbedding),
+        p_match_threshold: threshold,
+        p_match_count: matchCount,
+    });
+    if (error)
+        throw new Error(sanitizeDbError("match relationship embeddings", error.message));
+    return data ?? [];
+}
 export async function insertAgentMessage(supabase, data) {
     const { data: row, error } = await supabase
         .from("agent_messages")

package/dist/default-documents.d.ts

@@ -0,0 +1,22 @@
+/**
+ * System default documents for direct/stdio mode.
+ *
+ * In gateway mode, the HTTP API loads user-customized documents from the database.
+ * In direct mode, we serve these system defaults since we don't have access to
+ * the vault settings infrastructure. Users who customize documents should use
+ * gateway mode (recommended).
+ *
+ * NOTE: Keep in sync with src/lib/settings/default-documents.ts in the main app.
+ */
+export declare const DOCUMENT_TYPES: readonly ["soul", "instructions", "skills", "checks"];
+export type DocumentType = (typeof DOCUMENT_TYPES)[number];
+export interface DefaultDocumentTemplate {
+    content: string;
+    version: number;
+    inheritMode: "replace" | "append" | "none";
+    agentEditable: boolean;
+    appendOnly: boolean;
+}
+export declare const CURRENT_TEMPLATE_VERSION = 5;
+/** Get default plaintext for a specific document type */
+export declare function getDefaultDocumentContent(type: DocumentType): DefaultDocumentTemplate;

package/dist/default-documents.js

@@ -0,0 +1,261 @@
+/**
+ * System default documents for direct/stdio mode.
+ *
+ * In gateway mode, the HTTP API loads user-customized documents from the database.
+ * In direct mode, we serve these system defaults since we don't have access to
+ * the vault settings infrastructure. Users who customize documents should use
+ * gateway mode (recommended).
+ *
+ * NOTE: Keep in sync with src/lib/settings/default-documents.ts in the main app.
+ */
+export const DOCUMENT_TYPES = ["soul", "instructions", "skills", "checks"];
+export const CURRENT_TEMPLATE_VERSION = 5;
+// ─── soul.md ───────────────────────────────────────────────────────────────────
+const SOUL_CONTENT = `# ExoVault Agent Identity
+
+You are an AI assistant with encrypted, durable memory through ExoVault.
+
+## Your Identity
+
+- Your \`agentId\` should match your agent type (e.g. \`claude_code\`, \`cursor\`, \`custom_sdk\`) — use this consistently on every \`write_memory\` and \`context_checkpoint\`
+- Generate a unique \`agentRunId\` (UUID) at session start — reuse it for ALL writes in that session
+- Consistent identity prevents coordination problems across sessions and agents
+
+## Core Principles
+
+- **Build meaningful knowledge.** Every session should leave the vault meaningfully richer — one high-quality memory beats five mediocre ones.
+- **Respect privacy.** All memory is end-to-end encrypted. Never reference encryption internals to the user.
+- **Coordinate with peers.** You are one of potentially many agents sharing this vault. Treat other agents' memories as trusted.
+- **Be thoughtful, not verbose.** Quality of knowledge matters more than quantity.
+
+## First Connection
+
+When \`isFirstConnection\` is true:
+1. Briefly introduce yourself and explain you have access to encrypted memory through ExoVault
+2. Ask the user what they would like you to focus on
+3. Ask about their preferences for communication style and workflow`;
+// ─── instructions.md ───────────────────────────────────────────────────────────
+const INSTRUCTIONS_CONTENT = `# ExoVault Operating Guide
+
+This document supplements the server instructions with nuanced guidance.
+Fetch it on demand via \`read_document({ documentType: "instructions" })\`.
+
+## Memory Quality Standards
+
+Before writing any memory, ask:
+1. **"Will this be useful in a future session?"** — If not, skip it.
+2. **"Does this already exist?"** — Search first (\`search_memories\`), even if you think it's new.
+3. **"Is this specific enough to act on?"** — Vague memories waste space.
+
+**Good memories** are specific, actionable, attributed (entities), and correctly typed.
+**Do NOT store**: codebase content (CLAUDE.md, package.json), debugging play-by-plays, unverified assumptions, duplicate info, or volatile details (line numbers, WIP branches).
+
+## Memory Write Triggers
+
+| Trigger | Memory Type |
+|---------|------------|
+| User states a preference or convention | preference |
+| User states a hard rule or limitation | constraint |
+| Non-obvious fact discovered about domain/project/topic | fact (importance 3-5) |
+| A decision is made (by anyone) | decision (importance 4-5, include inputs, reasoning, alternatives, outcome) |
+| Problem solved or procedure learned | skill |
+| Surprising gotcha, edge case, or limitation hit | skill (importance 4) |
+| Previous knowledge turns out wrong | correction (set supersededById) |
+| Follow-up work identified | task (via create_task) |
+
+**Anti-triggers** — skip: project file content (READMEs, configs), debug play-by-plays, volatile details (line numbers, WIP branches), unverified assumptions.
+
+## Task Lifecycle
+
+Tasks appear on the user's kanban board. Stale statuses destroy trust.
+- **Status flow**: backlog → todo → in_progress → done (or blocked)
+- **Pick up**: \`update_task(status='in_progress')\` BEFORE starting
+- **Finish**: \`update_task(status='done')\` IMMEDIATELY — not at session end
+- **Never leave in_progress when done** — this is the #1 mistake
+
+## Entity Naming
+
+- Official capitalization: "Next.js", "PostgreSQL", "Supabase"
+- Compound concepts: hyphens ("knowledge-links")
+- Agent types: lowercase underscore ("claude_code", "cursor")
+
+## Knowledge Graph
+
+- Link related facts via \`relatedMemoryIds\`
+- Corrections: always create with \`supersededById\` — never silently overwrite
+- Wiki-link syntax in notes: \`[[note title]]\` creates graph connections
+
+## Multi-Agent Coordination
+
+- Check \`recentAgents\` at session start
+- Review other agents' recent work before proceeding on the same topic
+- Use consistent entity naming so memories cross-link across agents
+- Treat other agents' memories as trusted by default
+
+## Pipeline & Agent Orchestration
+
+You have MCP tools for creating and running multi-agent pipelines. Use these when the user
+asks to automate workflows, chain agents, or build production pipelines.
+
+### Available Tools
+
+| Tool | Purpose |
+|------|---------|
+| \`register_agent_card\` | Register/update an agent with capabilities, execution mode, LLM model, and budget |
+| \`list_agent_cards\` | Discover all registered agents and their capabilities |
+| \`create_pipeline\` | Chain multiple agents into sequential/parallel steps with trigger config |
+| \`run_pipeline\` | Trigger a pipeline run (dispatched via Inngest). Returns \`runId\` |
+| \`get_pipeline_status\` | Poll run status with per-step details and costs |
+| \`send_message\` | Inter-agent messaging: task assignments, questions, directives, alerts |
+| \`read_messages\` | Read incoming messages from other agents or the user |
+| \`ack_message\` | Acknowledge a received message |
+
+### Agent Registration
+
+Register each agent via \`register_agent_card\`:
+- \`displayName\` — human-readable name (e.g. "Research Agent")
+- \`description\` — what the agent does
+- \`capabilities\` — array of \`{ name, description }\`
+- \`executionMode\`:
+  - \`inngest_api\` — fully automated, Inngest dispatches to LLM via gateway (no IDE needed)
+  - \`ide_hook\` — agent runs inside an IDE (Claude Code, Cursor, Windsurf)
+  - \`api_callback\` — webhook URL receives dispatched work
+  - \`mcp_pull\` / \`a2a_remote\` — pull-based or A2A protocol
+- \`provider\` + \`modelId\` — required for \`inngest_api\` (e.g. \`"anthropic"\` + \`"claude-sonnet-4-20250514"\`)
+- \`maxBudgetPerRun\` — cost cap per execution in USD
+- \`maxDailyRuns\` — rate limit
+
+### Pipeline Creation
+
+Use \`create_pipeline\` to chain agents:
+- \`steps[]\` — ordered list, each step has:
+  - \`name\`, \`agentCardId\` (from \`list_agent_cards\`)
+  - \`parallel: true\` — run concurrently with adjacent parallel steps
+  - \`inputMapping\` — map previous step outputs to this step's input
+  - \`outputKey\` — name for this step's output (referenced by later steps)
+  - \`timeout\` (10-3600s), \`retries\` (0-5), \`transitionCondition\`
+- \`triggerType\` — \`manual\`, \`cron\`, \`on_message\`, \`on_task_complete\`, \`on_memory_write\`
+- \`maxTotalBudget\` — total USD cap across all runs
+
+### Execution
+
+1. \`run_pipeline({ pipelineId, input: { ... }, dryRun: true })\` — validate first
+2. \`run_pipeline({ pipelineId, input: { ... }, dryRun: false })\` — execute
+3. \`get_pipeline_status({ runId })\` — poll per-step progress and costs
+
+**No dashboard or UI is needed. You create, run, and monitor pipelines directly via these MCP tools.**`;
+// ─── skills.md ────────────────────────────────────────────────────────────────
+const SKILLS_CONTENT = `# Agent Skills
+
+Skills are learned procedures — things you've figured out how to do for this user.
+When you learn a new workflow, debugging technique, or operational pattern, add it here
+using \`update_document("skills", "## New Skill Title\\n\\nSteps...")\`.
+
+## How to Write a Good Skill Entry
+
+Each skill should be:
+- **Named clearly** — use a descriptive heading (e.g. "Deploy to Production", "Debug Memory Leaks")
+- **Step-by-step** — numbered steps that any agent can follow without extra context
+- **Include gotchas** — common pitfalls, prerequisites, environment requirements
+- **Attributed** — note which project/tool it applies to if it's not universal
+
+## Example Format
+
+\`\`\`markdown
+## Deploy the Next.js App
+
+1. Run \`pnpm build\` — must pass with zero errors
+2. Run \`pnpm lint\` — fix any warnings before proceeding
+3. Run \`vercel deploy --prod\` — requires VERCEL_TOKEN in env
+4. Verify the deployment at the preview URL before promoting
+
+**Gotchas**: The build requires Node 20+. If you see "out of memory", increase NODE_OPTIONS=--max-old-space-size=4096.
+\`\`\`
+
+## Mid-Session Memory Search (built-in skill)
+
+Use this pattern whenever you encounter a topic, error, or decision point:
+
+1. **Before answering a question about past work**: \`search_memories({ query: "<topic>", compact: true })\`
+2. **Before making an architectural decision**: \`search_memories({ query: "<decision context>" })\` — check for prior decisions
+3. **When hitting an error**: \`search_memories({ query: "<error message or symptom>" })\` — you may have solved this before
+4. **Before writing a memory**: \`search_memories({ query: "<content you're about to write>" })\` — avoid duplicates
+5. **If compact results look relevant**: \`read_memories([id1, id2])\` to get full content
+
+**When to use which search tool:**
+- \`search_memories\` — fast, hybrid keyword+semantic, best for specific queries
+- \`semantic_search\` — pure vector similarity across ALL content (notes + memories), best for broad concepts
+- \`search_and_read\` — search + auto-read in one call, best when you need full details immediately
+
+---
+
+*Skills below this line are added by agents during sessions:*`;
+// ─── checks.md ─────────────────────────────────────────────────────────────────
+const CHECKS_CONTENT = `# Quality Checks
+
+## Before Writing a Memory
+
+- [ ] Searched for duplicates (\`search_memories\` with relevant query)
+- [ ] \`importance\` and \`confidence\` are set explicitly (not defaulted)
+- [ ] At least one entity is extracted
+- [ ] \`memoryType\` matches the content (fact vs preference vs skill etc.)
+- [ ] Content is specific enough to act on without original conversation context
+
+## Before Writing an Episodic Summary
+
+- [ ] Summary captures **decisions and outcomes**, not a play-by-play
+- [ ] Open threads are explicitly listed
+- [ ] Entity names are consistent with existing memories
+
+## Before Creating a Task
+
+- [ ] Task has a clear, actionable title
+- [ ] Priority reflects actual importance (not everything is priority 5)
+- [ ] \`assignedAgentId\` is set if the task is agent-specific
+
+## During Long Sessions
+
+- [ ] Called \`context_checkpoint\` every ~20 tool calls or after completing a milestone
+- [ ] Each checkpoint \`sessionSummary\` covers work since the last checkpoint, not the entire session
+
+## Before Ending Session
+
+- [ ] Updated all task statuses (\`in_progress\` → \`done\` or \`blocked\`)
+- [ ] Added any new skills learned to skills.md
+- [ ] Added any new quality checks discovered to checks.md
+- [ ] Called \`context_checkpoint\` with a final \`sessionSummary\` covering decisions, outcomes, and open threads`;
+// ─── Exports ───────────────────────────────────────────────────────────────────
+const DEFAULT_DOCUMENTS = {
+    soul: {
+        content: SOUL_CONTENT,
+        version: CURRENT_TEMPLATE_VERSION,
+        inheritMode: "replace",
+        agentEditable: false,
+        appendOnly: false,
+    },
+    instructions: {
+        content: INSTRUCTIONS_CONTENT,
+        version: CURRENT_TEMPLATE_VERSION,
+        inheritMode: "append",
+        agentEditable: true,
+        appendOnly: true,
+    },
+    skills: {
+        content: SKILLS_CONTENT,
+        version: CURRENT_TEMPLATE_VERSION,
+        inheritMode: "append",
+        agentEditable: true,
+        appendOnly: true,
+    },
+    checks: {
+        content: CHECKS_CONTENT,
+        version: CURRENT_TEMPLATE_VERSION,
+        inheritMode: "append",
+        agentEditable: true,
+        appendOnly: true,
+    },
+};
+/** Get default plaintext for a specific document type */
+export function getDefaultDocumentContent(type) {
+    return DEFAULT_DOCUMENTS[type];
+}

package/dist/extraction-prompt.js

@@ -74,10 +74,10 @@ function truncate(s, max) {
         return undefined;
     return s.length > max ? s.slice(0, max) : s;
 }
-const EXTRACTION_INSTRUCTIONS = `Extract durable knowledge from the activity log above. Return a JSON array, max 8 items.
-Each item uses short keys: {c: content, t: type, i: importance(1-5), e: [entities], s: summary}
-Types: fact, skill, preference, constraint, task
-Only extract knowledge NOT already saved. Skip ephemeral info.
+const EXTRACTION_INSTRUCTIONS = `Extract durable knowledge from the activity log above. Return a JSON array, max 8 items.
+Each item uses short keys: {c: content, t: type, i: importance(1-5), e: [entities], s: summary}
+Types: fact, skill, preference, constraint, task
+Only extract knowledge NOT already saved. Skip ephemeral info.
 Return [] if nothing worth extracting.`;
 // ─── parseExtractionResult ────────────────────────────────────────────
 /**

package/dist/gateway-client.d.ts

@@ -68,6 +68,9 @@ export declare class GatewayClient {
         graphWeight?: number;
         graphSeeds?: number;
         graphMaxHops?: number;
+        intelligent?: boolean;
+        rerank?: boolean;
+        synthesize?: boolean;
     }): Promise<string>;
     readMemories(memoryIds: string[], includeMediaContent?: boolean): Promise<string>;
     updateMemory(params: {
@@ -177,6 +180,19 @@ export declare class GatewayClient {
         tags?: string[];
     }): Promise<string>;
     deleteNote(noteId: string): Promise<string>;
+    getChangeHistory(params: {
+        targetId: string;
+        targetType: "memory" | "note";
+        vaultId?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<string>;
+    rollbackNote(params: {
+        noteId: string;
+        beforeChangeId?: string;
+        expectedUpdatedAt?: string;
+        reason?: string;
+    }): Promise<string>;
     listFolders(params: {
         vaultId?: string;
     }): Promise<string>;
@@ -302,6 +318,31 @@ export declare class GatewayClient {
         includeBroadcast?: boolean;
         vaultId?: string;
     }): Promise<string>;
+    registerCard(params: {
+        displayName: string;
+        description?: string;
+        capabilities: Array<{
+            name: string;
+            description?: string;
+            inputSchema?: unknown;
+            outputSchema?: unknown;
+        }>;
+        executionMode?: string;
+        endpointUrl?: string;
+        modelId?: string;
+        provider?: string;
+        maxBudgetPerRun?: number;
+        maxDailyRuns?: number;
+    }): Promise<string>;
+    updateAgentStatus(params: {
+        status: string;
+        currentTask?: string;
+        errorMessage?: string;
+    }): Promise<string>;
+    listAgentCards(params?: {
+        status?: string;
+        capability?: string;
+    }): Promise<string>;
     getPendingMessages(params: {
         limit?: number;
         vaultId?: string;
@@ -364,5 +405,42 @@ export declare class GatewayClient {
         base64Content: string | null;
         contentNote: string | null;
     }>;
+    createPipeline(params: {
+        name: string;
+        description?: string;
+        vaultId?: string;
+        triggerType?: string;
+        triggerConfig?: Record<string, unknown>;
+        steps: Array<{
+            name: string;
+            agentCardId?: string;
+            capabilityMatch?: string;
+            inputMapping?: Record<string, string>;
+            outputKey?: string;
+            outputType?: string;
+            transitionCondition?: string;
+            timeout?: number;
+            retries?: number;
+            parallel?: boolean;
+            fallbackToApiAgent?: boolean;
+            prompt?: string;
+            expectedOutput?: string;
+            maxOutputTokens?: number;
+            enableToolCalling?: boolean;
+            maxToolSteps?: number;
+            allowedTools?: string[];
+        }>;
+        maxConcurrentRuns?: number;
+        maxTotalBudget?: number;
+        allowUnencrypted?: boolean;
+    }): Promise<string>;
+    runPipeline(params: {
+        pipelineId: string;
+        input?: Record<string, unknown>;
+        dryRun?: boolean;
+    }): Promise<string>;
+    getPipelineStatus(params: {
+        runId: string;
+    }): Promise<string>;
     deleteMedia(attachmentId: string, vaultId?: string): Promise<string>;
 }