memoir-cli 3.3.1 → 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

@@ -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);
@@ -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' +
@@ -298,6 +300,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.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/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

@@ -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')],