memoir-cli 3.3.1 → 3.5.0

package/README.md

@@ -2,37 +2,27 @@
 
 # memoir
 
-**Persistent memory for AI coding tools.**
+**Portable memory for every AI coding tool.**
 
 [![npm version](https://img.shields.io/npm/v/memoir-cli.svg?style=flat-square&color=7c6ef0)](https://npmjs.org/package/memoir-cli)
 [![npm downloads](https://img.shields.io/npm/dm/memoir-cli.svg?style=flat-square&color=7c6ef0)](https://npmjs.org/package/memoir-cli)
 [![GitHub stars](https://img.shields.io/github/stars/camgitt/memoir?style=flat-square&color=7c6ef0)](https://github.com/camgitt/memoir/stargazers)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](LICENSE)
-[![Node.js](https://img.shields.io/badge/node-%3E%3D18-brightgreen?style=flat-square)](https://nodejs.org)
-
-Your AI forgets everything between sessions. memoir gives it long-term memory via MCP.
-
-**11 tools supported** • **E2E encrypted** • **Cross-platform** • **Open source**
-
-Works with Claude Code, Cursor, Windsurf, Gemini, Copilot, Codex, ChatGPT, Aider, Zed, Cline, and Continue.dev.
-
-[Website](https://memoir.sh) • [npm](https://npmjs.org/package/memoir-cli) • [Blog](https://memoir.sh/blog) • [Contributing](CONTRIBUTING.md)
-
-<br />
-
-<img src="demo.svg" alt="memoir demo — push, restore, and sync AI memory" width="700" />
 
 </div>
 
-## The Problem
+```bash
+npm install -g memoir-cli
+memoir activate
+```
 
-You told Claude your project uses Zustand, not Redux. You explained your auth middleware to Cursor. You spent weeks building up context across your AI tools.
+Your AI now remembers across sessions, tools, and machines. Works with Claude Code, Cursor, Windsurf, Gemini, Copilot, and 6 more tools.
 
-Next session? **Gone.** New machine? **Gone.** Switch tools? **Gone.**
+---
 
-## How memoir fixes it
+## What it does
 
-memoir is a **persistent memory layer** that runs via [MCP](https://modelcontextprotocol.io) inside your AI tools. Your AI can search, read, and save memories automatically — across sessions, tools, and machines.
+memoir is an [MCP server](https://modelcontextprotocol.io) that gives your AI tools persistent memory. Your AI can search, save, and recall context automatically.
 
 ```
 you: how does auth work in this project?
@@ -47,38 +37,15 @@ claude: Based on your previous sessions: this project uses JWT auth
 
 No re-explaining. memoir remembered.
 
-## Architecture
-
-```mermaid
-graph LR
-    A[Claude Code] --> M[memoir MCP]
-    B[Cursor] --> M
-    C[Gemini CLI] --> M
-    D[Windsurf] --> M
-    E[+ 7 more] --> M
-
-    M --> R[recall / remember / list / read]
-    R --> S[(Local Memory Store)]
-
-    S --> P[memoir push]
-    P --> G[GitHub / Cloud]
-    G --> Q[memoir restore]
-    Q --> S2[(New Machine)]
-```
-
-memoir runs as a local MCP server inside your AI tools. Your AI can search, save, and recall memories automatically. Push to sync across machines.
+## Setup
 
-## Quick Start
+### 1. Install
 
 ```bash
-# Install
 npm install -g memoir-cli
-
-# Setup
-memoir init
 ```
 
-### Add MCP to your AI tools
+### 2. Add MCP to your AI tool
 
 **Claude Code** — add to `~/.mcp.json`:
 ```json
@@ -98,7 +65,13 @@ memoir init
 }
 ```
 
-That's it. Your AI tools now have 6 memory abilities:
+### 3. Activate in your project
+
+```bash
+memoir activate
+```
+
+That's it. Your AI now has 6 memory tools:
 
 | MCP Tool | What it does |
 |----------|-------------|
@@ -109,49 +82,28 @@ That's it. Your AI tools now have 6 memory abilities:
 | `memoir_status` | See which AI tools are detected |
 | `memoir_profiles` | Switch between work/personal |
 
-## What Gets Synced
-
-memoir syncs three layers that no other tool connects:
+## Why memoir
 
-### Layer 1: AI Memory (via MCP + CLI)
-Configs, instructions, and project knowledge across 11 tools — searchable and writable from inside any AI conversation.
+Your AI forgets everything between sessions. You re-explain your codebase, your conventions, your decisions — every time.
 
-| Tool | What gets synced |
-|------|-----------------|
-| **Claude Code** | ~/.claude/ settings, memory, CLAUDE.md files |
-| **Gemini CLI** | ~/.gemini/ config, GEMINI.md files |
-| **ChatGPT** | CHATGPT.md custom instructions |
-| **OpenAI Codex** | ~/.codex/ config, AGENTS.md |
-| **Cursor** | Settings, keybindings, .cursorrules |
-| **GitHub Copilot** | Config, copilot-instructions.md |
-| **Windsurf** | Settings, keybindings, .windsurfrules |
-| **Zed** | Settings, keymap, tasks |
-| **Cline** | Settings, .clinerules |
-| **Continue.dev** | Config, .continuerules |
-| **Aider** | .aider.conf.yml, system prompt |
+memoir fixes this by giving your AI a shared memory layer that works across **every tool you use**. Tell Claude something once. Cursor knows it too.
 
-### Layer 2: Session State
-What you were **doing** — not just what your AI knows, but the active context.
+**11 tools supported:** Claude Code, Cursor, Windsurf, Gemini CLI, GitHub Copilot, OpenAI Codex, ChatGPT, Aider, Zed, Cline, Continue.dev
 
-- Last coding session captured automatically
-- What files you changed, what errors you hit, what decisions you made
-- Injected into your AI on restore so it picks up mid-conversation
-- Secrets auto-redacted (API keys, tokens, passwords stripped before sync)
+## Sync across machines
 
-### Layer 3: Workspace
-Your actual projects — code, files, everything.
+```bash
+# Back up
+memoir push
 
-- **Git projects:** Remote URLs saved, auto-cloned on restore
-- **Non-git projects:** Bundled as compressed archives, unpacked on restore
-- **Uncommitted work:** Saved as patches, applied after clone
-- **Zero git commands needed** — memoir handles it all
+# Restore on any machine
+memoir restore -y
+```
 
-## Key Features
+Push syncs AI memory, session context, workspace (git repos + uncommitted work), and project configs. E2E encrypted with AES-256-GCM.
 
-### Cross-tool memory
-Tell Claude something once. Cursor knows it too. memoir is the shared memory layer between all your AI tools.
+## Translate between AI tools
 
-### Translate between AI tools
 ```bash
 memoir migrate --from chatgpt --to claude
 # AI-powered — rewrites conventions, not copy-paste
@@ -160,56 +112,25 @@ memoir migrate --from chatgpt --to all
 # Translate to every tool at once
 ```
 
-### Cross-machine sync
-```bash
-# On your main machine
-memoir push
-
-# On any other machine
-memoir restore -y
-# ✔ AI memory restored (Claude, Gemini, Cursor, 11 tools)
-# ✔ 44 projects cloned & unpacked
-# ✔ Uncommitted changes applied
-# ✔ Session context injected — AI picks up mid-conversation
-```
-
-### E2E Encryption
-```bash
-memoir encrypt    # toggle encryption on/off
-memoir push       # prompted for passphrase, AES-256-GCM encrypted
-```
-
-Your backup is encrypted before it leaves your machine. Secret scanning auto-redacts API keys, tokens, and passwords.
-
-### Profiles (personal / work)
-```bash
-memoir profile create work
-memoir push --profile work
-memoir profile switch personal
-```
+## Cloud sync
 
-### Cloud sync
 ```bash
 memoir login
 memoir cloud push      # encrypted cloud backup
 memoir cloud restore   # restore from any version
+memoir history         # view backup versions
+memoir share           # create encrypted shareable link
 ```
 
-### Cross-platform (Mac / Windows / Linux)
-Paths remap automatically between platforms. Push from Mac, restore on Windows. It just works.
-
 ## All Commands
 
 | Command | What it does |
 |---------|-------------|
-| `memoir init` | Setup wizard — GitHub or local storage |
+| `memoir activate` | Enable auto-recall in this project |
+| `memoir deactivate` | Remove memoir from this project |
 | `memoir push` | Back up AI memory + workspace + session |
 | `memoir restore` | Restore everything on a new machine |
-| `memoir mcp` | Start MCP server for editor integration |
 | `memoir status` | Show detected AI tools |
-| `memoir doctor` | Diagnose issues, scan for secrets |
-| `memoir view` | Preview what's in your backup |
-| `memoir diff` | Show changes since last backup |
 | `memoir migrate` | Translate memory between tools via AI |
 | `memoir snapshot` | Capture current coding session |
 | `memoir resume` | Pick up where you left off |
@@ -217,95 +138,24 @@ Paths remap automatically between platforms. Push from Mac, restore on Windows.
 | `memoir profile` | Manage profiles (personal/work) |
 | `memoir cloud push` | Back up to memoir cloud |
 | `memoir cloud restore` | Restore from memoir cloud |
-| `memoir history` | View cloud backup versions |
-| `memoir login` | Sign in to memoir cloud |
 | `memoir share` | Create encrypted shareable link |
-| `memoir upgrade` | View plans and upgrade |
+| `memoir doctor` | Diagnose issues |
+| `memoir diff` | Show changes since last backup |
+| `memoir view` | Preview what's in your backup |
 | `memoir update` | Self-update to latest version |
 
-## How memoir compares
-
-| Feature | memoir | dotfiles managers | ai-rulez | memories.sh |
-|---------|--------|-------------------|----------|-------------|
-| MCP memory layer | **6 tools** | No | No | No |
-| AI memory sync | **11 tools** | No | 18 tools | 3 tools |
-| Cross-tool recall | **Yes** | No | No | No |
-| Workspace sync | **Yes** | No | No | No |
-| Session handoff | **Yes** | No | No | No |
-| AI-powered migration | **Yes** | No | No | No |
-| E2E encryption | **Yes** | No | No | No |
-| Secret scanning | **Yes** | Some | No | No |
-| Cross-platform remap | **Yes** | Some | No | No |
-| Cloud backup | **Yes** | No | No | Yes ($15/mo) |
-| Profiles | **Yes** | No | No | No |
-| Free & open source | **Yes** | Yes | Yes | No |
-
-## Common Workflows
-
-### Your AI remembers across sessions
-```
-# Monday — you explain your auth setup to Claude
-# ...Claude calls memoir_remember to save the decision
-
-# Thursday — new conversation
-you: "add a protected route"
-# Claude calls memoir_recall, finds your auth architecture
-# No re-explaining needed
-```
-
-### New machine setup
-```bash
-npm install -g memoir-cli && memoir init && memoir restore -y
-# Done. Everything's back.
-```
-
-### Switching AI tools
-```bash
-memoir migrate --from chatgpt --to claude
-# Your custom instructions become a proper CLAUDE.md
-```
-
-### Team onboarding
-```bash
-# Senior dev pushes team config
-memoir push --profile team
-
-# New hire runs one command
-memoir restore --profile team
-# Every project cloned. Every AI tool configured. Day one productive.
-```
-
 ## Security
 
 - **E2E encryption** — AES-256-GCM with scrypt key derivation
-- **Secret scanning** — 20+ patterns detect API keys, tokens, passwords, connection strings
-- **Auto-redaction** — secrets stripped from session handoffs before sync
-- **No credentials synced** — .env files, auth tokens, and API keys are never included
-- **Passphrase verified** — wrong passphrase caught before decrypt attempt
-- **Local MCP server** — runs on your machine, no data sent to external services
-
-## Requirements
-
-- Node.js >= 18
-- Git (for workspace sync)
-- Works on macOS, Windows, Linux
-
-## Contributing
-
-Contributions welcome — especially new tool adapters and MCP improvements.
-
-1. Fork the repo
-2. Create your branch (`git checkout -b feature/my-feature`)
-3. Commit and push
-4. Open a PR
+- **Secret scanning** — API keys, tokens, passwords auto-redacted before sync
+- **Local MCP server** — runs on your machine, no data sent externally
+- **Zero-knowledge cloud** — encrypted before upload
 
 ## Links
 
 - **Website:** [memoir.sh](https://memoir.sh)
 - **npm:** [memoir-cli](https://npmjs.org/package/memoir-cli)
-- **Blog:** [memoir.sh/blog](https://memoir.sh/blog)
 - **Issues:** [GitHub Issues](https://github.com/camgitt/memoir/issues)
+- **Contributing:** [CONTRIBUTING.md](CONTRIBUTING.md)
 
-## License
-
-MIT
+MIT Licensed

package/bin/memoir.js

@@ -20,6 +20,7 @@ import { shareCommand } from '../src/commands/share.js';
 import { historyCommand } from '../src/commands/history.js';
 import { projectsListCommand, projectsTodoCommand } from '../src/commands/projects.js';
 import { upgradeCommand } from '../src/commands/upgrade.js';
+import { activateCommand, deactivateCommand } from '../src/commands/activate.js';
 import { createRequire } from 'module';
 
 const require = createRequire(import.meta.url);
@@ -52,40 +53,18 @@ async function checkForUpdate() {
   } catch {}
 }
 
-// Show quick start when run with no args
+// When run with no args: auto-push (zero-config)
 if (process.argv.length <= 2) {
-  console.log('\n' + boxen(
-    gradient.pastel.multiline('  memoir  ') + '\n' +
-    chalk.gray('  Your AI remembers everything.') + '\n\n' +
-    chalk.white.bold('Quick Start:') + '\n' +
-    chalk.cyan('  memoir init      ') + chalk.gray('— first-time setup') + '\n' +
-    chalk.cyan('  memoir push      ') + chalk.gray('— back up your AI memory') + '\n' +
-    chalk.cyan('  memoir restore   ') + chalk.gray('— restore on a new machine') + '\n' +
-    chalk.cyan('  memoir snapshot  ') + chalk.gray('— capture your current session') + '\n' +
-    chalk.cyan('  memoir resume    ') + chalk.gray('— pick up where you left off') + '\n' +
-    chalk.cyan('  memoir status    ') + chalk.gray('— see detected AI tools') + '\n' +
-    chalk.cyan('  memoir profile   ') + chalk.gray('— manage profiles (personal/work)') + '\n' +
-    chalk.cyan('  memoir projects   ') + chalk.gray('— see all your projects at a glance') + '\n' +
-    chalk.cyan('  memoir encrypt   ') + chalk.gray('— toggle E2E encryption') + '\n' +
-    chalk.cyan('  memoir update    ') + chalk.gray('— update to latest version') + '\n' +
-    chalk.cyan('  memoir upgrade   ') + chalk.gray('— view plans & upgrade') + '\n\n' +
-    chalk.white.bold('Cloud (Pro):') + '\n' +
-    chalk.cyan('  memoir login         ') + chalk.gray('— sign in to memoir cloud') + '\n' +
-    chalk.cyan('  memoir cloud push    ') + chalk.gray('— back up to the cloud') + '\n' +
-    chalk.cyan('  memoir cloud restore ') + chalk.gray('— restore from cloud') + '\n' +
-    chalk.cyan('  memoir share         ') + chalk.gray('— share memory via secure link') + '\n' +
-    chalk.cyan('  memoir history       ') + chalk.gray('— view backup versions') + '\n\n' +
-    chalk.gray('  Tip: use --profile work to sync a specific profile') + '\n\n' +
-    chalk.gray(`v${VERSION}`),
-    { padding: 1, borderStyle: 'round', borderColor: 'cyan', dimBorder: true }
-  ) + '\n');
-  process.exit(0);
+  // Pass 'push' as the command so Commander routes to pushCommand
+  process.argv.push('push');
 }
 
 // Custom help banner
 program.addHelpText('beforeAll', '\n' + boxen(
   gradient.pastel.multiline('  memoir  ') + '\n' +
-  chalk.gray('  Your AI remembers everything.'),
+  chalk.gray('  Your AI remembers everything.') + '\n\n' +
+  chalk.white.bold('Zero-config:') + ' just run ' + chalk.cyan('memoir') + ' or ' + chalk.cyan('npx memoir-cli') + '\n' +
+  chalk.gray('Auto-detects your GitHub, creates a private repo, and backs up.'),
   { padding: { top: 0, bottom: 0, left: 1, right: 1 }, borderStyle: 'round', borderColor: 'cyan', dimBorder: true }
 ) + '\n');
 
@@ -298,6 +277,30 @@ program
     }
   });
 
+program
+  .command('activate')
+  .description('Add memoir instructions to this project so your AI uses it automatically')
+  .action(async () => {
+    try {
+      await activateCommand();
+    } catch (err) {
+      console.error(chalk.red('\n✖ Error:'), err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('deactivate')
+  .description('Remove memoir instructions from this project')
+  .action(async () => {
+    try {
+      await deactivateCommand();
+    } catch (err) {
+      console.error(chalk.red('\n✖ Error:'), err.message);
+      process.exit(1);
+    }
+  });
+
 program
   .command('encrypt')
   .description('Toggle E2E encryption for your backups')

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "memoir-cli",
-  "version": "3.3.1",
+  "version": "3.5.0",
   "mcpName": "io.github.camgitt/memoir",
-  "description": "Persistent memory for AI coding tools via MCP. Your AI remembers across sessions, tools, and machines. Works with Claude, Cursor, Gemini, Windsurf, and 7 more tools.",
+  "description": "MCP server that gives Claude, Cursor, and Gemini long-term memory across sessions. Your AI remembers your codebase, decisions, and preferences — across tools and machines.",
   "main": "src/index.js",
   "type": "module",
   "bin": {
@@ -19,7 +19,8 @@
   },
   "scripts": {
     "start": "node bin/memoir.js",
-    "test": "bash test-local.sh"
+    "test": "bash test-local.sh",
+    "postinstall": "node -e \"try{const c='\\x1b[36m',r='\\x1b[0m',g='\\x1b[90m';console.log('\\n  '+c+'memoir'+r+' installed.\\n  Run '+c+'memoir activate'+r+' in any project to give your AI long-term memory.\\n  '+g+'https://memoir.sh'+r+'\\n')}catch{}\""
   },
   "keywords": [
     "mcp",

package/src/cloud/constants.js

@@ -1,5 +1,5 @@
 export const SUPABASE_URL = process.env.MEMOIR_SUPABASE_URL || 'https://oqrkxytbahfwjhcbyzrx.supabase.co';
 export const SUPABASE_ANON_KEY = process.env.MEMOIR_SUPABASE_ANON_KEY || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im9xcmt4eXRiYWhmd2poY2J5enJ4Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzMyMTQ4MzMsImV4cCI6MjA4ODc5MDgzM30.jOKOi73OJgIgi1zj0VOIQkGp0xqS3ee4gfCjpdqCnvM';
 export const STORAGE_BUCKET = 'memoir-backups';
-export const MAX_BACKUPS_FREE = 3;
+export const MAX_BACKUPS_FREE = 100;
 export const MAX_BACKUPS_PRO = 50;

package/src/commands/activate.js

@@ -0,0 +1,232 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import inquirer from 'inquirer';
+
+// The instruction files each AI tool reads, in priority order
+const INSTRUCTION_FILES = [
+  { file: 'CLAUDE.md', tool: 'Claude' },
+  { file: '.cursorrules', tool: 'Cursor' },
+  { file: '.windsurfrules', tool: 'Windsurf' },
+  { file: '.github/copilot-instructions.md', tool: 'Copilot' },
+  { file: '.clinerules', tool: 'Cline' },
+  { file: 'GEMINI.md', tool: 'Gemini' },
+  { file: '.aider.system-prompt.md', tool: 'Aider' },
+];
+
+const BLOCK_START = '<!-- memoir:start -->';
+const BLOCK_END = '<!-- memoir:end -->';
+
+const MEMOIR_BLOCK = `${BLOCK_START}
+# Memoir — Persistent Memory
+<!-- Cross-session memory for AI tools — https://memoir.sh -->
+<!-- Install: npm i -g memoir-cli -->
+Use memoir_recall to search past context before answering project questions.
+Use memoir_remember to save important decisions, architecture choices, or context worth keeping.
+${BLOCK_END}`;
+
+/**
+ * Detect which instruction files exist in the current project.
+ * Returns array of { file, tool, fullPath, exists }
+ */
+function detectInstructionFiles(projectDir) {
+  return INSTRUCTION_FILES.map(({ file, tool }) => {
+    const fullPath = path.join(projectDir, file);
+    return { file, tool, fullPath, exists: fs.existsSync(fullPath) };
+  });
+}
+
+/**
+ * Check if a file already has the memoir block
+ */
+function hasMemoir(content) {
+  return content.includes(BLOCK_START);
+}
+
+/**
+ * Inject memoir block into a file (append, or create)
+ */
+async function injectBlock(filePath) {
+  await fs.ensureDir(path.dirname(filePath));
+
+  if (await fs.pathExists(filePath)) {
+    const content = await fs.readFile(filePath, 'utf-8');
+    if (hasMemoir(content)) {
+      return 'already';
+    }
+    // Append with spacing
+    const separator = content.endsWith('\n') ? '\n' : '\n\n';
+    await fs.writeFile(filePath, content + separator + MEMOIR_BLOCK + '\n');
+    return 'appended';
+  } else {
+    await fs.writeFile(filePath, MEMOIR_BLOCK + '\n');
+    return 'created';
+  }
+}
+
+/**
+ * Remove memoir block from a file
+ */
+async function removeBlock(filePath) {
+  if (!await fs.pathExists(filePath)) return 'not_found';
+
+  const content = await fs.readFile(filePath, 'utf-8');
+  if (!hasMemoir(content)) return 'not_present';
+
+  const startIdx = content.indexOf(BLOCK_START);
+  const endIdx = content.indexOf(BLOCK_END);
+  if (startIdx === -1 || endIdx === -1) return 'not_present';
+
+  const before = content.slice(0, startIdx).replace(/\n+$/, '');
+  const after = content.slice(endIdx + BLOCK_END.length).replace(/^\n+/, '');
+  const cleaned = (before + (before && after ? '\n\n' : '') + after).trim();
+
+  if (!cleaned) {
+    // File would be empty — delete it
+    await fs.remove(filePath);
+    return 'deleted';
+  }
+
+  await fs.writeFile(filePath, cleaned + '\n');
+  return 'removed';
+}
+
+/**
+ * Track which projects have been activated
+ */
+function getActivatedPath() {
+  return path.join(os.homedir(), '.config', 'memoir', 'activated-projects.json');
+}
+
+async function loadActivated() {
+  const p = getActivatedPath();
+  if (await fs.pathExists(p)) {
+    const data = await fs.readJson(p);
+    return Array.isArray(data) ? data : [];
+  }
+  return [];
+}
+
+async function markActivated(projectDir) {
+  const activated = await loadActivated();
+  if (!activated.includes(projectDir)) {
+    activated.push(projectDir);
+    await fs.ensureDir(path.dirname(getActivatedPath()));
+    await fs.writeJson(getActivatedPath(), activated);
+  }
+}
+
+async function markDeactivated(projectDir) {
+  let activated = await loadActivated();
+  activated = activated.filter(p => p !== projectDir);
+  await fs.ensureDir(path.dirname(getActivatedPath()));
+  await fs.writeJson(getActivatedPath(), activated);
+}
+
+export async function isActivated(projectDir) {
+  const activated = await loadActivated();
+  return activated.includes(projectDir);
+}
+
+/**
+ * memoir activate — inject memoir instructions into project AI config files
+ */
+export async function activateCommand(options = {}) {
+  const projectDir = process.cwd();
+  const detected = detectInstructionFiles(projectDir);
+  const existing = detected.filter(d => d.exists);
+
+  if (existing.length === 0) {
+    // No instruction files exist — create CLAUDE.md by default
+    const result = await injectBlock(path.join(projectDir, 'CLAUDE.md'));
+    console.log(chalk.green('\n  ✔ Created CLAUDE.md with memoir instructions'));
+    console.log(chalk.gray('    Your AI will use memoir_recall and memoir_remember automatically.\n'));
+    await markActivated(projectDir);
+    return;
+  }
+
+  // Inject into all existing instruction files
+  let injected = 0;
+  for (const { file, tool, fullPath } of existing) {
+    const result = await injectBlock(fullPath);
+    if (result === 'appended') {
+      console.log(chalk.green(`  ✔ Added memoir to ${file}`) + chalk.gray(` (${tool})`));
+      injected++;
+    } else if (result === 'created') {
+      console.log(chalk.green(`  ✔ Created ${file} with memoir instructions`) + chalk.gray(` (${tool})`));
+      injected++;
+    } else if (result === 'already') {
+      console.log(chalk.gray(`  · ${file} already has memoir`) + chalk.gray(` (${tool})`));
+    }
+  }
+
+  if (injected > 0) {
+    console.log(chalk.gray('\n    Your AI tools will now use memoir automatically.\n'));
+  } else {
+    console.log(chalk.gray('\n    memoir is already active in this project.\n'));
+  }
+
+  await markActivated(projectDir);
+}
+
+/**
+ * memoir deactivate — remove memoir instructions from project AI config files
+ */
+export async function deactivateCommand(options = {}) {
+  const projectDir = process.cwd();
+  const detected = detectInstructionFiles(projectDir);
+
+  let removed = 0;
+  for (const { file, tool, fullPath } of detected) {
+    const result = await removeBlock(fullPath);
+    if (result === 'removed') {
+      console.log(chalk.yellow(`  ✔ Removed memoir from ${file}`) + chalk.gray(` (${tool})`));
+      removed++;
+    } else if (result === 'deleted') {
+      console.log(chalk.yellow(`  ✔ Deleted ${file}`) + chalk.gray(' (was only memoir block)'));
+      removed++;
+    }
+  }
+
+  if (removed === 0) {
+    console.log(chalk.gray('  · memoir is not active in this project.\n'));
+  } else {
+    console.log(chalk.gray('\n    memoir instructions removed.\n'));
+  }
+
+  await markDeactivated(projectDir);
+}
+
+/**
+ * Prompt to activate — called from push on first push per project
+ */
+export async function promptActivate() {
+  const projectDir = process.cwd();
+
+  // Don't prompt if already activated or if not in a project directory
+  if (await isActivated(projectDir)) return;
+
+  // Check if we're in a project (has git, or has instruction files, or has package.json etc.)
+  const projectSignals = ['.git', 'package.json', 'Cargo.toml', 'go.mod', 'pyproject.toml', 'Makefile'];
+  const isProject = projectSignals.some(f => fs.existsSync(path.join(projectDir, f)));
+  if (!isProject) {
+    await markActivated(projectDir); // Don't ask again for non-projects
+    return;
+  }
+
+  console.log('');
+  const { activate } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'activate',
+    message: 'Add memoir instructions to this project so your AI uses it automatically?',
+    default: true,
+  }]);
+
+  if (activate) {
+    await activateCommand();
+  } else {
+    await markActivated(projectDir); // Don't ask again
+    console.log(chalk.gray('  · Skipped. Run ') + chalk.cyan('memoir activate') + chalk.gray(' anytime to enable.\n'));
+  }
+}

package/src/commands/push.js

@@ -5,7 +5,7 @@ import os from 'os';
 import ora from 'ora';
 import boxen from 'boxen';
 import gradient from 'gradient-string';
-import { getConfig } from '../config.js';
+import { getConfig, autoSetup } from '../config.js';
 import { extractMemories, adapters } from '../adapters/index.js';
 import { syncToLocal, syncToGit } from '../providers/index.js';
 import inquirer from 'inquirer';
@@ -14,17 +14,25 @@ import { scanForSecrets, printSecurityReport } from '../security/scanner.js';
 import { encryptDirectory, createVerifyToken } from '../security/encryption.js';
 import { getRawConfig, saveConfig, migrateConfigToV2 } from '../config.js';
 import { scanWorkspace } from '../workspace/tracker.js';
+import { promptActivate } from './activate.js';
 
 export async function pushCommand(options = {}) {
-  const config = await getConfig(options.profile);
+  let config = await getConfig(options.profile);
 
   if (!config) {
-    console.log('\n' + boxen(
-      chalk.red('✖ Not configured yet\n\n') +
-      chalk.white('Run ') + chalk.cyan.bold('memoir init') + chalk.white(' to get started.'),
-      { padding: 1, borderStyle: 'round', borderColor: 'red' }
-    ) + '\n');
-    return;
+    // Zero-config: auto-detect GitHub user, create repo, save config
+    const setupSpinner = ora({ text: chalk.gray('Setting up memoir automatically...'), spinner: 'dots' }).start();
+    config = await autoSetup();
+    if (config) {
+      setupSpinner.succeed(chalk.green('Auto-configured') + chalk.gray(` → ${config.gitRepo}`));
+    } else {
+      setupSpinner.fail(chalk.red('Could not detect GitHub username'));
+      console.log('\n' + boxen(
+        chalk.white('Run ') + chalk.cyan.bold('memoir init') + chalk.white(' to set up manually.'),
+        { padding: 1, borderStyle: 'round', borderColor: 'yellow' }
+      ) + '\n');
+      return;
+    }
   }
 
   console.log();
@@ -262,6 +270,13 @@ export async function pushCommand(options = {}) {
       chalk.gray('Restore on another machine with: ') + chalk.cyan('memoir restore'),
       { padding: 1, borderStyle: 'round', borderColor: 'green', dimBorder: true }
     ) + '\n');
+
+    // Prompt to activate memoir in this project (first push only)
+    try {
+      await promptActivate();
+    } catch {
+      // Activation prompt is best-effort
+    }
   } catch (error) {
     spinner.fail(chalk.red('Sync failed: ') + error.message);
   } finally {

package/src/commands/restore.js

@@ -6,7 +6,7 @@ import ora from 'ora';
 import boxen from 'boxen';
 import gradient from 'gradient-string';
 import inquirer from 'inquirer';
-import { getConfig } from '../config.js';
+import { getConfig, autoSetup } from '../config.js';
 import { fetchFromLocal, fetchFromGit } from '../providers/restore.js';
 import { decryptDirectory, verifyPassphrase } from '../security/encryption.js';
 import { detectLocalHomeKey } from '../adapters/restore.js';
@@ -23,15 +23,21 @@ export async function restoreCommand(options = {}) {
     return restoreFromShare(options);
   }
 
-  const config = await getConfig(options.profile);
+  let config = await getConfig(options.profile);
 
   if (!config) {
-    console.log('\n' + boxen(
-      chalk.red('✖ Not configured yet\n\n') +
-      chalk.white('Run ') + chalk.cyan.bold('memoir init') + chalk.white(' to get started.'),
-      { padding: 1, borderStyle: 'round', borderColor: 'red' }
-    ) + '\n');
-    return;
+    const setupSpinner = ora({ text: chalk.gray('Setting up memoir automatically...'), spinner: 'dots' }).start();
+    config = await autoSetup();
+    if (config) {
+      setupSpinner.succeed(chalk.green('Auto-configured') + chalk.gray(` → ${config.gitRepo}`));
+    } else {
+      setupSpinner.fail(chalk.red('Could not detect GitHub username'));
+      console.log('\n' + boxen(
+        chalk.white('Run ') + chalk.cyan.bold('memoir init') + chalk.white(' to set up manually.'),
+        { padding: 1, borderStyle: 'round', borderColor: 'yellow' }
+      ) + '\n');
+      return;
+    }
   }
 
   console.log();

package/src/commands/upgrade.js

@@ -63,7 +63,7 @@ export async function upgradeCommand() {
   const sep = chalk.gray('─'.repeat(col1 + col2 + 18));
 
   const rows = [
-    [chalk.gray('3 cloud backups'),   chalk.white('50 cloud backups'),   chalk.white('Unlimited backups')],
+    [chalk.gray('100 cloud backups'),  chalk.white('Unlimited backups'),  chalk.white('Unlimited backups')],
     [chalk.gray('Local only'),        chalk.white('Unlimited machines'), chalk.white('Shared team context')],
     [chalk.gray('Manual snapshots'),  chalk.white('Auto snapshots'),     chalk.white('Team dashboard')],
     [chalk.gray('Community support'), chalk.white('Priority support'),   chalk.white('Audit log')],

package/src/config.js

@@ -1,6 +1,7 @@
 import fs from 'fs-extra';
 import path from 'path';
 import os from 'os';
+import { execFileSync } from 'child_process';
 
 const CONFIG_DIR = process.platform === 'win32'
   ? path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), 'memoir')
@@ -114,6 +115,50 @@ export async function deleteProfile(name) {
   await saveConfig(raw);
 }
 
+// Zero-config auto-setup: detect GitHub user, create repo, save config, return it
+export async function autoSetup() {
+  // Try gh CLI first, then git config
+  let username = '';
+  try {
+    username = execFileSync('gh', ['api', 'user', '--jq', '.login'], { encoding: 'utf8', timeout: 5000 }).trim();
+  } catch {
+    try {
+      username = execFileSync('git', ['config', '--global', 'user.name'], { encoding: 'utf8' }).trim();
+    } catch {}
+  }
+
+  if (!username) return null; // Can't auto-setup without a username
+
+  const repo = 'ai-memory';
+  const gitRepo = `https://github.com/${username}/${repo}.git`;
+
+  // Try to create the repo if it doesn't exist (best-effort)
+  try {
+    execFileSync('gh', ['repo', 'view', `${username}/${repo}`], { stdio: 'ignore', timeout: 5000 });
+  } catch {
+    try {
+      execFileSync('gh', ['repo', 'create', `${username}/${repo}`, '--private', '--description', 'AI memory backup (memoir-cli)'], { stdio: 'ignore', timeout: 10000 });
+    } catch {
+      // If gh isn't available, user will need to create repo manually — that's fine, syncToGit will handle it
+    }
+  }
+
+  const config = {
+    version: 2,
+    activeProfile: 'default',
+    profiles: {
+      default: {
+        provider: 'git',
+        gitRepo,
+        encrypt: false // Skip encryption for zero-config — user can enable later with `memoir encrypt`
+      }
+    }
+  };
+
+  await saveConfig(config);
+  return config.profiles.default;
+}
+
 export async function getGeminiApiKey() {
   const raw = await getRawConfig();
   return raw?.geminiApiKey || process.env.GEMINI_API_KEY || null;