recallnest 1.4.1

package/integrations/examples/claude-agent-sdk/memory-agent.ts

@@ -0,0 +1,182 @@
+/**
+ * RecallNest + Claude Agent SDK — Minimal Example
+ *
+ * A Claude agent with persistent memory powered by RecallNest HTTP API.
+ *
+ * Prerequisites:
+ *   1. RecallNest API server running: bun run api  (port 4318)
+ *   2. ANTHROPIC_API_KEY set in environment
+ *   3. Install deps: bun add @anthropic-ai/sdk
+ *
+ * Run: bun run integrations/examples/claude-agent-sdk/memory-agent.ts
+ */
+
+import Anthropic from "@anthropic-ai/sdk";
+
+const client = new Anthropic();
+const RECALLNEST = "http://localhost:4318";
+
+function buildRecallContext() {
+  const sessionId = process.env.RECALLNEST_SESSION_ID;
+  const scope = process.env.RECALLNEST_SCOPE;
+  const resolvedScope = scope || (sessionId ? `session:${sessionId}` : undefined);
+  return {
+    ...(sessionId ? { sessionId } : {}),
+    ...(resolvedScope ? { scope: resolvedScope } : {}),
+  };
+}
+
+// --- Tool definitions for Claude ---
+
+const tools: Anthropic.Tool[] = [
+  {
+    name: "recall_memory",
+    description:
+      "Recall relevant memories from past conversations. Use at the start of every task.",
+    input_schema: {
+      type: "object" as const,
+      properties: {
+        query: {
+          type: "string",
+          description: "Search query — use 2-3 key nouns",
+        },
+      },
+      required: ["query"],
+    },
+  },
+  {
+    name: "store_memory",
+    description:
+      "Store an important fact, decision, or preference for future recall.",
+    input_schema: {
+      type: "object" as const,
+      properties: {
+        text: {
+          type: "string",
+          description: "The memory content to store",
+        },
+        category: {
+          type: "string",
+          enum: [
+            "profile",
+            "preferences",
+            "entities",
+            "events",
+            "cases",
+            "patterns",
+          ],
+          description: "Memory category",
+        },
+      },
+      required: ["text"],
+    },
+  },
+];
+
+// --- Tool handler: calls RecallNest HTTP API ---
+
+async function handleTool(
+  name: string,
+  input: Record<string, unknown>
+): Promise<string> {
+  if (name === "recall_memory") {
+    const res = await fetch(`${RECALLNEST}/v1/auto-recall`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ message: input.query, limit: 5, ...buildRecallContext() }),
+    });
+    if (!res.ok) return `Error: ${res.status} ${await res.text()}`;
+    const data = await res.json();
+    return JSON.stringify({
+      mode: data.mode,
+      resolvedScope: data.resolvedScope,
+      summary: data.resume?.summary,
+      stableContext: data.resume?.stableContext || [],
+      results: data.results || [],
+      searchSkippedReason: data.searchSkippedReason,
+    }, null, 2);
+  }
+
+  if (name === "store_memory") {
+    const recallContext = buildRecallContext();
+    if (!("scope" in recallContext)) {
+      return "Set RECALLNEST_SCOPE or RECALLNEST_SESSION_ID before storing durable memory.";
+    }
+    const res = await fetch(`${RECALLNEST}/v1/store`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        text: input.text,
+        category: input.category || "events",
+        scope: recallContext.scope,
+        source: "claude-agent-sdk-example",
+      }),
+    });
+    if (!res.ok) return `Error: ${res.status} ${await res.text()}`;
+    return "Memory stored successfully.";
+  }
+
+  return `Unknown tool: ${name}`;
+}
+
+// --- Agent loop ---
+
+async function runAgent(userMessage: string) {
+  console.log(`\nUser: ${userMessage}\n`);
+
+  const messages: Anthropic.MessageParam[] = [
+    { role: "user", content: userMessage },
+  ];
+
+  // Agentic loop: keep going until no more tool calls
+  while (true) {
+    const response = await client.messages.create({
+      model: "claude-sonnet-4-20250514",
+      max_tokens: 1024,
+      system:
+        "You are a helpful assistant with persistent memory. " +
+        "Always use recall_memory at the start of a task or project pivot to recover relevant context. " +
+        "Store important facts with store_memory.",
+      tools,
+      messages,
+    });
+
+    // Collect text output
+    for (const block of response.content) {
+      if (block.type === "text") {
+        console.log(`Assistant: ${block.text}`);
+      }
+    }
+
+    // If no tool use, we're done
+    if (response.stop_reason !== "tool_use") break;
+
+    // Handle tool calls
+    const toolUseBlocks = response.content.filter(
+      (b): b is Anthropic.ContentBlockParam & { type: "tool_use"; id: string; name: string; input: Record<string, unknown> } =>
+        b.type === "tool_use"
+    );
+
+    // Add assistant response to history
+    messages.push({ role: "assistant", content: response.content });
+
+    // Process each tool call and add results
+    const toolResults: Anthropic.ToolResultBlockParam[] = [];
+    for (const toolUse of toolUseBlocks) {
+      console.log(`  [Tool] ${toolUse.name}(${JSON.stringify(toolUse.input)})`);
+      const result = await handleTool(toolUse.name, toolUse.input);
+      toolResults.push({
+        type: "tool_result",
+        tool_use_id: toolUse.id,
+        content: result,
+      });
+    }
+
+    messages.push({ role: "user", content: toolResults });
+  }
+}
+
+// --- Main ---
+
+const query = process.argv[2] || "What do you remember about my Docker setup?";
+runAgent(query);

