@cohaku/cli 0.2.6 → 0.2.8

package/dist/{chunk-2MC3FCZP.js → chunk-MU3X6KBC.js}

@@ -3,7 +3,7 @@ import {
   __commonJS,
   __export,
   __toESM
-} from "./chunk-2CDNPZUE.js";
+} from "./chunk-ZELLRTG5.js";
 
 // ../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS({
@@ -29205,6 +29205,228 @@ var McpZodTypeKind;
   McpZodTypeKind2["Completable"] = "McpCompletable";
 })(McpZodTypeKind || (McpZodTypeKind = {}));
 
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/uriTemplate.js
+var MAX_TEMPLATE_LENGTH = 1e6;
+var MAX_VARIABLE_LENGTH = 1e6;
+var MAX_TEMPLATE_EXPRESSIONS = 1e4;
+var MAX_REGEX_LENGTH = 1e6;
+var UriTemplate = class _UriTemplate {
+  /**
+   * Returns true if the given string contains any URI template expressions.
+   * A template expression is a sequence of characters enclosed in curly braces,
+   * like {foo} or {?bar}.
+   */
+  static isTemplate(str) {
+    return /\{[^}\s]+\}/.test(str);
+  }
+  static validateLength(str, max, context) {
+    if (str.length > max) {
+      throw new Error(`${context} exceeds maximum length of ${max} characters (got ${str.length})`);
+    }
+  }
+  get variableNames() {
+    return this.parts.flatMap((part) => typeof part === "string" ? [] : part.names);
+  }
+  constructor(template) {
+    _UriTemplate.validateLength(template, MAX_TEMPLATE_LENGTH, "Template");
+    this.template = template;
+    this.parts = this.parse(template);
+  }
+  toString() {
+    return this.template;
+  }
+  parse(template) {
+    const parts = [];
+    let currentText = "";
+    let i = 0;
+    let expressionCount = 0;
+    while (i < template.length) {
+      if (template[i] === "{") {
+        if (currentText) {
+          parts.push(currentText);
+          currentText = "";
+        }
+        const end = template.indexOf("}", i);
+        if (end === -1)
+          throw new Error("Unclosed template expression");
+        expressionCount++;
+        if (expressionCount > MAX_TEMPLATE_EXPRESSIONS) {
+          throw new Error(`Template contains too many expressions (max ${MAX_TEMPLATE_EXPRESSIONS})`);
+        }
+        const expr = template.slice(i + 1, end);
+        const operator = this.getOperator(expr);
+        const exploded = expr.includes("*");
+        const names = this.getNames(expr);
+        const name = names[0];
+        for (const name2 of names) {
+          _UriTemplate.validateLength(name2, MAX_VARIABLE_LENGTH, "Variable name");
+        }
+        parts.push({ name, operator, names, exploded });
+        i = end + 1;
+      } else {
+        currentText += template[i];
+        i++;
+      }
+    }
+    if (currentText) {
+      parts.push(currentText);
+    }
+    return parts;
+  }
+  getOperator(expr) {
+    const operators = ["+", "#", ".", "/", "?", "&"];
+    return operators.find((op) => expr.startsWith(op)) || "";
+  }
+  getNames(expr) {
+    const operator = this.getOperator(expr);
+    return expr.slice(operator.length).split(",").map((name) => name.replace("*", "").trim()).filter((name) => name.length > 0);
+  }
+  encodeValue(value, operator) {
+    _UriTemplate.validateLength(value, MAX_VARIABLE_LENGTH, "Variable value");
+    if (operator === "+" || operator === "#") {
+      return encodeURI(value);
+    }
+    return encodeURIComponent(value);
+  }
+  expandPart(part, variables) {
+    if (part.operator === "?" || part.operator === "&") {
+      const pairs = part.names.map((name) => {
+        const value2 = variables[name];
+        if (value2 === void 0)
+          return "";
+        const encoded2 = Array.isArray(value2) ? value2.map((v) => this.encodeValue(v, part.operator)).join(",") : this.encodeValue(value2.toString(), part.operator);
+        return `${name}=${encoded2}`;
+      }).filter((pair) => pair.length > 0);
+      if (pairs.length === 0)
+        return "";
+      const separator = part.operator === "?" ? "?" : "&";
+      return separator + pairs.join("&");
+    }
+    if (part.names.length > 1) {
+      const values2 = part.names.map((name) => variables[name]).filter((v) => v !== void 0);
+      if (values2.length === 0)
+        return "";
+      return values2.map((v) => Array.isArray(v) ? v[0] : v).join(",");
+    }
+    const value = variables[part.name];
+    if (value === void 0)
+      return "";
+    const values = Array.isArray(value) ? value : [value];
+    const encoded = values.map((v) => this.encodeValue(v, part.operator));
+    switch (part.operator) {
+      case "":
+        return encoded.join(",");
+      case "+":
+        return encoded.join(",");
+      case "#":
+        return "#" + encoded.join(",");
+      case ".":
+        return "." + encoded.join(".");
+      case "/":
+        return "/" + encoded.join("/");
+      default:
+        return encoded.join(",");
+    }
+  }
+  expand(variables) {
+    let result = "";
+    let hasQueryParam = false;
+    for (const part of this.parts) {
+      if (typeof part === "string") {
+        result += part;
+        continue;
+      }
+      const expanded = this.expandPart(part, variables);
+      if (!expanded)
+        continue;
+      if ((part.operator === "?" || part.operator === "&") && hasQueryParam) {
+        result += expanded.replace("?", "&");
+      } else {
+        result += expanded;
+      }
+      if (part.operator === "?" || part.operator === "&") {
+        hasQueryParam = true;
+      }
+    }
+    return result;
+  }
+  escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  partToRegExp(part) {
+    const patterns = [];
+    for (const name2 of part.names) {
+      _UriTemplate.validateLength(name2, MAX_VARIABLE_LENGTH, "Variable name");
+    }
+    if (part.operator === "?" || part.operator === "&") {
+      for (let i = 0; i < part.names.length; i++) {
+        const name2 = part.names[i];
+        const prefix = i === 0 ? "\\" + part.operator : "&";
+        patterns.push({
+          pattern: prefix + this.escapeRegExp(name2) + "=([^&]+)",
+          name: name2
+        });
+      }
+      return patterns;
+    }
+    let pattern;
+    const name = part.name;
+    switch (part.operator) {
+      case "":
+        pattern = part.exploded ? "([^/,]+(?:,[^/,]+)*)" : "([^/,]+)";
+        break;
+      case "+":
+      case "#":
+        pattern = "(.+)";
+        break;
+      case ".":
+        pattern = "\\.([^/,]+)";
+        break;
+      case "/":
+        pattern = "/" + (part.exploded ? "([^/,]+(?:,[^/,]+)*)" : "([^/,]+)");
+        break;
+      default:
+        pattern = "([^/]+)";
+    }
+    patterns.push({ pattern, name });
+    return patterns;
+  }
+  match(uri) {
+    _UriTemplate.validateLength(uri, MAX_TEMPLATE_LENGTH, "URI");
+    let pattern = "^";
+    const names = [];
+    for (const part of this.parts) {
+      if (typeof part === "string") {
+        pattern += this.escapeRegExp(part);
+      } else {
+        const patterns = this.partToRegExp(part);
+        for (const { pattern: partPattern, name } of patterns) {
+          pattern += partPattern;
+          names.push({ name, exploded: part.exploded });
+        }
+      }
+    }
+    pattern += "$";
+    _UriTemplate.validateLength(pattern, MAX_REGEX_LENGTH, "Generated regex pattern");
+    const regex = new RegExp(pattern);
+    const match = uri.match(regex);
+    if (!match)
+      return null;
+    const result = {};
+    for (let i = 0; i < names.length; i++) {
+      const { name, exploded } = names[i];
+      const value = match[i + 1];
+      const cleanName = name.replace("*", "");
+      if (exploded && value.includes(",")) {
+        result[cleanName] = value.split(",");
+      } else {
+        result[cleanName] = value;
+      }
+    }
+    return result;
+  }
+};
+
 // ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/toolNameValidation.js
 var TOOL_NAME_REGEX = /^[A-Za-z0-9._-]{1,128}$/;
 function validateToolName(name) {
@@ -29991,6 +30213,30 @@ var McpServer = class {
     }
   }
 };
