memoir-cli 3.3.0 → 3.4.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

@@ -14,12 +14,13 @@ import { migrateCommand } from '../src/commands/migrate.js';
 import { snapshotCommand } from '../src/commands/snapshot.js';
 import { resumeCommand } from '../src/commands/resume.js';
 import { profileListCommand, profileCreateCommand, profileSwitchCommand, profileDeleteCommand } from '../src/commands/profile.js';
-import { loginCommand, logoutCommand, forgotPasswordCommand } from '../src/commands/login.js';
+import { loginCommand, logoutCommand, forgotPasswordCommand, deleteAccountCommand } from '../src/commands/login.js';
 import { cloudPushCommand, cloudRestoreCommand } from '../src/commands/cloud.js';
 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);
@@ -66,6 +67,7 @@ if (process.argv.length <= 2) {
     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 activate  ') + chalk.gray('— enable auto-recall in this project') + '\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' +
@@ -97,9 +99,16 @@ program
 program
   .command('init')
   .description('Set up memoir with your storage provider')
-  .action(async () => {
+  .option('--direction <direction>', 'Upload or download (upload, download)')
+  .option('--provider <provider>', 'Storage provider (git, local)')
+  .option('--local-path <path>', 'Local folder path (for local provider)')
+  .option('--username <name>', 'GitHub username (for git provider)')
+  .option('--repo <name>', 'GitHub repo name (for git provider)')
+  .option('--encrypt', 'Enable E2E encryption')
+  .option('--no-encrypt', 'Disable E2E encryption')
+  .action(async (options) => {
     try {
-      await initCommand();
+      await initCommand(options);
     } catch (err) {
       console.error(chalk.red('\n✖ Error during initialization:'), err.message);
       process.exit(1);
@@ -291,10 +300,36 @@ 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')
-  .action(async () => {
+  .option('--on', 'Enable encryption without prompting')
+  .option('--off', 'Disable encryption without prompting')
+  .action(async (options) => {
     try {
       const { getConfig, getRawConfig, saveConfig, migrateConfigToV2 } = await import('../src/config.js');
       const config = await getConfig();
@@ -304,24 +339,34 @@ program
       }
       const current = config.encrypt || false;
       console.log(chalk.white(`\n  Encryption is currently: ${current ? chalk.green('ON') : chalk.red('OFF')}`));
-      const inquirer = (await import('inquirer')).default;
-      const { toggle } = await inquirer.prompt([{
-        type: 'confirm',
-        name: 'toggle',
-        message: current ? 'Disable encryption?' : 'Enable encryption?',
-        default: !current
-      }]);
-      if (toggle !== current) {
+
+      let newValue;
+      if (options.on) {
+        newValue = true;
+      } else if (options.off) {
+        newValue = false;
+      } else {
+        const inquirer = (await import('inquirer')).default;
+        const { toggle } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'toggle',
+          message: current ? 'Disable encryption?' : 'Enable encryption?',
+          default: !current
+        }]);
+        newValue = toggle ? !current : current;
+      }
+
+      if (newValue !== current) {
         let raw = await getRawConfig();
         if (!raw.version || raw.version < 2) raw = migrateConfigToV2(raw);
         const profileName = raw.activeProfile || 'default';
         if (raw.profiles?.[profileName]) {
-          raw.profiles[profileName].encrypt = !current;
+          raw.profiles[profileName].encrypt = newValue;
         } else {
-          raw.encrypt = !current;
+          raw.encrypt = newValue;
         }
         await saveConfig(raw);
-        console.log(chalk.green(`\n  ✔ Encryption ${!current ? 'enabled' : 'disabled'}. Next push will ${!current ? 'encrypt' : 'skip encryption'}.\n`));
+        console.log(chalk.green(`\n  ✔ Encryption ${newValue ? 'enabled' : 'disabled'}. Next push will ${newValue ? 'encrypt' : 'skip encryption'}.\n`));
       }
     } catch (err) {
       console.error(chalk.red('\n✖ Error:'), err.message);
@@ -386,6 +431,22 @@ program
     }
   });
 
+// Account management
+const account = program.command('account').description('Manage your memoir account');
+
+account
+  .command('delete')
+  .description('Permanently delete your account and all cloud data')
+  .option('--confirm', 'Skip interactive prompt (Node 25 workaround)')
+  .action(async (options) => {
+    try {
+      await deleteAccountCommand(options);
+    } catch (err) {
+      console.error(chalk.red('\n✖ Error:'), err.message);
+      process.exit(1);
+    }
+  });
+
 // Cloud sync
 const cloud = program.command('cloud').description('Cloud backup and restore (Pro)');
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "memoir-cli",
-  "version": "3.3.0",
+  "version": "3.4.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/auth.js

@@ -1,7 +1,7 @@
 import fs from 'fs-extra';
 import path from 'path';
 import os from 'os';
-import { SUPABASE_URL, SUPABASE_ANON_KEY } from './constants.js';
+import { SUPABASE_URL, SUPABASE_ANON_KEY, STORAGE_BUCKET } from './constants.js';
 
 const isWin = process.platform === 'win32';
 const configDir = isWin
@@ -131,4 +131,61 @@ export async function resetPassword(email) {
   }
 }
 
+export async function deleteAccount(session) {
+  // 1. Delete all backups (storage files + metadata rows)
+  const backupsRes = await fetch(
+    `${SUPABASE_URL}/rest/v1/backups?select=*&user_id=eq.${session.user.id}`,
+    {
+      headers: {
+        'Authorization': `Bearer ${session.access_token}`,
+        'apikey': SUPABASE_ANON_KEY,
+      },
+    }
+  );
+
+  if (backupsRes.ok) {
+    const backups = await backupsRes.json();
+    for (const backup of backups) {
+      // Delete storage object
+      await fetch(`${SUPABASE_URL}/storage/v1/object/${STORAGE_BUCKET}/${backup.storage_path}`, {
+        method: 'DELETE',
+        headers: {
+          'Authorization': `Bearer ${session.access_token}`,
+          'apikey': SUPABASE_ANON_KEY,
+        },
+      });
+
+      // Delete metadata row
+      await fetch(`${SUPABASE_URL}/rest/v1/backups?id=eq.${backup.id}`, {
+        method: 'DELETE',
+        headers: {
+          'Authorization': `Bearer ${session.access_token}`,
+          'apikey': SUPABASE_ANON_KEY,
+        },
+      });
+    }
+  }
+
+  // 2. Delete shared links
+  await fetch(`${SUPABASE_URL}/rest/v1/shared_links?user_id=eq.${session.user.id}`, {
+    method: 'DELETE',
+    headers: {
+      'Authorization': `Bearer ${session.access_token}`,
+      'apikey': SUPABASE_ANON_KEY,
+    },
+  });
+
+  // 3. Delete subscription
+  await fetch(`${SUPABASE_URL}/rest/v1/subscriptions?user_id=eq.${session.user.id}`, {
+    method: 'DELETE',
+    headers: {
+      'Authorization': `Bearer ${session.access_token}`,
+      'apikey': SUPABASE_ANON_KEY,
+    },
+  });
+
+  // 4. Sign out locally
+  await logout();
+}
+
 export { AUTH_FILE, supaFetch };

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/init.js

@@ -23,7 +23,7 @@ function getGitHubUsername() {
   }
 }
 
-export async function initCommand() {
+export async function initCommand(options = {}) {
   console.log('');
   console.log(boxen(
     gradient.pastel('memoir') + '\n' +
@@ -34,57 +34,80 @@ export async function initCommand() {
 
   const detectedUser = getGitHubUsername();
 
-  const { direction, provider } = await inquirer.prompt([
-    {
-      type: 'list',
-      name: 'direction',
-      message: 'Upload or download?',
-      choices: [
-        { name: 'Upload — back up this machine', value: 'upload' },
-        { name: 'Download — restore from backup', value: 'download' }
-      ]
-    },
-    {
-      type: 'list',
-      name: 'provider',
-      message: (answers) => answers.direction === 'upload' ? 'Back up to?' : 'Restore from?',
-      choices: [
-        { name: 'GitHub', value: 'git' },
-        { name: 'Local folder', value: 'local' }
-      ]
-    }
-  ]);
-
-  let config = { provider };
+  let direction, provider;
 
-  if (provider === 'local') {
-    const msg = direction === 'upload' ? 'Save to:' : 'Backup folder:';
-    const { localPath } = await inquirer.prompt([{
-      type: 'input',
-      name: 'localPath',
-      message: msg,
-      validate: (input) => input.trim() ? true : 'Required'
-    }]);
-    config.localPath = localPath;
+  if (options.provider) {
+    // Non-interactive: use flags directly
+    provider = options.provider;
+    direction = options.direction || 'upload';
   } else {
+    // Interactive: prompt the user
     const answers = await inquirer.prompt([
       {
-        type: 'input',
-        name: 'username',
-        message: 'GitHub username:',
-        default: detectedUser || undefined,
-        validate: (input) => input.trim() ? true : 'Required'
+        type: 'list',
+        name: 'direction',
+        message: 'Upload or download?',
+        choices: [
+          { name: 'Upload — back up this machine', value: 'upload' },
+          { name: 'Download — restore from backup', value: 'download' }
+        ]
       },
       {
-        type: 'input',
-        name: 'repo',
-        message: 'Repo name:',
-        default: 'ai-memory',
-        validate: (input) => input.trim() ? true : 'Required'
+        type: 'list',
+        name: 'provider',
+        message: (a) => a.direction === 'upload' ? 'Back up to?' : 'Restore from?',
+        choices: [
+          { name: 'GitHub', value: 'git' },
+          { name: 'Local folder', value: 'local' }
+        ]
       }
     ]);
-    const username = answers.username.trim();
-    const repo = answers.repo.trim();
+    direction = answers.direction;
+    provider = answers.provider;
+  }
+
+  let config = { provider };
+
+  if (provider === 'local') {
+    let localPath;
+    if (options.localPath) {
+      localPath = options.localPath;
+    } else {
+      const msg = direction === 'upload' ? 'Save to:' : 'Backup folder:';
+      const answers = await inquirer.prompt([{
+        type: 'input',
+        name: 'localPath',
+        message: msg,
+        validate: (input) => input.trim() ? true : 'Required'
+      }]);
+      localPath = answers.localPath;
+    }
+    config.localPath = localPath;
+  } else {
+    let username, repo;
+    if (options.username) {
+      username = options.username.trim();
+      repo = (options.repo || 'ai-memory').trim();
+    } else {
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'username',
+          message: 'GitHub username:',
+          default: detectedUser || undefined,
+          validate: (input) => input.trim() ? true : 'Required'
+        },
+        {
+          type: 'input',
+          name: 'repo',
+          message: 'Repo name:',
+          default: 'ai-memory',
+          validate: (input) => input.trim() ? true : 'Required'
+        }
+      ]);
+      username = answers.username.trim();
+      repo = answers.repo.trim();
+    }
 
     config.gitRepo = `https://github.com/${username}/${repo}.git`;
     console.log(chalk.gray(`  → ${config.gitRepo}`));
@@ -109,12 +132,18 @@ export async function initCommand() {
   }
 
   // Ask about encryption
-  const { encrypt } = await inquirer.prompt([{
-    type: 'confirm',
-    name: 'encrypt',
-    message: 'Enable E2E encryption? (protects your data even if backup is compromised)',
-    default: true
-  }]);
+  let encrypt;
+  if (options.encrypt !== undefined) {
+    encrypt = options.encrypt;
+  } else {
+    const answers = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'encrypt',
+      message: 'Enable E2E encryption? (protects your data even if backup is compromised)',
+      default: true
+    }]);
+    encrypt = answers.encrypt;
+  }
   config.encrypt = encrypt;
 
   if (encrypt) {

package/src/commands/login.js

@@ -2,7 +2,7 @@ import chalk from 'chalk';
 import boxen from 'boxen';
 import gradient from 'gradient-string';
 import inquirer from 'inquirer';
-import { signIn, signUp, saveSession, getSession, logout, getSubscription, resetPassword } from '../cloud/auth.js';
+import { signIn, signUp, saveSession, getSession, logout, getSubscription, resetPassword, deleteAccount } from '../cloud/auth.js';
 
 export async function loginCommand(options = {}) {
   // Check if already logged in
@@ -131,3 +131,43 @@ export async function logoutCommand() {
     { padding: 1, borderStyle: 'round', borderColor: 'green', dimBorder: true }
   ) + '\n');
 }
+
+export async function deleteAccountCommand(options = {}) {
+  const session = await getSession();
+  if (!session) {
+    console.log('\n' + boxen(
+      chalk.red('✖ Not logged in. Run ') + chalk.cyan('memoir login') + chalk.red(' first.'),
+      { padding: 1, borderStyle: 'round', borderColor: 'red' }
+    ) + '\n');
+    return;
+  }
+
+  if (!options.confirm) {
+    const answer = await inquirer.prompt([{
+      type: 'input',
+      name: 'confirmation',
+      message: 'Type DELETE to confirm account deletion:',
+    }]);
+
+    if (answer.confirmation !== 'DELETE') {
+      console.log('\n' + chalk.gray('  Account deletion cancelled.') + '\n');
+      return;
+    }
+  }
+
+  try {
+    await deleteAccount(session);
+
+    console.log('\n' + boxen(
+      gradient.pastel('  memoir cloud  ') + '\n\n' +
+      chalk.green('✔ Account deleted.') + '\n' +
+      chalk.gray('All backups, shared links, and data have been removed.'),
+      { padding: 1, borderStyle: 'round', borderColor: 'green', dimBorder: true }
+    ) + '\n');
+  } catch (error) {
+    console.log('\n' + boxen(
+      chalk.red('✖ ' + error.message),
+      { padding: 1, borderStyle: 'round', borderColor: 'red' }
+    ) + '\n');
+  }
+}

package/src/commands/push.js

@@ -14,6 +14,7 @@ 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);
@@ -262,6 +263,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/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')],