package/integrations/examples/langchain/memory-chain.py

@@ -0,0 +1,111 @@
+"""
+RecallNest + LangChain — Minimal Example
+
+A LangChain agent with persistent memory powered by RecallNest HTTP API.
+
+Prerequisites:
+    1. RecallNest API server running: bun run api  (port 4318)
+    2. OPENAI_API_KEY set in environment (or use any LangChain-supported LLM)
+    3. Install deps: pip install langchain langchain-openai httpx
+
+Run: python integrations/examples/langchain/memory-chain.py
+"""
+
+import json
+import os
+import httpx
+from langchain_core.tools import tool
+from langchain_openai import ChatOpenAI
+from langgraph.prebuilt import create_react_agent
+
+RECALLNEST = "http://localhost:4318"
+
+
+def build_recall_context() -> dict:
+    session_id = os.getenv("RECALLNEST_SESSION_ID")
+    scope = os.getenv("RECALLNEST_SCOPE")
+    resolved_scope = scope or (f"session:{session_id}" if session_id else None)
+    payload = {}
+    if session_id:
+        payload["sessionId"] = session_id
+    if resolved_scope:
+        payload["scope"] = resolved_scope
+    return payload
+
+
+@tool
+def recall_memory(query: str) -> str:
+    """Recall relevant memories from past conversations.
+    Use at the start of every task with 2-3 key nouns."""
+    r = httpx.post(
+        f"{RECALLNEST}/v1/auto-recall",
+        json={"message": query, "limit": 5, **build_recall_context()},
+    )
+    r.raise_for_status()
+    payload = r.json()
+    return json.dumps(
+        {
+            "mode": payload.get("mode"),
+            "resolvedScope": payload.get("resolvedScope"),
+            "summary": payload.get("resume", {}).get("summary"),
+            "stableContext": payload.get("resume", {}).get("stableContext", []),
+            "results": payload.get("results", []),
+            "searchSkippedReason": payload.get("searchSkippedReason"),
+        },
+        indent=2,
+        ensure_ascii=False,
+    )
+
+
+@tool
+def store_memory(text: str, category: str = "events") -> str:
+    """Store an important fact, decision, or preference for future recall.
+
+    Args:
+        text: The memory content to store.
+        category: One of: profile, preferences, entities, events, cases, patterns.
+    """
+    scope_context = build_recall_context()
+    if "scope" not in scope_context:
+        return "Set RECALLNEST_SCOPE or RECALLNEST_SESSION_ID before storing durable memory."
+    r = httpx.post(
+        f"{RECALLNEST}/v1/store",
+        json={
+            "text": text,
+            "category": category,
+            "scope": scope_context["scope"],
+            "source": "langchain-example",
+        },
+    )
+    r.raise_for_status()
+    return "Memory stored successfully."
+
+
+# --- Build the agent ---
+
+llm = ChatOpenAI(model="gpt-4o")
+tools = [recall_memory, store_memory]
+
+agent = create_react_agent(llm, tools)
+
+
+# --- Main ---
+
+def main():
+    import sys
+    query = sys.argv[1] if len(sys.argv) > 1 else "What do you remember about my project?"
+    print(f"\nUser: {query}\n")
+
+    result = agent.invoke(
+        {"messages": [{"role": "user", "content": query}]}
+    )
+
+    # Print the last assistant message
+    for msg in reversed(result["messages"]):
+        if msg.type == "ai" and msg.content:
+            print(f"Assistant: {msg.content}")
+            break
+
+
+if __name__ == "__main__":
+    main()

