total-recall-memory 1.3.0

package/.claude-plugin/marketplace.json

@@ -0,0 +1,21 @@
+{
+  "name": "total-recall",
+  "owner": {
+    "name": "Radu Lupu"
+  },
+  "plugins": [
+    {
+      "name": "total-recall",
+      "source": "./",
+      "description": "Persistent cross-session memory for Claude Code. Automatically stores decisions, patterns, and lessons learned in a semantic search index so every session starts with full context. Supports multi-machine sharing via HTTP server with web UI.",
+      "version": "1.3.0",
+      "author": {
+        "name": "Radu Lupu"
+      },
+      "homepage": "https://github.com/radu2lupu/total-recall",
+      "repository": "https://github.com/radu2lupu/total-recall",
+      "license": "MIT",
+      "keywords": ["memory", "knowledge", "semantic-search", "sessions", "qmd", "multi-machine", "cross-session", "persistence"]
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,7 @@
+{
+  "name": "total-recall",
+  "description": "Persistent cross-session memory for Claude Code. Automatically stores decisions, patterns, and lessons learned in a semantic search index so every session starts with full context. Supports multi-machine sharing via HTTP server with web UI.",
+  "author": {
+    "name": "Radu Lupu"
+  }
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Radu Lupu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,183 @@
+# total-recall
+
+Persistent cross-session memory for Claude Code. Stores decisions, patterns, and lessons learned in a semantic search index (qmd) so every new session starts with full context of past work.
+
+Works on a single machine with iCloud backup, or across multiple machines via a built-in HTTP server with a web UI for browsing and editing memories.
+
+## Quick Start
+
+### Claude Code Plugin (recommended)
+
+```text
+/install radu2lupu/total-recall
+```
+
+Then run `/memory-setup` inside any project to configure it.
+
+### npm
+
+```bash
+npm install -g total-recall-memory
+total-recall install --project my-project
+```
+
+### From source
+
+```bash
+git clone https://github.com/radu2lupu/total-recall.git
+cd total-recall
+./scripts/install.sh --project my-project
+```
+
+## What It Does
+
+Once installed, memory is fully automatic:
+
+- **Session start**: Claude queries past memories for relevant context before starting work
+- **Session end**: Claude writes a summary of what was done, decisions made, and lessons learned
+- **Mid-session**: Claude queries memory when encountering problems where prior context could help
+
+No manual commands needed. Three enforcement layers make this reliable:
+
+1. **SessionStart hook** — fires before Claude sees the user's message, forcing a memory query as the first action
+2. **CLAUDE.md instructions** — detailed rules for when to query and when to write
+3. **Stop hook** — blocks session end until a memory summary is written
+
+## Architecture
+
+```
+~/.ai-memory/knowledge/<project>/
+  ├── sessions/           # Session summaries (auto-generated)
+  │   ├── 2025-06-15-auth-refactor.md
+  │   └── imported/       # Ingested from Claude/Codex logs
+  │       ├── claude/
+  │       └── codex/
+  ├── decisions/          # Architectural decisions
+  ├── patterns/           # Reusable patterns
+  ├── bugs/               # Bug investigations
+  └── MEMORY.md           # Project-level notes
+```
+
+Each memory file contains structured metadata — date, machine, project, topic — and is indexed by qmd for hybrid BM25 + vector search.
+
+## Multi-Machine Setup
+
+Share memories across machines on the same network using the built-in HTTP server. One command per machine.
+
+### On the server machine
+
+```bash
+./scripts/install.sh --project my-project --server
+```
+
+This does everything: local memory setup, iCloud backup, session ingestion, hooks, **and** starts an HTTP server on port 7899 with auto-restart on boot. It prints the API key and client connection command.
+
+### On client machines
+
+```bash
+./scripts/install.sh --project my-project --client \
+  --server-url http://server.tailscale:7899 \
+  --api-key tr_sk_...
+```
+
+Client installs are lightweight — no local qmd or memory directories needed. Just the CLI, hooks, and instruction injection. All `write` and `query` operations route to the server automatically.
+
+### Web UI
+
+The server includes a web UI at `http://server:7899/` for browsing, viewing, editing, and deleting memories. Memories are grouped by project with metadata pills showing date, machine, and source tool.
+
+### Manual server/client commands
+
+For more control, the individual commands are still available:
+
+```bash
+total-recall server init              # Generate config + API key
+total-recall server start             # Start server manually
+total-recall server stop              # Stop server
+total-recall server status            # Check server status
+total-recall server add-key           # Generate additional API key
+total-recall server install-launchd   # Auto-start on boot (macOS)
+
+total-recall client configure --server-url URL --api-key KEY
+total-recall client status            # Check connection
+total-recall client enable            # Re-enable remote mode
+total-recall client disable           # Switch back to local mode
+```
+
+## All Commands
+
+```
+# Install (three modes)
+total-recall install --project NAME                    Standalone: full local setup
+total-recall install --project NAME --server            Server: local + HTTP API + launchd
+total-recall install --project NAME --client --server-url URL --api-key KEY   Client: remote only
+
+# Core
+total-recall write   --project NAME "<summary>"        Write a memory note
+total-recall query   --project NAME "<query>"          Semantic search across memories
+total-recall ingest  --project NAME                    Import Claude/Codex session logs
+total-recall status  --project NAME                    Show memory stats and config
+
+# iCloud
+total-recall icloud-enable   --project NAME            Move memory to iCloud Drive
+total-recall icloud-sync     --project NAME            Manual iCloud push/pull
+total-recall icloud-status   --project NAME            Check iCloud sync state
+
+# Server management
+total-recall server init / start / stop / status / add-key / install-launchd
+
+# Client management
+total-recall client configure / status / enable / disable
+```
+
+### Plugin Slash Commands
+
+When installed as a Claude Code plugin:
+
+- `/memory-setup` — Interactive setup wizard for the current project
+- `/memory-write` — Write a session summary to memory
+- `/memory-rebuild` — Rebuild memory from git history and Codex sessions
+
+## Install Options
+
+```bash
+# Standalone options
+total-recall install --project my-project --no-icloud          # Skip iCloud backup
+total-recall install --project my-project --no-launch-agent    # Skip background sync
+total-recall install --project my-project --interval-minutes 10 # Sync every 10 min
+total-recall install --project my-project --skip-embed         # Skip vector embeddings
+
+# Server options
+total-recall install --project my-project --server --port 8080 # Custom port
+
+# Client (no local qmd or bun needed)
+total-recall install --project my-project --client \
+  --server-url http://server:7899 --api-key tr_sk_...
+```
+
+## Environment Variables
+
+| Variable | Default | Purpose |
+|----------|---------|---------|
+| `TOTAL_RECALL_SHARED_ROOT` | `~/.ai-memory/knowledge` | Base directory for all project memories |
+| `TOTAL_RECALL_ICLOUD_ROOT` | `~/Library/Mobile Documents/.../AI-Memory/knowledge` | iCloud sync directory |
+| `TOTAL_RECALL_STATE_ROOT` | `~/.ai-memory/state` | Ingestion state tracking |
+| `TOTAL_RECALL_SERVER_URL` | — | Override client server URL |
+| `TOTAL_RECALL_API_KEY` | — | Override client API key |
+| `TOTAL_RECALL_SYNC_INTERVAL_MINUTES` | `15` | Background sync interval |
+
+## Requirements
+
+**Standalone / Server:**
+- macOS (iCloud + launchd features are macOS-only; core memory works anywhere)
+- [bun](https://bun.sh) (for installing qmd)
+- [qmd](https://github.com/tobi/qmd) (installed automatically)
+- Python 3.8+ (for server and session ingestion)
+
+**Client only:**
+- Python 3.8+ (for CLI)
+- No bun or qmd needed — everything routes to the server
+
+## License
+
+MIT

package/commands/memory-rebuild.md

@@ -0,0 +1,100 @@
+---
+description: "Rebuild session memory from git history and optionally Codex sessions"
+allowed-tools: [Bash, Write, Read, Glob, Grep]
+argument-hint: "[--since YYYY-MM-DD] [--codex]"
+---
+
+# Rebuild Session Memory
+
+Reconstruct the full session history from git commits and optionally from OpenAI Codex CLI session logs.
+
+## Context
+
+- Project root: !`git -C "$PWD" rev-parse --show-toplevel 2>/dev/null || echo "$PWD"`
+- Project name: !`basename "$(git -C "$PWD" remote get-url origin 2>/dev/null | sed 's/.*\///' | sed 's/\.git$//')" 2>/dev/null || basename "$PWD"`
+- Knowledge dir: !`PROJECT=$(basename "$(git remote get-url origin 2>/dev/null | sed 's/.*\///' | sed 's/\.git$//')" 2>/dev/null || basename "$PWD"); echo "$HOME/.claude/knowledge/$PROJECT"`
+- Git log summary: !`git log --oneline --since="2025-01-01" | wc -l` commits since 2025
+- Existing session files: !`PROJECT=$(basename "$(git remote get-url origin 2>/dev/null | sed 's/.*\///' | sed 's/\.git$//')" 2>/dev/null || basename "$PWD"); ls "$HOME/.claude/knowledge/$PROJECT/sessions/" 2>/dev/null | wc -l` files
+- Codex sessions exist: !`ls ~/.codex/sessions/ 2>/dev/null && echo "yes" || echo "no"`
+- Arguments: $ARGUMENTS
+
+## Your Task
+
+Use the detected project name and knowledge directory from the context above.
+
+### 1. Parse Arguments
+
+- `--since YYYY-MM-DD`: Only rebuild from this date forward (default: all history)
+- `--codex`: Also parse Codex CLI `.jsonl` session files from `~/.codex/sessions/`
+
+### 2. Analyze Git History
+
+```bash
+git log --format="%H %ai %s" --since="<date>"
+```
+
+Group commits into logical sessions by:
+- Date proximity (same day = same session usually)
+- Topic coherence (related commit messages)
+- Author patterns (structured `feat/fix/chore` commits vs informal)
+
+### 3. Parse Codex Sessions (if --codex)
+
+For each `.jsonl` file in `~/.codex/sessions/` (and `~/.codex/archived_sessions/`):
+- Extract user messages (role: "user", type: "input_text")
+- Skip system instructions and environment context blocks
+- Handle both old format (direct content) and new format (event_msg with payload)
+- Group by session file (each file = one session)
+
+Use this Python extraction pattern:
+```python
+import sys, json
+for line in sys.stdin:
+    try:
+        obj = json.loads(line.strip())
+        if obj.get('role') == 'user':
+            for c in obj.get('content', []):
+                text = c.get('text', '')
+                if text and not text.startswith('<user_instructions>') and not text.startswith('<environment_context>'):
+                    print(text[:500])
+    except: pass
+```
+
+### 4. Write Session Files
+
+For each identified session, write to `<knowledge-dir>/sessions/YYYY-MM-DD-<topic>.md` using the standard template:
+
+```markdown
+# Session: [Brief Title]
+
+**Date:** YYYY-MM-DD
+**Machine:** !`scutil --get ComputerName 2>/dev/null || hostname -s`
+**Topic:** [Category — specific area]
+**Tool:** [Claude Code / Codex CLI / Cursor / Manual]
+
+## What Was Done
+- [Bullet points]
+
+## Decisions Made
+- [Choices and reasoning]
+
+## Lessons Learned
+- [Gotchas and insights]
+```
+
+Rules:
+- Don't overwrite existing session files — skip dates that already have files
+- For Codex sessions, note the tool as "OpenAI Codex CLI"
+- For Cursor PRs (cursor/ branch prefixes), note as "Cursor"
+- Group small related sessions on the same day into one file
+- Use concise but informative descriptions
+
+### 5. Re-index and Embed
+
+```bash
+qmd update && qmd embed
+```
+
+### 6. Report
+
+Tell the user how many session files were created/updated and the total knowledge base size.

package/commands/memory-setup.md

@@ -0,0 +1,94 @@
+---
+description: "Set up total-recall memory for the current project"
+allowed-tools: [Bash, Read, Write, Glob]
+---
+
+# Total Recall Setup
+
+Set up cross-session semantic memory for the current project. This runs the full `total-recall install` — shared memory, session ingestion, qmd indexing, and background sync.
+
+## Context
+
+- Current directory: !`pwd`
+- Git remote: !`git remote get-url origin 2>/dev/null || echo "no git remote"`
+- Detected project name: !`basename "$(git remote get-url origin 2>/dev/null | sed 's/.*\///' | sed 's/\.git$//')" 2>/dev/null || basename "$PWD"`
+- Platform: !`uname -s`
+- iCloud Drive exists: !`[ -d "$HOME/Library/Mobile Documents/com~apple~CloudDocs" ] && echo "yes" || echo "no"`
+- qmd installed: !`command -v qmd >/dev/null 2>&1 && echo "yes" || echo "no"`
+- bun installed: !`command -v bun >/dev/null 2>&1 && echo "yes" || echo "no"`
+- Plugin root: !`echo "${CLAUDE_PLUGIN_ROOT:-unknown}"`
+- Client configured: !`[ -f "$HOME/.ai-memory/client.json" ] && echo "yes" || echo "no"`
+- Server configured: !`[ -f "$HOME/.ai-memory/server.json" ] && echo "yes" || echo "no"`
+- User arguments: $ARGUMENTS
+
+## Your Task
+
+### 1. Pre-flight check
+
+If `qmd` is not installed and `bun` is not installed either, stop and tell the user:
+```
+Install bun first: curl -fsSL https://bun.sh/install | bash
+Then re-run /memory-setup
+```
+
+If `bun` is available but `qmd` is not, install it:
+```bash
+bun install -g github:tobi/qmd
+```
+
+### 2. Ask the user (interactive)
+
+Ask the user these questions **before** running anything. Present them all at once so the user can answer in one go.
+
+**Project name:** Show the auto-detected name from context above. Ask if it's correct or if they want a different name. If the user provided a name via `$ARGUMENTS`, use that without asking.
+
+**iCloud backup:** Only ask on macOS when iCloud Drive exists. Default yes. Explain: "This syncs your memory to iCloud so it survives machine changes."
+
+**Background sync:** Only ask on macOS. Default yes. Explain: "This installs a background job that imports new Claude/Codex session logs every 15 minutes."
+
+**Multi-machine mode:** If no server or client is configured, ask if this machine should:
+- **Standalone** (default) — memory stays local (with optional iCloud)
+- **Server** — this machine hosts a total-recall HTTP server that other machines connect to
+- **Client** — this machine connects to an existing total-recall server
+
+### 3. Run total-recall install
+
+Build the command from the user's answers:
+
+```bash
+<plugin-root>/scripts/total-recall install \
+  --project <project-name> \
+  [--no-icloud] \
+  [--no-launch-agent]
+```
+
+Where `<plugin-root>` is the Plugin root from context above. Run it and let the output stream.
+
+### 4. Multi-machine setup (if selected)
+
+**If Server:**
+```bash
+<plugin-root>/scripts/total-recall server init
+<plugin-root>/scripts/total-recall server start
+```
+Tell the user their API key and server URL. Ask if they want to auto-start on boot:
+```bash
+<plugin-root>/scripts/total-recall server install-launchd
+```
+
+**If Client:**
+Ask the user for the server URL and API key, then:
+```bash
+<plugin-root>/scripts/total-recall client configure \
+  --server-url <url> \
+  --api-key <key>
+```
+
+### 5. Report results
+
+Tell the user:
+- Setup is complete
+- Memory is fully automatic — Claude will query past memories at session start and save new ones at session end, no manual commands needed
+- If server mode: share the server URL and API key with other machines, and mention the web UI at `http://<server>:7899/`
+- If client mode: confirm the connection is active with `total-recall client status`
+- `/memory-rebuild` can optionally backfill memory from git history if they want to seed it with past work

package/commands/memory-write.md

@@ -0,0 +1,69 @@
+---
+description: "Write a session summary to qmd memory"
+model: sonnet
+allowed-tools: [Bash, Write, Read, Glob, Grep]
+---
+
+# Write Session Memory
+
+Write a summary of the current session's work to the qmd knowledge base.
+
+## Context
+
+- Today's date: !`date +%Y-%m-%d`
+- Project root: !`git -C "$PWD" rev-parse --show-toplevel 2>/dev/null || echo "$PWD"`
+- Project name: !`basename "$(git -C "$PWD" remote get-url origin 2>/dev/null | sed 's/.*\///' | sed 's/\.git$//')" 2>/dev/null || basename "$PWD"`
+- Knowledge dir: !`PROJECT=$(basename "$(git remote get-url origin 2>/dev/null | sed 's/.*\///' | sed 's/\.git$//')" 2>/dev/null || basename "$PWD"); echo "$HOME/.claude/knowledge/$PROJECT"`
+- Recent commits (last 24h): !`git log --oneline --since="24 hours ago" 2>/dev/null || echo "no recent commits"`
+- Uncommitted changes: !`git diff --stat HEAD 2>/dev/null || echo "no changes"`
+- Untracked files: !`git ls-files --others --exclude-standard 2>/dev/null | head -10`
+- Latest session file: !`PROJECT=$(basename "$(git remote get-url origin 2>/dev/null | sed 's/.*\///' | sed 's/\.git$//')" 2>/dev/null || basename "$PWD"); ls -t "$HOME/.claude/knowledge/$PROJECT/sessions/" 2>/dev/null | head -1`
+- User request: $ARGUMENTS
+
+## Your Task
+
+Write a session summary capturing what was done in this session. Use the detected project name and knowledge directory from the context above.
+
+### 1. Determine What Was Done
+
+Analyze the git log, diffs, and any context from the conversation to understand what work was completed. If the user provided a description via `$ARGUMENTS`, use that as the primary source.
+
+### 2. Generate Session File
+
+Write the summary to `<knowledge-dir>/sessions/YYYY-MM-DD-<topic>.md` using this template:
+
+```markdown
+# Session: [Brief Title]
+
+**Date:** YYYY-MM-DD
+**Machine:** !`scutil --get ComputerName 2>/dev/null || hostname -s`
+**Topic:** [Category — specific area]
+
+## What Was Done
+- [Bullet points of completed work]
+
+## Decisions Made
+- [Any choices made and why]
+
+## Lessons Learned
+- [Gotchas, insights, things to remember]
+```
+
+Rules:
+- Topic slug should be kebab-case, 2-4 words (e.g., `ingredient-display-fixes`)
+- If a file for today with the same topic already exists, append a number suffix
+- Be concise but capture the important details — especially decisions and lessons
+- Include specific file paths, function names, or error messages that would help future sessions
+
+### 3. Index and Embed
+
+Run:
+```bash
+qmd update && qmd embed
+```
+
+The `qmd embed` may crash on cleanup (known bun bug) — this is harmless.
+
+### 4. Confirm
+
+Tell the user what file was written and that it's been indexed.

package/hooks/hooks.json

@@ -0,0 +1,26 @@
+{
+  "description": "Total Recall: cross-session memory persistence via qmd",
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/session-start-query.sh",
+            "statusMessage": "Loading session memory..."
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/session-summary-reminder.sh"
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/session-start-query.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+# SessionStart hook — tells Claude to query Total Recall before doing anything else.
+INPUT=$(cat)
+
+# Get cwd from hook input (more reliable than $PWD in hook context)
+CWD=$(echo "$INPUT" | jq -r '.cwd // empty')
+CWD="${CWD:-$PWD}"
+
+# Ensure bun-installed globals (like qmd) are on PATH
+for p in "$HOME/.bun/bin" "/opt/homebrew/bin" "/usr/local/bin"; do
+  [ -d "$p" ] && export PATH="$p:$PATH"
+done
+
+# Extract project name from the total-recall instruction block in CLAUDE.md
+# This is the most reliable source — it's set during `total-recall install`
+PROJECT=""
+CLAUDE_MD="$HOME/.claude/CLAUDE.md"
+if [ -f "$CLAUDE_MD" ]; then
+  PROJECT=$(sed -n 's/.*Total Recall Auto-Memory (\([^)]*\)).*/\1/p' "$CLAUDE_MD" | head -1)
+fi
+
+# Fallback: derive from git remote or directory name
+if [ -z "$PROJECT" ]; then
+  PROJECT=$(basename "$(git -C "$CWD" remote get-url origin 2>/dev/null | sed 's/.*\///' | sed 's/\.git$//')" 2>/dev/null || basename "$CWD")
+fi
+
+CLI="${CLAUDE_PLUGIN_ROOT}/scripts/total-recall"
+KNOWLEDGE_DIR="$HOME/.ai-memory/knowledge/$PROJECT"
+CLIENT_JSON="$HOME/.ai-memory/client.json"
+
+# Activate if local qmd memory exists OR if a remote server is configured
+if { [ -d "$KNOWLEDGE_DIR" ] && command -v qmd >/dev/null 2>&1; } || [ -f "$CLIENT_JSON" ]; then
+  jq -n --arg cli "$CLI" --arg project "$PROJECT" '{
+    "hookSpecificOutput": {
+      "hookEventName": "SessionStart",
+      "additionalContext": ("TOTAL RECALL MEMORY SYSTEM ACTIVE.\nYour FIRST action — before reading files, before planning, before anything — MUST be to query prior session memory:\n`" + $cli + " query --project " + $project + " \"<what the user is asking about>\"`\nThis retrieves context from all previous sessions. Without it, you will repeat past mistakes and miss prior decisions. This is mandatory, not optional.")
+    }
+  }'
+fi
+
+exit 0

package/hooks/session-summary-reminder.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+INPUT=$(cat)
+
+# Prevent infinite loop — if we already triggered a stop hook continuation, let it end
+if [ "$(echo "$INPUT" | jq -r '.stop_hook_active // false')" = "true" ]; then
+  exit 0
+fi
+
+# Get cwd from hook input (more reliable than $PWD in hook context)
+CWD=$(echo "$INPUT" | jq -r '.cwd // empty')
+CWD="${CWD:-$PWD}"
+
+# Ensure bun-installed globals (like qmd) are on PATH
+for p in "$HOME/.bun/bin" "/opt/homebrew/bin" "/usr/local/bin"; do
+  [ -d "$p" ] && export PATH="$p:$PATH"
+done
+
+# Extract project name from the total-recall instruction block in CLAUDE.md
+# This is the most reliable source — it's set during `total-recall install`
+PROJECT=""
+CLAUDE_MD="$HOME/.claude/CLAUDE.md"
+if [ -f "$CLAUDE_MD" ]; then
+  PROJECT=$(sed -n 's/.*Total Recall Auto-Memory (\([^)]*\)).*/\1/p' "$CLAUDE_MD" | head -1)
+fi
+
+# Fallback: derive from git remote or directory name
+if [ -z "$PROJECT" ]; then
+  PROJECT=$(basename "$(git -C "$CWD" remote get-url origin 2>/dev/null | sed 's/.*\///' | sed 's/\.git$//')" 2>/dev/null || basename "$CWD")
+fi
+
+CLI="${CLAUDE_PLUGIN_ROOT}/scripts/total-recall"
+KNOWLEDGE_DIR="$HOME/.ai-memory/knowledge/$PROJECT"
+CLIENT_JSON="$HOME/.ai-memory/client.json"
+
+# Activate if local qmd memory exists OR if a remote server is configured
+if { [ -d "$KNOWLEDGE_DIR" ] && command -v qmd >/dev/null 2>&1; } || [ -f "$CLIENT_JSON" ]; then
+  jq -n --arg cli "$CLI" --arg project "$PROJECT" '{
+    "decision": "block",
+    "reason": ("BEFORE STOPPING: You must persist what you learned this session. Run:\n`" + $cli + " write --project " + $project + " \"<concise summary: what changed, why, and what was learned>\"`\nThen you may stop. If this session was truly trivial (only reading files, no changes, no decisions), you may skip this — but explain why.")
+  }'
+else
+  exit 0
+fi

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "total-recall-memory",
+  "version": "1.3.0",
+  "description": "Persistent cross-session memory for Claude Code. Automatically stores decisions, patterns, and lessons learned in a semantic search index so every session starts with full context. Supports multi-machine sharing via HTTP server with web UI.",
+  "bin": {
+    "total-recall": "scripts/total-recall"
+  },
+  "scripts": {
+    "postinstall": "chmod +x ./scripts/total-recall ./scripts/ingest_sessions.py ./scripts/total-recall-server 2>/dev/null || true"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "codex",
+    "memory",
+    "knowledge",
+    "semantic-search",
+    "sessions",
+    "qmd",
+    "multi-machine",
+    "cross-session",
+    "persistence",
+    "ai",
+    "llm"
+  ],
+  "author": "Radu Lupu",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/radu2lupu/total-recall.git"
+  },
+  "homepage": "https://github.com/radu2lupu/total-recall",
+  "bugs": {
+    "url": "https://github.com/radu2lupu/total-recall/issues"
+  },
+  "os": [
+    "darwin",
+    "linux"
+  ],
+  "engines": {
+    "node": ">=16"
+  },
+  "files": [
+    "scripts/",
+    "hooks/",
+    "commands/",
+    ".claude-plugin/",
+    "LICENSE",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}