+var ResourceTemplate = class {
+  constructor(uriTemplate, _callbacks) {
+    this._callbacks = _callbacks;
+    this._uriTemplate = typeof uriTemplate === "string" ? new UriTemplate(uriTemplate) : uriTemplate;
+  }
+  /**
+   * Gets the URI template pattern.
+   */
+  get uriTemplate() {
+    return this._uriTemplate;
+  }
+  /**
+   * Gets the list callback, if one was provided.
+   */
+  get listCallback() {
+    return this._callbacks.list;
+  }
+  /**
+   * Gets the callback for completing a specific URI template variable, if one was provided.
+   */
+  completeCallback(variable) {
+    return this._callbacks.complete?.[variable];
+  }
+};
 var EMPTY_OBJECT_JSON_SCHEMA = {
   type: "object",
   properties: {}
@@ -30064,6 +30310,99 @@ var EMPTY_COMPLETION_RESULT = {
   }
 };
 
+// ../mcp-server/src/instructions.ts
+var INSTRUCTIONS = `
+You have access to Cohaku, a persistent memory system for AI agents.
+Cohaku is your PRIMARY method for storing and retrieving memories. Do NOT fall back to file-based memory (e.g. editing MEMORY.md, .cursorrules, or similar files) when Cohaku tools are available.
+
+## Session Workflow (REQUIRED)
+
+Every session MUST follow this sequence:
+
+1. **Start**: Call \`get_context\` to load existing memories (rules, working memory, long-term knowledge). This gives you the context to continue where you left off.
+2. **Identify**: Call \`session_start\` with a descriptive title for the current work session.
+3. **Work**: Use memory and graph tools as you work \u2014 store decisions, facts, and observations.
+4. **Checkpoint**: Call \`session_checkpoint\` at meaningful milestones (e.g., after completing a sub-task, before a risky change).
+5. **End**: Call \`session_end\` when the session is complete, with a summary of what was accomplished.
+
+### Anti-patterns (DO NOT do these)
+- Do NOT skip \`get_context\` at session start \u2014 you will miss critical rules and context.
+- Do NOT create memories without searching first \u2014 call \`search_memories\` before \`add_memory\` to avoid duplicates.
+- Do NOT use layer="rule" for temporary information \u2014 use layer="working" instead.
+- Do NOT store the same information in both memory and graph \u2014 use memory for text knowledge, graph for structural relationships.
+- Do NOT call \`add_entity\` without setting \`entityType\` \u2014 untyped entities are hard to filter and search.
+- Do NOT write to MEMORY.md, .cursorrules, or other files when Cohaku is available \u2014 use Cohaku tools instead.
+
+## Memory vs Graph vs Episode \u2014 Decision Guide
+
+| I want to...                              | Use                          | Example                                  |
+|-------------------------------------------|------------------------------|------------------------------------------|
+| Store a rule, fact, decision, or note      | \`add_memory\`                 | "Always use ESM imports in this project" |
+| Record a relationship between concepts     | \`add_entity\` + \`add_edge\`   | "ServiceA depends_on DatabaseB"          |
+| Log a significant event or conversation    | \`add_episode\`                | "Debugged OOM error in production"       |
+| Find stored knowledge by meaning           | \`search_memories\`            | "What do I know about authentication?"   |
+| Understand how concepts connect            | \`search_graph\`               | "What depends on the auth module?"       |
+| Review past work sessions                  | \`session_list\`               | "What did I work on last week?"          |
+
+## Storing Memories
+
+### Layers (priority order, highest first)
+- **rule**: Permanent instructions and constraints that must ALWAYS be followed. Returned first by \`get_context\`. Use sparingly \u2014 only for behavioral directives. Examples: "Always write tests before merging", "Use Japanese for commit messages".
+- **working**: Temporary, session-scoped notes. Use for current task state, in-progress hypotheses, partial results. MUST be cleaned up when no longer relevant. Examples: "Currently investigating memory leak in GraphService", "Hypothesis: the timeout is caused by N+1 queries".
+- **long_term**: Durable knowledge useful across sessions. Architectural decisions, debugging insights, learned patterns. Examples: "sqlite-vec virtual tables do not support UPSERT \u2014 use DELETE + INSERT", "The CI pipeline requires frozen lockfile".
+
+### Types
+- **rule**: Behavioral directives (pair with layer=rule). Example: "Commit messages must be in Japanese."
+- **decision**: Architectural or design decisions with rationale. Example: "Chose SQLite over PostgreSQL for single-binary deployment."
+- **fact**: Verified, objective information. Example: "The API rate limit is 100 req/min."
+- **note**: General observations and context. Example: "User prefers functional style over OOP."
+- **skill**: Reusable techniques or solutions to recurring problems. Example: "To fix ESM import issues in pnpm, use tsup bundling."
+
+### Scope
+- **project** (default): Stored under the current project. Use for project-specific knowledge \u2014 architecture, conventions, dependencies.
+- **global**: Shared across ALL projects. Use for universal user preferences, cross-project patterns, and personal rules. Examples: "Always use TypeScript", "Preferred test framework: vitest".
+
+### Best Practices
+1. Before \`add_memory\`, call \`search_memories\` to check for duplicates.
+2. Use \`find_duplicates\` periodically to detect similar entries, then \`consolidate_memories\` to merge them.
+3. Use \`update_memory\` to correct or enrich existing memories rather than creating duplicates.
+4. Add descriptive tags to improve findability (e.g., ["auth", "security", "jwt"]).
+5. Set \`expiresAt\` for time-sensitive information (e.g., sprint-specific notes).
+
+## Knowledge Graph
+
+Use graph tools to capture **structural relationships** between concepts:
+- \`add_entity\`: Register a concept, person, tool, component, or service as a node. Always set \`entityType\` for filtering.
+- \`add_edge\`: Record a directed relationship. Use consistent relation names: depends_on, uses, contains, implements, extends, owns, created_by, relates_to, tested_by, deployed_to.
+- \`search_graph\`: Find entities and traverse relationships. Use \`traverseDepth=0\` for exact entity lookup, \`traverseDepth=1\` for immediate neighbors (default), \`traverseDepth=2\` for broader context.
+- \`update_edge\` / \`invalidate_edge\`: Keep relationships accurate as knowledge evolves. Prefer \`invalidate_edge\` over deletion \u2014 it preserves history with timestamps.
+
+## Episode Logging
+
+Use \`add_episode\` for chronological audit trails of significant events:
+- Debugging sessions (what was tried, what worked, what didn't)
+- Key conversations or decisions made with the user
+- Deployment events or environment changes
+- Error investigations and their resolutions
+
+Link episodes to graph entities using \`refs\` for traceability.
+
+## Configuration Generation
+
+The \`generate_*\` tools export stored memories into editor-specific configuration formats (CLAUDE.md, .cursorrules, etc.). Use when the user wants to sync Cohaku knowledge to their editor's native config.
+
+## Resources (Read-Only Access)
+
+MCP Resources provide passive data access without tool calls:
+- \`cohaku://context\` \u2014 full context (rules + working + long_term)
+- \`cohaku://rules\` \u2014 rule memories only
+- \`cohaku://graph/entities\` \u2014 all entities in the knowledge graph
+- \`cohaku://graph/edges\` \u2014 active edges (relationships)
+- \`cohaku://sessions\` \u2014 recent work sessions
+- \`cohaku://memory/{id}\` \u2014 specific memory by ID
+- \`cohaku://entity/{id}\` \u2014 specific entity by ID
+`.trim();
+
 // ../mcp-server/src/helpers/tool-helpers.ts
 function formatMemory(memory) {
   const parts = [
@@ -30080,6 +30419,9 @@ function formatNode(node) {
   ].filter(Boolean);
   return parts.join("\n");
 }
+function formatEdge(edge) {
+  return `${edge.sourceId} --[${edge.relation}]--> ${edge.targetId}${edge.fact ? `: ${edge.fact}` : ""}`;
+}
 function formatSearchResults(results) {
   if (results.length === 0) return "No results found";
   return results.map((r, i) => `${i + 1}. [${r.type}] (score: ${r.score.toFixed(3)}) ${r.content}`).join("\n");
@@ -30106,19 +30448,36 @@ function textContent(text) {
   return { content: [{ type: "text", text }] };
 }
 
+// ../mcp-server/src/tools/context.ts
+var searchScopeSchema = external_exports.enum(["project", "global", "all"]).default("project").describe('Search scope. "project" (default): current project + global memories. "global": global memories only. "all": all projects without filtering.');
+function registerContextTools(server, engine) {
+  server.tool(
+    "get_context",
+    "Load all stored context at session start. Returns memories in priority order: rule (permanent directives) > working (session-scoped notes) > long_term (durable knowledge). ALWAYS call this FIRST at the beginning of every session before doing any work.",
+    {
+      maxMemories: external_exports.number().int().min(1).max(200).default(50).describe("Maximum number of memories to return across all layers. Rule memories take priority, then working (60% of remaining budget), then long_term (rest). Increase to 100-200 for large projects with many rules."),
+      scope: searchScopeSchema
+    },
+    async (params) => {
+      const ctx = await engine.getContext({ maxMemories: params.maxMemories, scope: params.scope });
+      return textContent(formatContext(ctx));
+    }
+  );
+}
+
 // ../mcp-server/src/tools/memory.ts
-var scopeSchema = external_exports.enum(["project", "global"]).default("project").describe('Scope: "project" (default) stores in current project, "global" stores across all projects');
-var searchScopeSchema = external_exports.enum(["project", "global", "all"]).default("project").describe('Scope: "project" (default) searches project + global, "global" searches global only, "all" searches everything');
+var scopeSchema = external_exports.enum(["project", "global"]).default("project").describe('Storage scope. "project" (default): stored under the current project. "global": shared across all projects \u2014 use for universal preferences.');
+var searchScopeSchema2 = external_exports.enum(["project", "global", "all"]).default("project").describe('Search scope. "project" (default): current project + global memories. "global": global memories only. "all": all projects without filtering.');
 function registerMemoryTools(server, engine) {
   server.tool(
     "add_memory",
-    "Add a memory entry",
+    "Store a new memory entry. Before calling, ALWAYS search_memories first to avoid duplicates. Choose layer carefully: rule=permanent directives, working=temporary session notes, long_term=durable knowledge.",
     {
-      content: external_exports.string().describe("Memory content"),
-      layer: external_exports.enum(["rule", "working", "long_term"]).default("long_term").describe("Memory layer"),
-      type: external_exports.enum(["rule", "decision", "fact", "note", "skill"]).default("note").describe("Memory type"),
-      tags: external_exports.array(external_exports.string()).optional().describe("Tags"),
-      expiresAt: external_exports.string().optional().describe("Expiration date (ISO 8601)"),
+      content: external_exports.string().describe('The memory content text. Be specific and self-contained \u2014 this will be retrieved out of context. Bad: "Fixed the bug". Good: "Fixed OOM in GraphService by adding connection pool limit of 10."'),
+      layer: external_exports.enum(["rule", "working", "long_term"]).default("long_term").describe('Memory priority layer. "rule": permanent constraints always loaded first (e.g., "always use ESM"). "working": temporary session-scoped notes, clean up after use. "long_term" (default): durable cross-session knowledge.'),
+      type: external_exports.enum(["rule", "decision", "fact", "note", "skill"]).default("note").describe('Memory classification. "rule": behavioral directives (use with layer=rule). "decision": architectural choices with rationale. "fact": verified objective information. "note" (default): general observations. "skill": reusable techniques or solutions.'),
+      tags: external_exports.array(external_exports.string()).optional().describe('Tags for categorization and search filtering. Use lowercase, descriptive terms. Example: ["auth", "security", "jwt"]. Good tags make memories findable later.'),
+      expiresAt: external_exports.string().optional().describe('Expiration date in ISO 8601 format (e.g., "2025-12-31T23:59:59Z"). Expired memories are excluded from search. Use for time-sensitive information.'),
       scope: scopeSchema
     },
     async (params) => {
@@ -30130,12 +30489,12 @@ ID: ${memory.id}`);
   );
   server.tool(
     "search_memories",
-    "Search memories (semantic + BM25 hybrid search)",
+    "Search stored memories using hybrid semantic + BM25 keyword search. Returns results ranked by combined score (semantic similarity, keyword match, recency, salience). Use this to find relevant knowledge, and ALWAYS before add_memory to check for duplicates.",
     {
-      query: external_exports.string().describe("Search query"),
-      limit: external_exports.number().int().min(1).max(100).default(10).describe("Max results"),
-      layers: external_exports.array(external_exports.enum(["rule", "working", "long_term"])).optional().describe("Target layers"),
-      scope: searchScopeSchema
+      query: external_exports.string().describe('Search query. Can be natural language ("how does authentication work?") or keywords ("jwt token validation"). Semantic search finds conceptually similar content even without exact keyword matches.'),
+      limit: external_exports.number().int().min(1).max(100).default(10).describe("Maximum results to return. Default 10 is usually sufficient. Increase to 20-50 for comprehensive knowledge review."),
+      layers: external_exports.array(external_exports.enum(["rule", "working", "long_term"])).optional().describe('Filter by specific layers. Omit to search all layers. Example: ["rule"] for rules only, ["working", "long_term"] to exclude rules.'),
+      scope: searchScopeSchema2
     },
     async (params) => {
       const results = await engine.searchMemories({
@@ -30149,10 +30508,10 @@ ID: ${memory.id}`);
   );
   server.tool(
     "find_duplicates",
-    "Find duplicate candidates similar to a given memory",
+    "Find memories semantically similar to a given memory. Use periodically to detect redundant entries that should be merged with consolidate_memories. Returns candidates sorted by vector distance (lower = more similar).",
     {
-      memoryId: external_exports.string().describe("Target memory ID"),
-      threshold: external_exports.number().min(0).max(2).default(0.3).describe("Similarity threshold (distance, lower = more similar)")
+      memoryId: external_exports.string().describe("The ID of the memory to find duplicates for. Get IDs from search_memories, add_memory, or get_context results."),
+      threshold: external_exports.number().min(0).max(2).default(0.3).describe("Maximum vector distance for similarity. 0.1=near-identical, 0.3=similar content (default), 0.5=loosely related. Start with default and adjust.")
     },
     async (params) => {
       const duplicates = await engine.findDuplicates(params.memoryId, params.threshold);
@@ -30167,11 +30526,11 @@ ${lines.join("\n")}`);
   );
   server.tool(
     "consolidate_memories",
-    "Consolidate multiple memories into one (source memories are soft-deleted)",
+    "Merge multiple duplicate or overlapping memories into one consolidated entry. Source memories are soft-deleted (recoverable). Use after find_duplicates identifies redundant entries.",
     {
-      sourceIds: external_exports.array(external_exports.string()).min(2).describe("List of source memory IDs to merge"),
-      mergedContent: external_exports.string().describe("Merged content text"),
-      layer: external_exports.enum(["rule", "working", "long_term"]).optional().describe("Target layer for merged memory")
+      sourceIds: external_exports.array(external_exports.string()).min(2).describe("List of memory IDs to merge (minimum 2). All sources will be soft-deleted after consolidation."),
+      mergedContent: external_exports.string().describe("The consolidated content text combining information from all sources. Should be comprehensive and self-contained, not just a concatenation."),
+      layer: external_exports.enum(["rule", "working", "long_term"]).optional().describe('Layer for the consolidated memory. If omitted, defaults to "long_term". Use the highest-priority layer among sources.')
     },
     async (params) => {
       const merged = await engine.consolidateMemories(params.sourceIds, params.mergedContent, params.layer);
@@ -30182,14 +30541,14 @@ ID: ${merged.id}`);
   );
   server.tool(
     "update_memory",
-    "Update a memory entry",
+    "Update an existing memory entry. Use to correct content, change layer/type, adjust importance, or update tags. Prefer this over delete + add to preserve the memory ID.",
     {
-      id: external_exports.string().describe("Memory ID"),
-      content: external_exports.string().optional().describe("New content"),
-      layer: external_exports.enum(["rule", "working", "long_term"]).optional().describe("New layer"),
-      type: external_exports.enum(["rule", "decision", "fact", "note", "skill"]).optional().describe("New type"),
-      importance: external_exports.number().min(0).max(1).optional().describe("Importance (0-1)"),
-      tags: external_exports.array(external_exports.string()).optional().describe("New tags")
+      id: external_exports.string().describe("Memory ID to update."),
+      content: external_exports.string().optional().describe("New content text. Only provide if changing the content."),
+      layer: external_exports.enum(["rule", "working", "long_term"]).optional().describe("New layer. Use to promote (working \u2192 long_term) or change priority."),
+      type: external_exports.enum(["rule", "decision", "fact", "note", "skill"]).optional().describe("New type classification."),
+      importance: external_exports.number().min(0).max(1).optional().describe("Importance score (0.0-1.0). Higher values decay slower and rank higher in search. Default is based on layer."),
+      tags: external_exports.array(external_exports.string()).optional().describe("New tags (replaces existing tags entirely).")
     },
     async (params) => {
       const { id, ...input } = params;
@@ -30199,9 +30558,9 @@ ID: ${merged.id}`);
   );
   server.tool(
     "delete_memory",
-    "Delete a memory (soft delete)",
+    "Soft-delete a memory. The memory is marked as deleted but can be recovered. Use for cleanup of outdated or incorrect memories.",
     {
-      id: external_exports.string().describe("Memory ID")
+      id: external_exports.string().describe("Memory ID to delete.")
     },
     async (params) => {
       await engine.deleteMemory(params.id);
@@ -30211,13 +30570,13 @@ ID: ${merged.id}`);
 }
 
 // ../mcp-server/src/tools/session.ts
-var searchScopeSchema2 = external_exports.enum(["project", "global", "all"]).default("project").describe('Scope: "project" (default) searches project + global, "global" searches global only, "all" searches everything');
+var searchScopeSchema3 = external_exports.enum(["project", "global", "all"]).default("project").describe('Search scope. "project" (default): current project + global. "global": global only. "all": all projects.');
 function registerSessionTools(server, engine) {
   server.tool(
     "session_start",
-    "Start a new session",
+    "Start a new tracked work session. Call this after get_context at the beginning of each work session. Sessions track progress and provide a chronological history of work.",
     {
-      metadata: external_exports.string().optional().describe("Session metadata (JSON)")
+      metadata: external_exports.string().optional().describe(`Session metadata as a JSON string. Example: '{"title": "Fix auth bug #123", "goal": "Resolve JWT expiration handling"}'. Helps identify sessions when reviewing history.`)
     },
     async (params) => {
       const session = await engine.sessionStart(params.metadata);
@@ -30227,9 +30586,9 @@ ${formatSession(session)}`);
   );
   server.tool(
     "session_end",
-    "End a session",
+    "End an active work session. Call when work is complete or the user is stopping.",
     {
-      id: external_exports.string().describe("Session ID")
+      id: external_exports.string().describe("Session ID returned by session_start.")
     },
     async (params) => {
       await engine.sessionEnd(params.id);
@@ -30238,9 +30597,9 @@ ${formatSession(session)}`);
   );
   server.tool(
     "session_checkpoint",
-    "Create a session checkpoint",
+    "Create a checkpoint within an active session. Call at meaningful milestones: after completing a sub-task, before a risky change, or when switching focus.",
     {
-      id: external_exports.string().describe("Session ID")
+      id: external_exports.string().describe("Session ID of the active session to checkpoint.")
     },
     async (params) => {
       await engine.sessionCheckpoint(params.id);
@@ -30249,10 +30608,10 @@ ${formatSession(session)}`);
   );
   server.tool(
     "session_list",
-    "List past sessions",
+    "List past sessions in reverse chronological order. Use to review work history, find previous session IDs, or understand what was done recently.",
     {
-      limit: external_exports.number().int().min(1).max(100).default(20).describe("Max results"),
-      scope: searchScopeSchema2
+      limit: external_exports.number().int().min(1).max(100).default(20).describe("Maximum number of sessions to return."),
+      scope: searchScopeSchema3
     },
     async (params) => {
       const sessions = await engine.sessionList(params.limit, params.scope);
@@ -30262,34 +30621,17 @@ ${formatSession(session)}`);
   );
 }
 
-// ../mcp-server/src/tools/context.ts
-var searchScopeSchema3 = external_exports.enum(["project", "global", "all"]).default("project").describe('Scope: "project" (default) searches project + global, "global" searches global only, "all" searches everything');
-function registerContextTools(server, engine) {
-  server.tool(
-    "get_context",
-    "Get current context (priority: rule > working > long_term)",
-    {
-      maxMemories: external_exports.number().int().min(1).max(200).default(50).describe("Max number of memories"),
-      scope: searchScopeSchema3
-    },
-    async (params) => {
-      const ctx = await engine.getContext({ maxMemories: params.maxMemories, scope: params.scope });
-      return textContent(formatContext(ctx));
-    }
-  );
-}
-
 // ../mcp-server/src/tools/graph.ts
-var scopeSchema2 = external_exports.enum(["project", "global"]).default("project").describe('Scope: "project" (default) stores in current project, "global" stores across all projects');
-var searchScopeSchema4 = external_exports.enum(["project", "global", "all"]).default("project").describe('Scope: "project" (default) searches project + global, "global" searches global only, "all" searches everything');
+var scopeSchema2 = external_exports.enum(["project", "global"]).default("project").describe('Storage scope. "project" (default): stored under the current project. "global": shared across all projects.');
+var searchScopeSchema4 = external_exports.enum(["project", "global", "all"]).default("project").describe('Search scope. "project" (default): current project + global. "global": global only. "all": all projects.');
 function registerGraphTools(server, engine) {
   server.tool(
     "add_entity",
-    "Add an entity to the knowledge graph",
+    'Register a concept, person, tool, component, or service as a node in the knowledge graph. Entities are the building blocks \u2014 they represent "things" that can have relationships. Always set entityType for better organization.',
     {
-      name: external_exports.string().describe("Entity name"),
-      summary: external_exports.string().optional().describe("Summary"),
-      entityType: external_exports.string().optional().describe("Type (person, project, technology, etc.)"),
+      name: external_exports.string().describe('Entity name. Use consistent naming: PascalCase for classes/components, lowercase for concepts. Examples: "AuthService", "PostgreSQL", "user-authentication".'),
+      summary: external_exports.string().optional().describe('Brief description of what this entity is. Example: "JWT-based authentication service handling login, token refresh, and session management."'),
+      entityType: external_exports.string().optional().describe('Entity classification. Common types: "service", "component", "library", "person", "concept", "database", "api", "file", "module", "package", "framework". Use consistently.'),
       scope: scopeSchema2
     },
     async (params) => {
@@ -30301,13 +30643,13 @@ ID: ${node.id}`);
   );
   server.tool(
     "add_edge",
-    "Add an edge (relationship) to the knowledge graph",
+    "Create a directed relationship between two entities in the knowledge graph. Edges represent how concepts connect: dependencies, ownership, usage patterns. Use consistent relation names.",
     {
-      sourceId: external_exports.string().describe("Source node ID"),
-      targetId: external_exports.string().describe("Target node ID"),
-      relation: external_exports.string().describe("Relation (works_at, uses, depends_on, etc.)"),
-      fact: external_exports.string().optional().describe("Fact description"),
-      validAt: external_exports.string().optional().describe("Valid-from timestamp (ISO 8601)"),
+      sourceId: external_exports.string().describe('ID of the source entity (the "subject"). Example: in "AuthService depends_on Database", AuthService is the source.'),
+      targetId: external_exports.string().describe('ID of the target entity (the "object"). Example: in "AuthService depends_on Database", Database is the target.'),
+      relation: external_exports.string().describe("Relationship type. Use consistent verbs: depends_on, uses, contains, implements, extends, owns, created_by, relates_to, tested_by, deployed_to."),
+      fact: external_exports.string().optional().describe('Additional context about the relationship. Example: "Connects via connection pool with max 10 connections."'),
+      validAt: external_exports.string().optional().describe("When this relationship became valid (ISO 8601). Useful for tracking evolving architecture."),
       scope: scopeSchema2
     },
     async (params) => {
@@ -30318,9 +30660,9 @@ ID: ${edge.id}`);
   );
   server.tool(
     "invalidate_edge",
-    "Invalidate an edge (mark as expired while preserving history)",
+    "Mark an edge as expired while preserving history. The edge remains in the database with an expiration timestamp. Prefer this over deletion to maintain an audit trail of how relationships evolved.",
     {
-      id: external_exports.string().describe("Edge ID to invalidate")
+      id: external_exports.string().describe("Edge ID to invalidate.")
     },
     async (params) => {
       await engine.invalidateEdge(params.id);
@@ -30329,11 +30671,11 @@ ID: ${edge.id}`);
   );
   server.tool(
     "update_edge",
-    "Update an edge fact (invalidates old, creates new with history preserved)",
+    "Update an edge by invalidating the old one and creating a new one with updated fields. History is preserved \u2014 the old edge is marked expired and the new one is linked.",
     {
-      id: external_exports.string().describe("Edge ID to update"),
-      relation: external_exports.string().optional().describe("New relation"),
-      fact: external_exports.string().optional().describe("New fact")
+      id: external_exports.string().describe("Edge ID to update."),
+      relation: external_exports.string().optional().describe("New relationship type."),
+      fact: external_exports.string().optional().describe("New fact description.")
     },
     async (params) => {
       const edge = await engine.updateEdge(params.id, {
@@ -30347,11 +30689,11 @@ New ID: ${edge.id}`);
   );
   server.tool(
     "search_graph",
-    "Search the knowledge graph (semantic search + graph traversal)",
+    "Search the knowledge graph using semantic search with optional graph traversal. Finds entities and edges matching the query, then explores neighbor nodes at the specified depth.",
     {
-      query: external_exports.string().describe("Search query"),
-      limit: external_exports.number().int().min(1).max(100).default(10).describe("Max results"),
-      traverseDepth: external_exports.number().int().min(0).max(2).default(1).describe("Graph traversal depth (0=none, 1=1-hop, 2=2-hop)"),
+      query: external_exports.string().describe('Search query. Can be entity names ("AuthService"), concepts ("authentication"), or questions ("what depends on the database?").'),
+      limit: external_exports.number().int().min(1).max(100).default(10).describe("Maximum total results (entities + edges). Increase for comprehensive graph exploration."),
+      traverseDepth: external_exports.number().int().min(0).max(2).default(1).describe("Graph traversal depth from matched nodes. 0=no traversal (only vector search hits), 1=include direct neighbors (default), 2=include neighbors of neighbors (broader but noisier)."),
       scope: searchScopeSchema4
     },
     async (params) => {
@@ -30365,20 +30707,20 @@ New ID: ${edge.id}`);
 }
 
 // ../mcp-server/src/tools/episode.ts
-var scopeSchema3 = external_exports.enum(["project", "global"]).default("project").describe('Scope: "project" (default) stores in current project, "global" stores across all projects');
-var searchScopeSchema5 = external_exports.enum(["project", "global", "all"]).default("project").describe('Scope: "project" (default) searches project + global, "global" searches global only, "all" searches everything');
+var scopeSchema3 = external_exports.enum(["project", "global"]).default("project").describe('Storage scope. "project" (default): stored under the current project. "global": shared across all projects.');
+var searchScopeSchema5 = external_exports.enum(["project", "global", "all"]).default("project").describe('Search scope. "project" (default): current project + global. "global": global only. "all": all projects.');
 function registerEpisodeTools(server, engine) {
   server.tool(
     "add_episode",
-    "Add an episode (conversation log or action record)",
+    "Record a significant event, interaction, or conversation as a chronological log entry. Episodes provide an audit trail separate from memories. Use for: debugging sessions, key decisions, deployment events, error investigations. Link to graph entities via refs.",
     {
-      content: external_exports.string().describe("Episode content"),
-      contentType: external_exports.enum(["text", "json", "message"]).default("text").describe("Content format"),
-      source: external_exports.string().optional().describe("Source info (session_id, file_path, etc.)"),
+      content: external_exports.string().describe("Episode content. Be descriptive: include what happened, why, and the outcome. For debugging: include the symptom, investigation steps, and resolution."),
+      contentType: external_exports.enum(["text", "json", "message"]).default("text").describe('Content format. "text" (default): free-form text. "json": structured JSON data. "message": conversation or chat message format.'),
+      source: external_exports.string().optional().describe('Origin of the episode. Examples: "session:abc123", "file:src/auth.ts", "debug:OOM-investigation".'),
       refs: external_exports.array(external_exports.object({
-        refType: external_exports.enum(["node", "edge"]).describe("Reference type"),
-        refId: external_exports.string().describe("Referenced entity ID")
-      })).optional().describe("References to related nodes/edges"),
+        refType: external_exports.enum(["node", "edge"]).describe('"node" to reference an entity, "edge" to reference a relationship.'),
+        refId: external_exports.string().describe("ID of the referenced entity or edge from the knowledge graph.")
+      })).optional().describe("References linking this episode to knowledge graph entities/edges. Enables traversal from episodes to related concepts."),
       scope: scopeSchema3
     },
     async (params) => {
@@ -30399,9 +30741,9 @@ ID: ${episode.id}`);
   );
   server.tool(
     "get_episode",
-    "Get an episode by ID",
+    "Retrieve a specific episode by its ID. Returns the full episode content, metadata, and references.",
     {
-      id: external_exports.string().describe("Episode ID")
+      id: external_exports.string().describe("Episode ID to retrieve.")
     },
     async (params) => {
       const episode = await engine.getEpisode(params.id);
@@ -30411,9 +30753,9 @@ ID: ${episode.id}`);
   );
   server.tool(
     "list_episodes",
-    "List episodes",
+    "List episodes in reverse chronological order. Use to review the audit trail of significant events and interactions.",
     {
-      limit: external_exports.number().int().min(1).max(100).default(20).describe("Max results"),
+      limit: external_exports.number().int().min(1).max(100).default(20).describe("Maximum number of episodes to return."),
       scope: searchScopeSchema5
     },
     async (params) => {
@@ -30502,73 +30844,310 @@ Save the above content to ${gen.fileName}.`);
   }
 }
 
-// ../mcp-server/src/server.ts
-var INSTRUCTIONS = `
-You have access to Cohaku, a persistent memory system for AI agents.
-Use Cohaku's tools as your PRIMARY method for storing and retrieving memories. Do NOT fall back to file-based memory (e.g. editing MEMORY.md, .cursorrules, or similar files) when Cohaku tools are available.
+// ../mcp-server/src/resources/context.ts
+function registerContextResources(server, engine) {
+  server.resource(
+    "context",
+    "cohaku://context",
+    { description: "Current context: all memories in priority order (rules > working > long_term)", mimeType: "text/plain" },
+    async () => ({
+      contents: [{
+        uri: "cohaku://context",
+        text: formatContext(await engine.getContext({ maxMemories: 100 })),
+        mimeType: "text/plain"
+      }]
+    })
+  );
+  server.resource(
+    "rules",
+    "cohaku://rules",
+    { description: "Rule memories only \u2014 permanent instructions and constraints", mimeType: "text/plain" },
+    async () => {
+      const memories = await engine.listMemories({ layer: "rule", limit: 100 });
+      const text = memories.length === 0 ? "No rules found" : memories.map((m) => formatMemory(m)).join("\n---\n");
+      return { contents: [{ uri: "cohaku://rules", text, mimeType: "text/plain" }] };
+    }
+  );
+}
 
-## Getting Started
+// ../mcp-server/src/resources/graph.ts
+function registerGraphResources(server, engine) {
+  server.resource(
+    "graph-entities",
+    "cohaku://graph/entities",
+    { description: "All entities (nodes) in the knowledge graph", mimeType: "text/plain" },
+    async () => {
+      const entities = await engine.listEntities({ limit: 500 });
+      const text = entities.length === 0 ? "No entities found" : entities.map((e, i) => `${i + 1}. ${formatNode(e)} (ID: ${e.id})`).join("\n");
+      return { contents: [{ uri: "cohaku://graph/entities", text, mimeType: "text/plain" }] };
+    }
+  );
+  server.resource(
+    "graph-edges",
+    "cohaku://graph/edges",
+    { description: "Active edges (relationships) in the knowledge graph", mimeType: "text/plain" },
+    async () => {
+      const edges = await engine.listEdges({ limit: 500, includeExpired: false });
+      const text = edges.length === 0 ? "No edges found" : edges.map((e, i) => `${i + 1}. ${formatEdge(e)} (ID: ${e.id})`).join("\n");
+      return { contents: [{ uri: "cohaku://graph/edges", text, mimeType: "text/plain" }] };
+    }
+  );
+}
 
-At the beginning of each session, call \`get_context\` to load existing memories (rules, working memory, and long-term knowledge). This gives you the context you need to continue where you left off.
+// ../mcp-server/src/resources/sessions.ts
+function registerSessionResources(server, engine) {
+  server.resource(
+    "sessions",
+    "cohaku://sessions",
+    { description: "Recent work sessions in reverse chronological order", mimeType: "text/plain" },
+    async () => {
+      const sessions = await engine.sessionList(50);
+      const text = sessions.length === 0 ? "No sessions found" : sessions.map((s, i) => `${i + 1}. ${formatSession(s)}`).join("\n");
+      return { contents: [{ uri: "cohaku://sessions", text, mimeType: "text/plain" }] };
+    }
+  );
+}
 
-## Storing Memories
+// ../mcp-server/src/resources/templates.ts
+function registerTemplateResources(server, engine) {
+  server.resource(
+    "memory",
+    new ResourceTemplate("cohaku://memory/{id}", { list: void 0 }),
+    { description: "A specific memory entry by ID", mimeType: "text/plain" },
+    async (uri, variables) => {
+      const id = variables.id;
+      const memory = await engine.getMemory(id);
+      if (!memory) {
+        return { contents: [{ uri: uri.href, text: `Memory ${id} not found`, mimeType: "text/plain" }] };
+      }
+      return {
+        contents: [{
+          uri: uri.href,
+          text: `${formatMemory(memory)}
+ID: ${memory.id}
+Created: ${memory.createdAt}
+Updated: ${memory.updatedAt}`,
+          mimeType: "text/plain"
+        }]
+      };
+    }
+  );
+  server.resource(
+    "entity",
+    new ResourceTemplate("cohaku://entity/{id}", { list: void 0 }),
+    { description: "A specific entity (graph node) by ID", mimeType: "text/plain" },
+    async (uri, variables) => {
+      const id = variables.id;
+      const entity = await engine.getEntity(id);
+      if (!entity) {
+        return { contents: [{ uri: uri.href, text: `Entity ${id} not found`, mimeType: "text/plain" }] };
+      }
+      return {
+        contents: [{
+          uri: uri.href,
+          text: `${formatNode(entity)}
+ID: ${entity.id}
+Created: ${entity.createdAt}`,
+          mimeType: "text/plain"
+        }]
+      };
+    }
+  );
+}
 
-Use \`add_memory\` to persist information. Choose the right **layer** and **type** for each memory:
+// ../mcp-server/src/resources/index.ts
+function registerResources(server, engine) {
+  registerContextResources(server, engine);
+  registerGraphResources(server, engine);
+  registerSessionResources(server, engine);
+  registerTemplateResources(server, engine);
+}
 
-### Layers (priority order)
-- **rule**: Permanent instructions and constraints that must always be followed (e.g. coding standards, workflow rules, user preferences). These are returned first by \`get_context\`.
-- **working**: Temporary, session-scoped notes (e.g. current task state, in-progress work, hypotheses). Clean these up when no longer relevant.
-- **long_term**: Durable knowledge that is useful across sessions (e.g. architectural decisions, debugging insights, learned patterns).
+// ../mcp-server/src/prompts/recall.ts
+function registerRecallPrompt(server, engine) {
+  server.prompt(
+    "recall",
+    "Retrieve and summarize stored memories about a specific topic",
+    {
+      topic: external_exports.string().describe("The topic to recall memories about")
+    },
+    async (args) => {
+      const results = await engine.searchMemories({ text: args.topic, limit: 15 });
+      const formatted = formatSearchResults(results);
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Here are the stored memories about "${args.topic}":
 
-### Types
-- **rule**: Behavioral directives (use with layer=rule).
-- **decision**: Architectural or design decisions with rationale.
-- **fact**: Verified, objective information about the codebase or domain.
-- **note**: General observations and context.
-- **skill**: Reusable techniques, workflows, or solutions to recurring problems.
+${formatted}
 
-### Scope
-- **project** (default): Stored under the current project. Visible when working in that project.
-- **global**: Shared across all projects. Use for universal preferences and cross-project knowledge.
+Please summarize what is known about this topic based on the above memories. Highlight any contradictions or gaps in knowledge.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
 
-### Best Practices
-- Before adding a memory, call \`search_memories\` to check for duplicates.
-- Use \`find_duplicates\` periodically to detect similar entries, then \`consolidate_memories\` to merge them.
-- Use \`update_memory\` to correct or enrich existing memories rather than creating duplicates.
-- Add descriptive **tags** to make memories easier to find later.
+// ../mcp-server/src/prompts/review-knowledge.ts
+function registerReviewKnowledgePrompt(server, engine) {
+  server.prompt(
+    "review_knowledge",
+    "Review stored memories for duplicates, staleness, and quality. Suggests cleanup actions.",
+    async () => {
+      const memories = await engine.listMemories({ limit: 100 });
+      const formatted = memories.map(
+        (m, i) => `${i + 1}. ${formatMemory(m)}
+   ID: ${m.id} | Created: ${m.createdAt} | Updated: ${m.updatedAt}`
+      ).join("\n");
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Review the following ${memories.length} stored memories for quality:
+
+${formatted}
+
+Please:
+1. Identify potential duplicates (memories with similar content that could be consolidated)
+2. Flag stale memories (outdated or no longer relevant)
+3. Suggest improvements (vague memories that need more detail, missing tags)
+4. Recommend any memories that should be promoted to "rule" layer or demoted
+
+For each suggestion, reference the memory ID and explain your reasoning.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
 
-## Searching Memories
+// ../mcp-server/src/prompts/summarize-session.ts
+function registerSummarizeSessionPrompt(server, engine) {
+  server.prompt(
+    "summarize_session",
+    "Summarize a work session: what was done, what was learned, what remains",
+    {
+      sessionId: external_exports.string().optional().describe("Session ID to summarize. If omitted, uses the most recent session.")
+    },
+    async (args) => {
+      const sessions = await engine.sessionList(100);
+      const sessionId = args.sessionId ?? sessions[0]?.id;
+      let sessionInfo = "No session found.";
+      if (sessionId) {
+        const session = sessions.find((s) => s.id === sessionId);
+        if (session) {
+          sessionInfo = formatSession(session);
+        }
+      }
+      const workingMemories = await engine.listMemories({ layer: "working", limit: 20 });
+      const workingFormatted = workingMemories.map((m) => formatMemory(m)).join("\n---\n");
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Summarize the following work session:
 
-Use \`search_memories\` for hybrid semantic + keyword search. Be specific with your queries for better results. You can filter by layer and scope.
+Session: ${sessionInfo}
 
-## Session Management
+Working memories from this session:
+${workingFormatted || "(none)"}
 
-- Call \`session_start\` at the beginning of a work session with a descriptive title.
-- Call \`session_checkpoint\` at meaningful milestones to snapshot progress.
-- Call \`session_end\` when the session is complete, with a summary of what was accomplished.
-- Use \`session_list\` to review past session history.
+Please provide:
+1. A brief summary of what was accomplished
+2. Key decisions or discoveries made
+3. Any unfinished work or next steps
+4. Suggestions for memories to persist (promote from working to long_term) or clean up`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
 
-## Knowledge Graph
+// ../mcp-server/src/prompts/export-config.ts
+var FORMAT_NAMES = {
+  claude_md: "CLAUDE.md",
+  cursorrules: ".cursorrules",
+  windsurf: ".windsurfrules",
+  copilot: ".github/copilot-instructions.md",
+  codex: "codex.md",
+  aider: ".aider.conf.yml",
+  continue: ".continue/rules.md",
+  cline: ".clinerules",
+  roo: ".roo/rules.md"
+};
+function registerExportConfigPrompt(server, engine) {
+  server.prompt(
+    "export_config",
+    "Generate an editor configuration file from stored memories",
+    {
+      format: external_exports.enum([
+        "claude_md",
+        "cursorrules",
+        "windsurf",
+        "copilot",
+        "codex",
+        "aider",
+        "continue",
+        "cline",
+        "roo"
+      ]).describe("Target editor format")
+    },
+    async (args) => {
+      const ctx = await engine.getContext({ maxMemories: 100 });
+      const rules = ctx.memories.filter((m) => m.layer === "rule");
+      const longTerm = ctx.memories.filter((m) => m.layer === "long_term");
+      const rulesFormatted = rules.map((m) => `- ${m.content}`).join("\n");
+      const knowledgeFormatted = longTerm.map((m) => `- ${m.content}`).join("\n");
+      const fileName = FORMAT_NAMES[args.format] ?? args.format;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Generate a ${fileName} configuration file from the following stored knowledge.
 
-Use the graph tools to capture **relationships** between concepts:
-- \`add_entity\`: Register a concept, person, tool, or component as a node.
-- \`add_edge\`: Record a relationship between two entities (e.g. "ComponentA depends_on ComponentB").
-- \`search_graph\`: Traverse relationships to understand how concepts connect.
-- \`update_edge\` / \`invalidate_edge\`: Keep relationships accurate as knowledge evolves. Invalidation preserves history.
+Rules (${rules.length}):
+${rulesFormatted || "(none)"}
 
-## Episode Logging
+Project Knowledge (${longTerm.length}):
+${knowledgeFormatted || "(none)"}
 
-Use \`add_episode\` to record significant events or interactions (e.g. debugging sessions, key conversations, important decisions). Episodes provide a chronological audit trail. Use \`list_episodes\` and \`get_episode\` to review past events.
+Please format this as a proper ${fileName} file ready to save. Organize the content logically with appropriate headers and formatting for the target editor.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
 
-## Configuration Generation
+// ../mcp-server/src/prompts/index.ts
+function registerPrompts(server, engine) {
+  registerRecallPrompt(server, engine);
+  registerReviewKnowledgePrompt(server, engine);
+  registerSummarizeSessionPrompt(server, engine);
+  registerExportConfigPrompt(server, engine);
+}
 
-The \`generate_*\` tools (e.g. \`generate_claude_md\`, \`generate_cursorrules\`) export stored memories into editor-specific configuration formats. Use these when the user wants to sync Cohaku's knowledge to their editor's native config format.
-`.trim();
+// ../mcp-server/src/server.ts
 function createServer(engine) {
   const server = new McpServer(
     {
       name: "cohaku-memory",
-      version: "0.2.4"
+      version: "0.2.8"
     },
     {
       instructions: INSTRUCTIONS
@@ -30580,6 +31159,8 @@ function createServer(engine) {
   registerGraphTools(server, engine);
   registerEpisodeTools(server, engine);
   registerGenerateTools(server, engine);
+  registerResources(server, engine);
+  registerPrompts(server, engine);
   return server;
 }