package/integrations/examples/openai-agents-sdk/memory-agent.py

@@ -0,0 +1,109 @@
+"""
+RecallNest + OpenAI Agents SDK — Minimal Example
+
+A Python agent with persistent memory powered by RecallNest HTTP API.
+
+Prerequisites:
+    1. RecallNest API server running: bun run api  (port 4318)
+    2. OPENAI_API_KEY set in environment
+    3. Install deps: pip install openai-agents httpx
+
+Run: python integrations/examples/openai-agents-sdk/memory-agent.py
+"""
+
+import asyncio
+import json
+import os
+import httpx
+from agents import Agent, Runner, function_tool
+
+RECALLNEST = "http://localhost:4318"
+
+
+def build_recall_context() -> dict:
+    session_id = os.getenv("RECALLNEST_SESSION_ID")
+    scope = os.getenv("RECALLNEST_SCOPE")
+    resolved_scope = scope or (f"session:{session_id}" if session_id else None)
+    payload = {}
+    if session_id:
+        payload["sessionId"] = session_id
+    if resolved_scope:
+        payload["scope"] = resolved_scope
+    return payload
+
+
+@function_tool
+async def recall_memory(query: str) -> str:
+    """Recall relevant memories from past conversations.
+    Use at the start of every task with 2-3 key nouns."""
+    async with httpx.AsyncClient() as client:
+        r = await client.post(
+            f"{RECALLNEST}/v1/auto-recall",
+            json={"message": query, "limit": 5, **build_recall_context()},
+        )
+        r.raise_for_status()
+        payload = r.json()
+        return json.dumps(
+            {
+                "mode": payload.get("mode"),
+                "resolvedScope": payload.get("resolvedScope"),
+                "summary": payload.get("resume", {}).get("summary"),
+                "stableContext": payload.get("resume", {}).get("stableContext", []),
+                "results": payload.get("results", []),
+                "searchSkippedReason": payload.get("searchSkippedReason"),
+            },
+            indent=2,
+            ensure_ascii=False,
+        )
+
+
+@function_tool
+async def store_memory(text: str, category: str = "events") -> str:
+    """Store an important fact, decision, or preference for future recall.
+
+    Args:
+        text: The memory content to store.
+        category: One of: profile, preferences, entities, events, cases, patterns.
+    """
+    scope_context = build_recall_context()
+    if "scope" not in scope_context:
+        return "Set RECALLNEST_SCOPE or RECALLNEST_SESSION_ID before storing durable memory."
+    async with httpx.AsyncClient() as client:
+        r = await client.post(
+            f"{RECALLNEST}/v1/store",
+            json={
+                "text": text,
+                "category": category,
+                "scope": scope_context["scope"],
+                "source": "openai-agents-sdk-example",
+            },
+        )
+        r.raise_for_status()
+        return "Memory stored successfully."
+
+
+# --- Agent definition ---
+
+agent = Agent(
+    name="Memory Agent",
+    instructions=(
+        "You are a helpful assistant with persistent memory. "
+        "Always use recall_memory at the start of a task or project pivot to recover relevant context. "
+        "Store important facts with store_memory."
+    ),
+    tools=[recall_memory, store_memory],
+)
+
+
+# --- Main ---
+
+async def main():
+    import sys
+    query = sys.argv[1] if len(sys.argv) > 1 else "What do you remember about my project?"
+    print(f"\nUser: {query}\n")
+    result = await Runner.run(agent, query)
+    print(f"Assistant: {result.final_output}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/integrations/gemini-cli/README.md

@@ -0,0 +1,57 @@
+# Gemini CLI Integration
+
+> Gemini CLI 接入指南：一键配 MCP + continuity 规则，让 Gemini CLI 在新窗口里主动恢复稳定上下文。
+
+## Quick Start
+
+```bash
+bash integrations/gemini-cli/setup.sh
+```
+
+## What It Does
+
+- Adds RecallNest as an MCP server in `~/.gemini/settings.json` with `trust: true`
+- Installs a managed RecallNest block in `~/.gemini/GEMINI.md`
+
+## Continuity Rules
+
+The managed block comes from [gemini-md-snippet.md](gemini-md-snippet.md) and tells Gemini CLI to:
+
+- call `resume_context` at the start of fresh windows or continuity-sensitive tasks
+- run lightweight `search_memory` on task pivots inside the same project before repo exploration drifts
+- reuse known `scope` / `sessionId` and the resolved scope returned by `resume_context` in follow-up recall calls
+- treat recalled or startup-hook repo state as unverified until this window explicitly checks the repo
+- save `checkpoint_session` before leaving resumable work
+- do not inspect repo state just to enrich a close-window checkpoint unless the user explicitly asked for repo state
+- do not write unverified repo-state claims into `checkpoint_session`
+- capture durable facts with `store_memory` and reusable workflows with `store_workflow_pattern`
+
+## Shared Index
+
+Gemini CLI shares the same LanceDB index as Claude Code and Codex. Memories ingested from any source are searchable by all three.
+
+## Manual Setup
+
+Add to `~/.gemini/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "recallnest": {
+      "command": "bun",
+      "args": ["run", "RECALLNEST_PATH/src/mcp-server.ts"],
+      "trust": true
+    }
+  }
+}
+```
+
+Replace `RECALLNEST_PATH` with your actual path.
+
+Then copy [gemini-md-snippet.md](gemini-md-snippet.md) into `~/.gemini/GEMINI.md` if you are not using `setup.sh`.
+
+## Verify
+
+Start Gemini CLI and ask: "resume my context for RecallNest continuity work"
+
+If `resume_context` or `search_memory` is called, you're set.

package/integrations/gemini-cli/gemini-md-snippet.md

@@ -0,0 +1,31 @@
+## RecallNest Continuity
+
+- These continuity rules override later generic writing, skill, and local-memory instructions whenever the user's intent is continuity recovery or memory recall.
+- If the user says `continue`, `继续`, `接着`, `刚才`, `上个窗口`, `不要让我重复前情`, `之前讨论过`, or asks what the project is solving / where it stopped / what to do next, call `resume_context` before any Bash, Read, or repo exploration.
+- If the user starts a concrete task in an active project, shifts back to a named project, or asks for prior implementation detail, do lightweight RecallNest recovery before repo exploration even without an explicit `continue`: call `resume_context` for broad continuity or `search_memory` for focused fact/pattern recall.
+- Do not substitute `git status`, `git log`, or reading local docs for `resume_context`. Local inspection can validate current code state only after continuity has been recovered.
+- Use `resume_context` to recover stable background such as active projects, durable preferences, recent cases, reusable patterns, and the latest checkpoint.
+- When `scope`, shared project scope, or `sessionId` is known, pass it into `resume_context` / `search_memory` / related recall tools instead of relying on global recall.
+- If `resume_context` returns a resolved scope or latest checkpoint scope, reuse that same scope in follow-up `search_memory`, `brief_memory`, `pin_memory`, and other recall calls.
+- If `resume_context` or a recalled checkpoint mentions repo state such as `git status`, modified files, untracked files, commits, or pending push, treat that as handoff context only. Do not restate it as the current repo state unless you verify it in this window with repo tools.
+- If current repo state has not been verified in this window, say it is unknown or omit it. Do not infer dirty/clean state, staged files, commit readiness, or specific modified files from recalled context alone.
+- In recall-only continuity recovery, do not mention `git status`, modified/untracked filenames, or repo cleanliness just to sound specific. If the next step would need repo inspection, say you would inspect the repo after the user asks you to proceed.
+- Treat startup hooks, restored checkpoints, and recalled notes the same way: unless this window explicitly inspected the repo, they are not evidence for current file lists or worktree state.
+- If the user is asking what you remember about preferences, style, tone, identity, or current project background, answer from `resume_context` and recalled memory first. Do not read repo files or local docs unless the user explicitly asks for file inspection or the recovered context is insufficient.
+- If the message mentions writing, articles, or the public account but the actual intent is recall-only (for example: "what style do you remember", "哪些表达方式要避免", "回忆偏好"), do not activate article-writing workflows, writing-persona files, or content-alchemy style skills. Treat it as a memory recall question unless the user explicitly asks you to draft, edit, or research.
+- Normal writing requests are unchanged: if the user explicitly asks you to draft an article, revise copy, research a topic, or continue the writing pipeline, you should use the existing writing workflows and skills as usual.
+- For recall-only writing/style questions, do not supplement the answer with local memory indexes, quick-reference blocks, `writing-persona.md`, `writing-rules.md`, or similar local style docs. If RecallNest recalled only one preference, answer from that one preference.
+- For recall-only preference questions, prefer a plain `resume_context` call over writing-specific profiles or broader rulesets unless the user explicitly asks for the full writing system.
+- If `resume_context` returns `Response mode: recall-only` or a recall-only guidance line, follow it literally. Restate the recalled stable context briefly and do not add extra examples, banned words, or inferred style rules unless they were also recalled.
+- If `resume_context` already returns a relevant durable preference for the current task, keep the answer narrow. Do not pad it with older pins, briefs, or local rule files unless the user asks for a broader ruleset.
+- For recall-only questions, stay constrained to the recalled items. Do not expand one recalled preference into a full doctrine, banned-word list, or writing system unless those details were also recalled or the user explicitly asks for expansion.
+- If recalled context is sparse, say what you do remember and what is still uncertain. Do not invent extra rules to sound complete.
+- For task pivots or fresh implementation work inside the same project, run a lightweight `search_memory` using 2-3 key nouns or verbs from the user's request before repo exploration drifts.
+- If `resume_context` is not enough and you need a specific fact, follow up with `search_memory` using 2-3 key nouns or verbs instead of full sentences.
+- If the user explicitly corrects a continuity miss, such as saying you should have resumed context first or should have saved a checkpoint before stopping, fix the workflow first and then call `workflow_observe` with outcome `corrected` so the miss is tracked outside durable memory.
+- Before leaving a window with unfinished or resumable work, call `checkpoint_session` and capture the current summary, decisions, open loops, next actions, and relevant entities.
+- Do not inspect repo state just to make `checkpoint_session` more complete unless the user explicitly asked for repo state in this window. A close-window handoff should prefer an incomplete but verified checkpoint over speculative or freshly-probed repo details.
+- Do not write repo-state claims into `checkpoint_session` unless you actually inspected the repo in this window. A recalled checkpoint mentioning dirty files or pending push is not enough evidence to repeat or persist it.
+- Do not copy or paraphrase unverified repo-state text into `checkpoint_session`, even with caveats like `未在本窗口验证`, `上次看到`, or `according to the earlier checkpoint`. If this window never inspected the repo, omit repo state entirely from the checkpoint.
+- Use `store_memory` when you learn durable profile, preference, entity, or case knowledge that should survive across future windows.
+- Use `store_workflow_pattern` when you discover a reusable multi-step workflow that should become durable `patterns` memory.

package/integrations/gemini-cli/setup.sh

@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+# RecallNest — Gemini CLI MCP setup (idempotent)
+# Usage: bash integrations/gemini-cli/setup.sh
+
+set -euo pipefail
+
+GEMINI_SETTINGS="$HOME/.gemini/settings.json"
+GEMINI_MD="$HOME/.gemini/GEMINI.md"
+GEMINI_DIR="$HOME/.gemini"
+RECALLNEST_DIR="$(cd "$(dirname "$0")/../.." && pwd)"
+MCP_ENTRY="$RECALLNEST_DIR/src/mcp-server.ts"
+RULES_SNIPPET="$RECALLNEST_DIR/integrations/gemini-cli/gemini-md-snippet.md"
+RULES_HELPER="$RECALLNEST_DIR/integrations/shared/install-managed-block.sh"
+
+if [[ ! -f "$MCP_ENTRY" ]]; then
+  echo "ERROR: $MCP_ENTRY not found. Run this from the recallnest repo root."
+  exit 1
+fi
+
+if [[ ! -f "$RULES_HELPER" ]]; then
+  echo "ERROR: $RULES_HELPER not found."
+  exit 1
+fi
+
+# Create ~/.gemini/ and settings.json if missing
+mkdir -p "$GEMINI_DIR"
+if [[ ! -f "$GEMINI_SETTINGS" ]]; then
+  echo '{}' > "$GEMINI_SETTINGS"
+  echo "Created $GEMINI_SETTINGS"
+fi
+
+# Check if already configured
+if bun -e "
+  const c = JSON.parse(require('fs').readFileSync('$GEMINI_SETTINGS','utf8'));
+  process.exit(c.mcpServers?.recallnest ? 0 : 1);
+" 2>/dev/null; then
+  echo "RecallNest MCP already configured in $GEMINI_SETTINGS — skipping."
+else
+  bun -e "
+    const fs = require('fs');
+    const c = JSON.parse(fs.readFileSync('$GEMINI_SETTINGS','utf8'));
+    if (!c.mcpServers) c.mcpServers = {};
+    c.mcpServers.recallnest = {
+      command: 'bun',
+      args: ['run', '$MCP_ENTRY'],
+      trust: true
+    };
+    fs.writeFileSync('$GEMINI_SETTINGS', JSON.stringify(c, null, 2) + '\n');
+  "
+  echo "Added RecallNest MCP to $GEMINI_SETTINGS"
+fi
+
+. "$RULES_HELPER"
+install_managed_markdown_block "$RULES_SNIPPET" "$GEMINI_MD" "recallnest-continuity"
+echo "Installed RecallNest continuity rules in $GEMINI_MD"
+
+echo ""
+echo "Setup complete. Restart Gemini CLI to activate."
+echo ""
+echo "Continuity baseline seed:"
+echo "  (cd \"$RECALLNEST_DIR\" && bun run seed:continuity)"
+echo ""
+echo "Managed snippet source:"
+echo "  $RULES_SNIPPET"

package/integrations/shared/install-managed-block.sh

@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+
+install_managed_markdown_block() {
+  local snippet_path="$1"
+  local target_path="$2"
+  local marker_name="$3"
+
+  if [[ ! -f "$snippet_path" ]]; then
+    echo "ERROR: snippet not found: $snippet_path" >&2
+    return 1
+  fi
+
+  mkdir -p "$(dirname "$target_path")"
+  touch "$target_path"
+
+  local start_marker="<!-- ${marker_name}:start -->"
+  local end_marker="<!-- ${marker_name}:end -->"
+  local tmp_file
+  tmp_file="$(mktemp)"
+  local tmp_body
+  tmp_body="$(mktemp)"
+
+  awk -v start="$start_marker" -v end="$end_marker" '
+    BEGIN {
+      in_block = 0
+    }
+    $0 == start {
+      in_block = 1
+      next
+    }
+    $0 == end {
+      in_block = 0
+      next
+    }
+    !in_block {
+      print
+    }
+  ' "$target_path" > "$tmp_body"
+
+  printf '%s\n' "$start_marker" > "$tmp_file"
+  awk '1' "$snippet_path" >> "$tmp_file"
+  printf '%s\n' "$end_marker" >> "$tmp_file"
+
+  if [[ -s "$tmp_body" ]]; then
+    printf '\n' >> "$tmp_file"
+    cat "$tmp_body" >> "$tmp_file"
+  fi
+
+  mv "$tmp_file" "$target_path"
+  rm -f "$tmp_body"
+}

package/lm

@@ -0,0 +1,19 @@
+#!/bin/bash
+# RecallNest CLI shortcut
+# Usage:
+#   lm search "keywords"     — search memory
+#   lm ingest                — ingest all sources
+#   lm ingest --source cc    — ingest Claude Code only
+#   lm stats                 — show stats
+#   lm reset --yes           — reset index
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+# Load .env if present (CLI also loads it, this is for standalone use)
+if [ -f "$SCRIPT_DIR/.env" ]; then
+  set -a
+  source "$SCRIPT_DIR/.env"
+  set +a
+fi
+
+cd "$SCRIPT_DIR" && bun run src/cli.ts "$@"

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "recallnest",
+  "version": "1.4.1",
+  "description": "RecallNest \u2014 MCP-native, local-first memory search and distillation for AI conversations",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "recallnest": "src/cli.ts",
+    "local-memory": "src/cli.ts"
+  },
+  "scripts": {
+    "search": "bun run src/cli.ts search",
+    "ingest": "bun run src/cli.ts ingest",
+    "stats": "bun run src/cli.ts stats",
+    "scope-inventory": "bun run src/cli.ts scope-inventory",
+    "workflow-scope-review": "bun run src/cli.ts workflow-scope-review",
+    "mcp": "bun run src/mcp-server.ts",
+    "explain": "bun run src/cli.ts explain",
+    "distill": "bun run src/cli.ts distill",
+    "brief": "bun run src/cli.ts brief",
+    "assets": "bun run src/cli.ts assets",
+    "clean-briefs": "bun run src/cli.ts clean-briefs --apply",
+    "test": "bun test",
+    "test:core": "bun test src/__tests__/scope-policy.test.ts src/__tests__/core-recall-eval.test.ts src/__tests__/capture-engine.test.ts src/__tests__/store-scope-audit.test.ts src/__tests__/scope-inventory.test.ts src/__tests__/workflow-observation.test.ts src/__tests__/resume-context.test.ts src/__tests__/term-registry.test.ts",
+    "eval": "bun run src/eval.ts",
+    "eval:continuity": "bun run src/eval.ts --mode continuity --cases eval/continuity/cases.json",
+    "profiles": "bun run src/cli.ts profiles",
+    "doctor": "bun run src/cli.ts doctor",
+    "demo": "bun run src/cli.ts demo",
+    "seed:patterns": "bun run src/cli.ts seed-patterns",
+    "seed:cases": "bun run src/cli.ts seed-cases",
+    "seed:memories": "bun run src/cli.ts seed-memories",
+    "seed:continuity": "bun run seed:patterns && bun run seed:cases && bun run seed:memories",
+    "smoke:claude-continuity": "bash integrations/claude-code/smoke-continuity.sh",
+    "ui": "bun run src/ui-server.ts",
+    "api": "bun run src/api-server.ts"
+  },
+  "dependencies": {
+    "@lancedb/lancedb": "^0.26.0",
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "commander": "^12.0.0",
+    "openai": "^4.0.0",
+    "zod": "^3.25.76"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AliceLJY/recallnest.git"
+  },
+  "homepage": "https://github.com/AliceLJY/recallnest"
+}