memoir-cli 3.0.3 → 3.1.1

package/README.md

@@ -2,43 +2,59 @@
 
 # memoir
 
-**Sync your AI memory across every device and every tool.**
+**Your AI remembers everything. On every machine.**
 
 [![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)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D18-brightgreen?style=flat-square)](https://nodejs.org)
 
-Your AI tools forget you on every new machine. memoir fixes that.
+Close your laptop. Open another one. **Your AI picks up exactly where you left off.**
 
 [Website](https://memoir.sh) • [npm](https://npmjs.org/package/memoir-cli) • [Blog](https://memoir.sh/blog)
 
 <br />
 
-![memoir demo](demo.gif)
-
 </div>
 
-## Why memoir
+## The Problem
 
-You spend weeks teaching your AI tools how you code. Your CLAUDE.md is dialed in. Your .cursorrules are perfect. Your ChatGPT custom instructions know your stack.
+You spend weeks teaching Claude how you code. Your projects are dialed in. Your AI knows your stack, your decisions, your preferences.
 
-Then you get a new laptop. **Everything is gone.**
+Then you switch machines. **Everything is gone.** Your AI has amnesia. Your projects aren't there. You start from zero.
 
-memoir backs up, restores, and **translates** your AI memory across any machine and any tool. One command to save. One command to restore.
+## The Fix
 
 ```bash
+# On your main machine
+memoir push
+
+# On any other machine
 npm install -g memoir-cli
+memoir restore -y
+
+# Done. Everything's back:
+# ✔ AI memory restored (Claude, Gemini, Cursor, 11 tools)
+# ✔ 44 projects cloned & unpacked
+# ✔ Uncommitted changes applied
+# ✔ Session context injected — AI picks up mid-conversation
 ```
 
-## Supported Tools (11)
+One command to save. One command to restore. That's it.
+
+## What Gets Synced
+
+memoir syncs three layers that no other tool connects:
+
+### Layer 1: AI Memory
+Your AI tool configs, preferences, and project knowledge across 11 tools.
 
 | Tool | What gets synced |
 |------|-----------------|
-| **ChatGPT** | CHATGPT.md custom instructions |
 | **Claude Code** | ~/.claude/ settings, memory, CLAUDE.md files |
 | **Gemini CLI** | ~/.gemini/ config, GEMINI.md files |
-| **OpenAI Codex** | ~/.codex/ config, AGENTS.md, codex.md |
+| **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 |
@@ -47,7 +63,37 @@ npm install -g memoir-cli
 | **Continue.dev** | Config, .continuerules |
 | **Aider** | .aider.conf.yml, system prompt |
 
-Plus **per-project configs** — memoir scans your filesystem for CLAUDE.md, GEMINI.md, CHATGPT.md, .cursorrules, and AGENTS.md across all your projects.
+### Layer 2: Session State
+What you were **doing** — not just what your AI knows, but the active context.
+
+- 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)
+
+### Layer 3: Workspace (NEW in v3.1)
+Your actual projects — code, files, everything.
+
+- **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
+
+```
+memoir push on Mac:
+  ✔ AI memory backed up
+  ✔ Session context captured
+  ✔ Workspace: 44 projects (17 git, 23 bundled)
+  🔒 E2E encrypted
+
+memoir restore on Windows:
+  ✔ AI memory restored
+  ✔ stock-market-book → C:\Users\You\stock-market-book (cloned)
+  ✔ socialslink → C:\Users\You\socialslink (cloned)
+  ✔ btc-trader → C:\Users\You\btc-trader (unpacked)
+  ✔ 41 more projects restored
+  📋 Session context injected — Claude picks up where you left off
+```
 
 ## Quick Start
 
@@ -55,41 +101,52 @@ Plus **per-project configs** — memoir scans your filesystem for CLAUDE.md, GEM
 # Install
 npm install -g memoir-cli
 
-# First-time setup (GitHub repo or local)
+# First-time setup
 memoir init
 
-# Back up all your AI configs
+# Back up everything
 memoir push
 
-# Restore on a new machine
+# Restore on any machine
 memoir restore
 ```
 
-That's it. Every AI tool gets its memory back.
-
 ## Key Features
 
-### Translate between AI tools
+### Workspace sync
 ```bash
-memoir migrate --from chatgpt --to claude
-# AI-powered — rewrites conventions, not copy-paste
+memoir push     # scans all projects, saves git URLs + bundles non-git projects
+memoir restore  # auto-clones repos, unpacks bundles, applies uncommitted patches
 ```
 
-Works between any combination: ChatGPT, Claude, Gemini, Cursor, Copilot, Codex, Windsurf, Aider, and more. Translate to one tool or all at once:
+No manual git commands. memoir detects your projects, tracks their remotes, and restores them anywhere.
 
+### Translate between AI tools
 ```bash
+memoir migrate --from chatgpt --to claude
+# AI-powered — rewrites conventions, not copy-paste
+
 memoir migrate --from chatgpt --to all
+# Translate to every tool at once
 ```
 
 ### Session handoff
 ```bash
-# Laptop dying? Capture your session
+# Capture your session (automatic on push, or manual)
 memoir snapshot
 
 # Pick up on another machine
 memoir resume --inject --to claude
 ```
 
+### 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. Even if your storage is compromised, your data is safe. Secret scanning auto-redacts API keys, tokens, and passwords.
+
 ### Profiles (personal / work)
 ```bash
 memoir profile create work
@@ -107,23 +164,24 @@ memoir cloud restore   # restore from any version
 memoir history         # view all backup versions
 ```
 
-Free tier: 3 cloud backups. Pro ($5/mo): unlimited + version history.
-
-### Security
+### Cross-platform (Mac / Windows / Linux)
 ```bash
-memoir doctor
-# Scans for secrets, API keys, .env files before pushing
+# Push from Mac
+memoir push
+
+# Restore on Windows — paths remap automatically
+memoir restore
 ```
 
-memoir **never** syncs credentials, API keys, .env files, or auth tokens.
+Claude's memory paths are automatically remapped between platforms. Projects are cloned to the right locations. It just works.
 
 ## All Commands
 
 | Command | What it does |
 |---------|-------------|
 | `memoir init` | Setup wizard — GitHub or local storage |
-| `memoir push` | Back up all AI configs |
-| `memoir restore` | Restore on a new machine |
+| `memoir push` | Back up AI memory + workspace + session |
+| `memoir restore` | Restore everything on a new machine |
 | `memoir status` | Show detected AI tools |
 | `memoir doctor` | Diagnose issues, scan for secrets |
 | `memoir view` | Preview what's in your backup |
@@ -131,6 +189,7 @@ memoir **never** syncs credentials, API keys, .env files, or auth tokens.
 | `memoir migrate` | Translate memory between tools via AI |
 | `memoir snapshot` | Capture current coding session |
 | `memoir resume` | Pick up where you left off |
+| `memoir encrypt` | Toggle E2E encryption |
 | `memoir profile` | Manage profiles (personal/work) |
 | `memoir cloud push` | Back up to memoir cloud |
 | `memoir cloud restore` | Restore from memoir cloud |
@@ -140,57 +199,65 @@ memoir **never** syncs credentials, API keys, .env files, or auth tokens.
 
 ## How memoir compares
 
-| Feature | memoir | skillshare | ai-rulez | memories.sh |
-|---------|--------|-----------|----------|-------------|
-| Cross-device sync | **Yes** | Yes (git) | No | Yes |
+| Feature | memoir | dotfiles managers | ai-rulez | memories.sh |
+|---------|--------|-------------------|----------|-------------|
+| AI memory sync | **11 tools** | No | 18 tools | 3 tools |
+| Workspace sync | **Yes** | No | No | No |
+| Session handoff | **Yes** | No | No | No |
 | AI-powered translation | **Yes** | No | No | No |
-| Tools supported | **11** | 40+ | 18 | 3 |
+| E2E encryption | **Yes** | No | No | No |
+| Secret scanning | **Yes** | Some | No | No |
+| Cross-platform remap | **Yes** | Some | No | No |
+| Uncommitted work patches | **Yes** | No | No | No |
 | Cloud backup | **Yes** | No | No | Yes ($15/mo) |
-| Version history | **Yes** | No | No | No |
-| Session handoff | **Yes** | No | No | No |
 | Profiles | **Yes** | No | No | No |
-| Secret scanning | **Yes** | Yes | No | No |
 | Free & open source | **Yes** | Yes | Yes | No |
 
-memoir is free and open source. Cloud sync starts at $0 (3 backups free).
-
 ## Common Workflows
 
-### New laptop setup
+### New machine setup
 ```bash
 # Old machine
 memoir push
 
-# New machine
-npm install -g memoir-cli
-memoir init      # connect to same repo
-memoir restore   # all configs restored in seconds
+# New machine — one command, everything's back
+npm install -g memoir-cli && memoir init && memoir restore -y
 ```
 
-### Switching from ChatGPT to Claude
+### Daily sync between machines
 ```bash
-memoir migrate --from chatgpt --to claude
-# Your custom instructions become a proper CLAUDE.md
+memoir push      # end of day on laptop
+memoir restore   # next morning on desktop — AI knows what you were doing
 ```
 
-### Daily sync between machines
+### Switching AI tools
 ```bash
-memoir push      # end of day on laptop
-memoir restore   # next morning on desktop
+memoir migrate --from chatgpt --to claude
+# Your custom instructions become a proper CLAUDE.md
 ```
 
-### Cross-platform (Mac ↔ Windows ↔ Linux)
+### Team onboarding
 ```bash
-# Push from Mac
-memoir push
+# Senior dev pushes team config
+memoir push --profile team
 
-# Restore on Windows — paths remap automatically
-memoir restore
+# 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
+
 ## Requirements
 
 - Node.js >= 18
+- Git (for workspace sync)
 - Works on macOS, Windows, Linux
 
 ## Contributing

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memoir-cli",
-  "version": "3.0.3",
+  "version": "3.1.1",
   "description": "Sync AI memory across devices. Back up and restore Claude, Gemini, Codex, Cursor, Copilot, Windsurf configs. Snapshot coding sessions and resume on another machine. Migrate instructions between AI assistants.",
   "main": "src/index.js",
   "type": "module",

package/src/adapters/index.js

@@ -37,15 +37,22 @@ export const adapters = [
       if (src === claudeDir) return true;
       // Only allow these top-level dirs
       const topDir = rel.split(path.sep)[0];
-      const allowedDirs = ['projects', 'settings'];
       const allowedFiles = ['settings.json', 'settings.local.json'];
       // Allow specific top-level config files
       if (!rel.includes(path.sep) && allowedFiles.includes(basename)) return true;
       // Allow projects dir (contains memory .md files)
       if (topDir === 'projects') {
-        // Allow directory traversal
-        try { if (nodeFs.statSync(src).isDirectory()) return true; } catch {}
-        // Only sync memory markdown files
+        // Allow directory traversal but skip dirs that only contain session data
+        try {
+          if (nodeFs.statSync(src).isDirectory()) {
+            // Skip subagents and UUID-named session dirs (contain large .jsonl files, no .md)
+            if (basename === 'subagents') return false;
+            // UUID pattern: 8-4-4-4-12 hex chars
+            if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(basename)) return false;
+            return true;
+          }
+        } catch {}
+        // Only sync memory markdown files — skip .jsonl session files
         return basename.endsWith('.md');
       }
       // Allow settings dir

package/src/commands/push.js

@@ -9,10 +9,11 @@ import { getConfig } from '../config.js';
 import { extractMemories, adapters } from '../adapters/index.js';
 import { syncToLocal, syncToGit } from '../providers/index.js';
 import inquirer from 'inquirer';
-import { findClaudeSessions, parseSession, generateContextHandoff, shouldIgnoreProject } from '../context/capture.js';
+import { findClaudeSessions, parseSession, generateContextHandoff, shouldIgnoreProject, persistDecisions } from '../context/capture.js';
 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';
 
 export async function pushCommand(options = {}) {
   const config = await getConfig(options.profile);
@@ -76,10 +77,19 @@ export async function pushCommand(options = {}) {
           await fs.writeFile(path.join(localHandoffDir, `${timestamp}-claude.md`), clean);
           await fs.writeFile(path.join(localHandoffDir, 'latest.md'), clean);
 
+          // Persist decisions to Claude's memory so they survive across sessions
+          let decisionCount = 0;
+          if (parsed.decisions.length > 0) {
+            try {
+              decisionCount = persistDecisions(parsed.decisions);
+            } catch {}
+          }
+
           contextCaptured = true;
           sessionInfo = {
             slug: parsed.slug,
             filesModified: parsed.filesWritten.length,
+            decisions: decisionCount,
             duration: parsed.firstTimestamp && parsed.lastTimestamp
               ? (() => {
                   const ms = new Date(parsed.lastTimestamp) - new Date(parsed.firstTimestamp);
@@ -101,6 +111,15 @@ export async function pushCommand(options = {}) {
       // Context capture is best-effort — don't fail the push
     }
 
+    // Scan workspace for projects (git repos + unbacked projects)
+    let workspaceManifest = null;
+    spinner.text = chalk.gray('Scanning workspace...');
+    try {
+      workspaceManifest = await scanWorkspace(stagingDir, spinner);
+    } catch {
+      // Workspace scan is best-effort
+    }
+
     // Count what was found
     const found = [];
     for (const adapter of adapters) {
@@ -216,13 +235,25 @@ export async function pushCommand(options = {}) {
       if (sessionInfo.duration) parts.push(sessionInfo.duration);
       if (sessionInfo.filesModified) parts.push(`${sessionInfo.filesModified} files changed`);
       contextLine = '\n' + chalk.green('  ✔ Session Context') + chalk.gray(` (${parts.join(', ')})`) + '\n';
+      if (sessionInfo.decisions > 0) {
+        contextLine += chalk.green(`  ✔ ${sessionInfo.decisions} decision(s) saved to persistent memory`) + '\n';
+      }
       if (sessionInfo.secretsRedacted > 0) {
         contextLine += chalk.yellow(`  🔒 ${sessionInfo.secretsRedacted} secret(s) auto-redacted`) + '\n';
       }
     }
+    let workspaceLine = '';
+    if (workspaceManifest && workspaceManifest.projects.length > 0) {
+      const gitCount = workspaceManifest.projects.filter(p => p.type === 'git' && p.gitRemote).length;
+      const bundleCount = workspaceManifest.projects.filter(p => p.bundleFile).length;
+      const parts = [];
+      if (gitCount > 0) parts.push(`${gitCount} git`);
+      if (bundleCount > 0) parts.push(`${bundleCount} bundled`);
+      workspaceLine = '\n' + chalk.green('  ✔ Workspace') + chalk.gray(` (${workspaceManifest.projects.length} projects — ${parts.join(', ')})`) + '\n';
+    }
     console.log('\n' + boxen(
       gradient.pastel('  Backed up!  ') + '\n\n' +
-      toolList + contextLine + '\n' +
+      toolList + contextLine + workspaceLine + '\n' +
       chalk.white(`${totalFiles} files from ${found.length} tool${found.length !== 1 ? 's' : ''}`) + '\n' +
       (encrypted ? chalk.green('  🔒 E2E encrypted') + '\n' : '') +
       chalk.gray(`→ ${dest}`) + '\n\n' +

package/src/commands/restore.js

@@ -10,6 +10,7 @@ import { getConfig } from '../config.js';
 import { fetchFromLocal, fetchFromGit } from '../providers/restore.js';
 import { decryptDirectory, verifyPassphrase } from '../security/encryption.js';
 import { detectLocalHomeKey } from '../adapters/restore.js';
+import { restoreWorkspace } from '../workspace/tracker.js';
 
 const home = os.homedir();
 
@@ -169,6 +170,39 @@ export async function restoreCommand(options = {}) {
       }
     }
 
+    // Restore workspace (clone git projects, unpack bundles)
+    let workspaceResults = null;
+    try {
+      spinner.start(chalk.gray('Checking workspace...'));
+      workspaceResults = await restoreWorkspace(stagingDir, spinner, autoYes);
+      spinner.stop();
+
+      if (workspaceResults) {
+        const { cloned, unpacked, patched, skipped } = workspaceResults;
+        if (cloned.length > 0 || unpacked.length > 0) {
+          console.log('\n' + chalk.cyan.bold('  📁 Workspace restored:'));
+          for (const p of cloned) {
+            console.log(chalk.green(`    ✔ ${p.name}`) + chalk.gray(` → ${p.path}`));
+          }
+          for (const p of unpacked) {
+            console.log(chalk.green(`    ✔ ${p.name}`) + chalk.gray(` → ${p.path} (unpacked)`));
+          }
+          if (patched.length > 0) {
+            for (const p of patched) {
+              console.log(chalk.yellow(`    ↻ ${p.name}`) + chalk.gray(` — uncommitted changes applied`));
+            }
+          }
+          const existingCount = skipped.filter(s => s.reason === 'exists').length;
+          if (existingCount > 0) {
+            console.log(chalk.gray(`    ⏭ ${existingCount} project(s) already on this machine`));
+          }
+          restored = true;
+        }
+      }
+    } catch {
+      // Workspace restore is best-effort
+    }
+
     if (restored) {
       let handoffMsg = '';
       if (handoffInjected && handoffInfo) {
@@ -178,10 +212,17 @@ export async function restoreCommand(options = {}) {
           (handoffInfo.duration ? '\n' + chalk.gray(`   Duration: ${handoffInfo.duration}`) : '') + '\n' +
           chalk.gray('   Your AI will pick up where you left off.');
       }
+      let workspaceMsg = '';
+      if (workspaceResults) {
+        const total = workspaceResults.cloned.length + workspaceResults.unpacked.length;
+        if (total > 0) {
+          workspaceMsg = '\n' + chalk.cyan(`📁 ${total} project(s) restored to this machine`);
+        }
+      }
       console.log(boxen(
         gradient.pastel('  Done!  ') + '\n\n' +
         chalk.white('Your AI tools have their memories back.') +
-        handoffMsg + '\n' +
+        handoffMsg + workspaceMsg + '\n' +
         chalk.gray(handoffInjected ? '' : 'Restart your AI tools to pick up the changes.'),
         { padding: 1, borderStyle: 'round', borderColor: 'green', dimBorder: true }
       ) + '\n');

package/src/context/capture.js

@@ -42,12 +42,18 @@ export function findClaudeSessions() {
  */
 export function parseSession(sessionPath, maxSizeMB = 10) {
   const stat = fs.statSync(sessionPath);
-  if (stat.size > maxSizeMB * 1024 * 1024) {
-    // For large files, only parse the last portion
-    const raw = fs.readFileSync(sessionPath, 'utf8');
-    const lines = raw.split('\n');
-    const lastLines = lines.slice(-500); // Last 500 lines
-    return parseLines(lastLines);
+  const TAIL_BYTES = 2 * 1024 * 1024; // Read last 2MB max
+
+  if (stat.size > TAIL_BYTES) {
+    // For large files, only read the tail to avoid loading 20MB+ into memory
+    const fd = fs.openSync(sessionPath, 'r');
+    const buf = Buffer.alloc(TAIL_BYTES);
+    fs.readSync(fd, buf, 0, TAIL_BYTES, stat.size - TAIL_BYTES);
+    fs.closeSync(fd);
+    const raw = buf.toString('utf8');
+    // Skip the first (partial) line since we likely cut mid-line
+    const lines = raw.split('\n').slice(1);
+    return parseLines(lines);
   }
 
   const raw = fs.readFileSync(sessionPath, 'utf8').trim();
@@ -55,6 +61,7 @@ export function parseSession(sessionPath, maxSizeMB = 10) {
 }
 
 function parseLines(lines) {
+  const assistantTexts = [];
   const result = {
     sessionId: null,
     slug: null,
@@ -89,9 +96,14 @@ function parseLines(lines) {
       }
     }
 
-    // Tool uses from assistant
+    // Tool uses and text from assistant
     if (obj.type === 'assistant' && Array.isArray(obj.message?.content)) {
       for (const block of obj.message.content) {
+        if (block.type === 'text' && block.text) {
+          // Capture assistant text for decision extraction (limit size)
+          if (block.text.length < 2000) assistantTexts.push(block.text);
+          continue;
+        }
         if (block.type !== 'tool_use') continue;
         const name = block.name;
         const input = block.input || {};
@@ -133,9 +145,148 @@ function parseLines(lines) {
   result.filesRead = [...result.filesRead];
   result.errors = [...new Set(result.errors)].slice(0, 10);
 
+  // Extract decisions from user + assistant messages
+  result.decisions = extractDecisions(result.userMessages, assistantTexts);
+
   return result;
 }
 
+/**
+ * Extract durable decisions from session conversation.
+ * These are things like renames, tech choices, preferences — stuff that should persist.
+ */
+function extractDecisions(userMessages, assistantTexts) {
+  const decisions = [];
+  const allText = [...userMessages, ...assistantTexts].join('\n');
+
+  // Patterns that indicate a decision was made
+  const patterns = [
+    // Renames / naming
+    { regex: /(?:rename|call|name)\s+(?:it|this|the (?:project|app|tool|product))\s+(?:to\s+)?["']?([A-Z][a-zA-Z0-9_-]+)["']?/gi, type: 'rename' },
+    { regex: /(?:the\s+)?(?:new\s+)?name\s+(?:is|will be|should be)\s+["']?([A-Z][a-zA-Z0-9_-]+)["']?/gi, type: 'rename' },
+    { regex: /(?:rebrand|rebranding)\s+(?:to|as)\s+["']?([A-Z][a-zA-Z0-9_-]+)["']?/gi, type: 'rename' },
+    // Tech choices
+    { regex: /(?:let'?s|we(?:'ll| will| should)?|going to|decided to)\s+use\s+([A-Z][a-zA-Z0-9_./-]+)\s+(?:for|instead|as|to)/gi, type: 'tech' },
+    { regex: /(?:switch|migrate|move)\s+(?:from\s+\S+\s+)?to\s+([A-Z][a-zA-Z0-9_./-]+)/gi, type: 'tech' },
+    // Architecture / design
+    { regex: /(?:let'?s|we(?:'ll| will| should)?)\s+(?:go with|pick|choose)\s+(.{5,60}?)(?:\.|$|,|\n)/gi, type: 'design' },
+    // Stack choices
+    { regex: /(?:stack|framework|database|backend|frontend)\s+(?:is|will be|should be)\s+(.{5,60}?)(?:\.|$|,|\n)/gi, type: 'stack' },
+  ];
+
+  for (const { regex, type } of patterns) {
+    let match;
+    while ((match = regex.exec(allText)) !== null) {
+      const value = match[1].trim().replace(/["']+$/, '');
+      if (value.length > 2 && value.length < 80) {
+        // Avoid duplicates
+        const existing = decisions.find(d => d.value.toLowerCase() === value.toLowerCase());
+        if (!existing) {
+          decisions.push({ type, value, context: match[0].trim().slice(0, 120) });
+        }
+      }
+    }
+  }
+
+  // Look for explicit "remember this" instructions from the user
+  for (const msg of userMessages) {
+    // Only match when user is clearly asking to remember something
+    const rememberMatch = msg.match(/(?:remember (?:that|this)|note that|keep in mind that|from now on)[:\s]+(.{10,150})/i);
+    if (rememberMatch) {
+      decisions.push({ type: 'user-note', value: rememberMatch[1].trim(), context: msg.slice(0, 120) });
+    }
+  }
+
+  return decisions.slice(0, 20); // Cap at 20 decisions per session
+}
+
+/**
+ * Write extracted decisions to Claude's persistent memory.
+ * This ensures decisions survive across sessions and machines.
+ */
+export function persistDecisions(decisions, claudeSource) {
+  if (!decisions || decisions.length === 0) return 0;
+
+  const claudeDir = claudeSource || path.join(home, '.claude');
+  const projectsDir = path.join(claudeDir, 'projects');
+  if (!fs.existsSync(projectsDir)) return 0;
+
+  // Find the HOME-level memory dir (not project-specific)
+  // This is the dir that matches the user's home path encoding
+  let homeKey;
+  if (process.platform === 'win32') {
+    homeKey = home.replace(/\\/g, '-').replace(/:/g, '-');
+  } else {
+    homeKey = '-' + home.replace(/^\//, '').replace(/\//g, '-');
+  }
+
+  // Try exact match first, then detect from existing dirs
+  let memDir = path.join(projectsDir, homeKey, 'memory');
+  if (!fs.existsSync(memDir)) {
+    // Fallback: find dirs with memory/ subfolder, pick shortest name (likely home-level)
+    const entries = fs.readdirSync(projectsDir, { withFileTypes: true })
+      .filter(e => e.isDirectory() && fs.existsSync(path.join(projectsDir, e.name, 'memory')));
+    if (entries.length === 0) return 0;
+    // Shortest dir name is most likely the home key (not a sub-project)
+    const homeEntry = entries.sort((a, b) => a.name.length - b.name.length)[0];
+    memDir = path.join(projectsDir, homeEntry.name, 'memory');
+  }
+
+  fs.mkdirSync(memDir, { recursive: true });
+  const decisionsFile = path.join(memDir, 'session-decisions.md');
+  const memoryMdPath = path.join(memDir, 'MEMORY.md');
+
+  // Read existing decisions file or create new
+  let existing = '';
+  if (fs.existsSync(decisionsFile)) {
+    existing = fs.readFileSync(decisionsFile, 'utf8');
+  }
+
+  // Format new decisions
+  const date = new Date().toISOString().split('T')[0];
+  const newEntries = decisions.map(d => {
+    if (d.type === 'rename') return `- **Renamed:** ${d.context}`;
+    if (d.type === 'tech') return `- **Tech choice:** ${d.context}`;
+    if (d.type === 'design') return `- **Decision:** ${d.context}`;
+    if (d.type === 'stack') return `- **Stack:** ${d.context}`;
+    if (d.type === 'user-note') return `- **Note:** ${d.value}`;
+    return `- ${d.context}`;
+  });
+
+  // Check for duplicates against existing content
+  const fresh = newEntries.filter(entry => !existing.includes(entry));
+  if (fresh.length === 0) return 0;
+
+  const section = `\n### ${date}\n${fresh.join('\n')}\n`;
+
+  if (!existing) {
+    // Create new file with frontmatter
+    const content = `---
+name: Session Decisions
+description: Project decisions extracted from coding sessions — renames, tech choices, architecture
+type: project
+---
+
+# Decisions from coding sessions
+${section}`;
+    fs.writeFileSync(decisionsFile, content);
+  } else {
+    // Append to existing
+    fs.writeFileSync(decisionsFile, existing.trimEnd() + '\n' + section);
+  }
+
+  // Ensure MEMORY.md references the decisions file
+  if (fs.existsSync(memoryMdPath)) {
+    const memoryMd = fs.readFileSync(memoryMdPath, 'utf8');
+    if (!memoryMd.includes('session-decisions.md')) {
+      const addition = `\n- [Session Decisions](session-decisions.md) — project renames, tech choices, architecture decisions from coding sessions\n`;
+      fs.writeFileSync(memoryMdPath, memoryMd.trimEnd() + addition);
+    }
+  }
+
+  return fresh.length;
+}
+
 /**
  * Generate a concise handoff markdown from parsed session
  * This is what gets injected into the AI tool on the other machine

package/src/workspace/tracker.js

@@ -0,0 +1,350 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { execFileSync } from 'child_process';
+
+const home = os.homedir();
+
+/**
+ * Scan home directory for git projects and build a workspace manifest.
+ * Tracks: git remote URL, branch, last commit, uncommitted changes (as patch).
+ * For non-git projects with AI configs, bundles them as tar.gz.
+ */
+export async function scanWorkspace(stagingDir, spinner, opts = {}) {
+  const maxDepth = opts.maxDepth || 3;
+  const maxBundleSize = opts.maxBundleSize || 50 * 1024 * 1024; // 50MB
+
+  const skipDirs = new Set([
+    'node_modules', '.git', '.next', '.vercel', 'dist', 'build',
+    '__pycache__', '.venv', 'venv', '.cache', '.npm', '.bun',
+    'Library', '.Trash', 'Applications', 'Pictures', 'Music',
+    'Movies', 'Public', 'Downloads', '.local', '.cargo', '.rustup',
+    '.docker', '.ssh', '.config', '.claude', '.gemini'
+  ]);
+
+  // Project markers — files that indicate "this is a project"
+  const projectMarkers = [
+    'package.json', 'Cargo.toml', 'go.mod', 'pyproject.toml',
+    'requirements.txt', 'Gemfile', 'pom.xml', 'build.gradle',
+    'Makefile', 'CMakeLists.txt', '.project', 'CLAUDE.md',
+    'GEMINI.md', 'AGENTS.md', 'README.md',
+    // Also detect dirs with .git or multiple content files
+    '.gitignore', 'index.html', 'main.py', 'app.py', 'index.js',
+  ];
+
+  // Also detect dirs with multiple markdown/code files as potential projects
+  const isContentProject = (entries) => {
+    const mdFiles = entries.filter(e => !e.isDirectory() && e.name.endsWith('.md'));
+    return mdFiles.length >= 2; // 2+ markdown files = likely a writing project
+  };
+
+  const projects = [];
+
+  const scanDir = async (dir, depth = 0) => {
+    if (depth > maxDepth) return;
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch { return; }
+
+    // Check if this dir is a project
+    const hasMarker = entries.some(e => !e.isDirectory() && projectMarkers.includes(e.name));
+    const hasContent = isContentProject(entries);
+
+    if ((hasMarker || hasContent) && dir !== home) {
+      const info = await getProjectInfo(dir);
+      if (info) projects.push(info);
+      // Don't recurse into sub-projects deeper than this
+      return;
+    }
+
+    // Recurse into subdirectories
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith('.') && entry.name !== '.github') continue;
+      if (skipDirs.has(entry.name)) continue;
+      await scanDir(path.join(dir, entry.name), depth + 1);
+    }
+  };
+
+  if (spinner) spinner.text = 'Scanning workspace for projects...';
+  await scanDir(home);
+
+  // Build manifest
+  const manifest = {
+    version: 1,
+    machine: os.hostname(),
+    platform: process.platform,
+    home: home,
+    scannedAt: new Date().toISOString(),
+    projects: []
+  };
+
+  const bundleDir = path.join(stagingDir, 'workspace-bundles');
+
+  for (const proj of projects) {
+    const entry = {
+      name: proj.name,
+      relativePath: proj.relativePath,
+      originalPath: proj.path,
+      type: proj.hasGit ? 'git' : 'bundle',
+    };
+
+    if (proj.hasGit) {
+      entry.gitRemote = proj.gitRemote;
+      entry.branch = proj.branch;
+      entry.lastCommit = proj.lastCommit;
+      entry.lastCommitMessage = proj.lastCommitMessage;
+
+      // Save uncommitted changes as patch
+      if (proj.hasDirtyWork && proj.lastCommit) {
+        try {
+          const patchDir = path.join(stagingDir, 'workspace-patches');
+          await fs.ensureDir(patchDir);
+          const diff = execFileSync('git', ['diff', 'HEAD'], {
+            cwd: proj.path,
+            maxBuffer: 10 * 1024 * 1024,
+            timeout: 10000
+          }).toString();
+          if (diff.trim()) {
+            const patchFile = `${proj.name}.patch`;
+            await fs.writeFile(path.join(patchDir, patchFile), diff);
+            entry.patchFile = patchFile;
+          }
+        } catch {
+          // Patch capture is best-effort
+        }
+      }
+    } else {
+      // Bundle non-git project (if small enough)
+      const size = await getDirSize(proj.path);
+      if (size <= maxBundleSize) {
+        try {
+          await fs.ensureDir(bundleDir);
+          const bundleName = `${proj.name}.tar.gz`;
+          execFileSync('tar', [
+            'czf', path.join(bundleDir, bundleName),
+            '-C', path.dirname(proj.path),
+            '--exclude', 'node_modules',
+            '--exclude', '.git',
+            '--exclude', '__pycache__',
+            '--exclude', '.venv',
+            '--exclude', 'dist',
+            '--exclude', 'build',
+            proj.name
+          ], { stdio: 'ignore', timeout: 30000 });
+          entry.bundleFile = bundleName;
+          entry.bundleSize = (await fs.stat(path.join(bundleDir, bundleName))).size;
+        } catch {
+          // Bundle is best-effort
+          entry.bundleFailed = true;
+        }
+      } else {
+        entry.tooLarge = true;
+        entry.size = size;
+      }
+    }
+
+    manifest.projects.push(entry);
+  }
+
+  // Save manifest
+  await fs.writeFile(
+    path.join(stagingDir, 'workspace.json'),
+    JSON.stringify(manifest, null, 2)
+  );
+
+  return manifest;
+}
+
+/**
+ * Restore workspace on this machine from a manifest.
+ * Clones git projects, unpacks bundles, applies patches.
+ */
+export async function restoreWorkspace(sourceDir, spinner, autoYes = false) {
+  const manifestPath = path.join(sourceDir, 'workspace.json');
+  if (!await fs.pathExists(manifestPath)) return null;
+
+  const manifest = await fs.readJson(manifestPath);
+  if (!manifest.projects || manifest.projects.length === 0) return null;
+
+  const results = { cloned: [], unpacked: [], patched: [], skipped: [] };
+
+  for (const proj of manifest.projects) {
+    // Determine where to put this project on the local machine
+    const localPath = resolveLocalPath(proj);
+
+    // Skip if project already exists locally
+    if (await fs.pathExists(localPath)) {
+      // But check if we should apply a patch
+      if (proj.patchFile) {
+        const patchPath = path.join(sourceDir, 'workspace-patches', proj.patchFile);
+        if (await fs.pathExists(patchPath)) {
+          try {
+            execFileSync('git', ['apply', '--check', patchPath], {
+              cwd: localPath, stdio: 'ignore'
+            });
+            execFileSync('git', ['apply', patchPath], {
+              cwd: localPath, stdio: 'ignore'
+            });
+            results.patched.push({ name: proj.name, path: localPath });
+          } catch {
+            // Patch didn't apply cleanly — skip
+          }
+        }
+      }
+      results.skipped.push({ name: proj.name, path: localPath, reason: 'exists' });
+      continue;
+    }
+
+    if (proj.type === 'git' && proj.gitRemote) {
+      // Clone the repo
+      if (spinner) spinner.text = `Cloning ${proj.name}...`;
+      try {
+        await fs.ensureDir(path.dirname(localPath));
+        execFileSync('git', ['clone', proj.gitRemote, localPath], {
+          stdio: 'ignore',
+          timeout: 120000
+        });
+
+        // Checkout the right branch
+        if (proj.branch && proj.branch !== 'main' && proj.branch !== 'master') {
+          try {
+            execFileSync('git', ['checkout', proj.branch], {
+              cwd: localPath, stdio: 'ignore'
+            });
+          } catch {}
+        }
+
+        // Apply patch if available
+        if (proj.patchFile) {
+          const patchPath = path.join(sourceDir, 'workspace-patches', proj.patchFile);
+          if (await fs.pathExists(patchPath)) {
+            try {
+              execFileSync('git', ['apply', patchPath], {
+                cwd: localPath, stdio: 'ignore'
+              });
+              results.patched.push({ name: proj.name, path: localPath });
+            } catch {}
+          }
+        }
+
+        results.cloned.push({ name: proj.name, path: localPath, remote: proj.gitRemote });
+      } catch (err) {
+        results.skipped.push({ name: proj.name, reason: `clone failed: ${err.message}` });
+      }
+    } else if (proj.bundleFile) {
+      // Unpack bundle
+      const bundlePath = path.join(sourceDir, 'workspace-bundles', proj.bundleFile);
+      if (await fs.pathExists(bundlePath)) {
+        if (spinner) spinner.text = `Unpacking ${proj.name}...`;
+        try {
+          await fs.ensureDir(path.dirname(localPath));
+          execFileSync('tar', ['xzf', bundlePath, '-C', path.dirname(localPath)], {
+            stdio: 'ignore',
+            timeout: 60000
+          });
+          results.unpacked.push({ name: proj.name, path: localPath });
+        } catch (err) {
+          results.skipped.push({ name: proj.name, reason: `unpack failed: ${err.message}` });
+        }
+      }
+    } else {
+      results.skipped.push({ name: proj.name, reason: proj.tooLarge ? 'too large' : 'no source' });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Figure out where a project should live on this machine.
+ */
+function resolveLocalPath(proj) {
+  // If the project had a relative path from home, use that
+  if (proj.relativePath) {
+    return path.join(home, proj.relativePath);
+  }
+  // Default: put it in home directory
+  return path.join(home, proj.name);
+}
+
+/**
+ * Get info about a project directory.
+ */
+async function getProjectInfo(dir) {
+  const name = path.basename(dir);
+  const relativePath = path.relative(home, dir);
+  const info = {
+    name,
+    path: dir,
+    relativePath,
+    hasGit: false,
+    gitRemote: null,
+    branch: null,
+    lastCommit: null,
+    lastCommitMessage: null,
+    hasDirtyWork: false,
+  };
+
+  // Check for git
+  const gitDir = path.join(dir, '.git');
+  if (await fs.pathExists(gitDir)) {
+    info.hasGit = true;
+    try {
+      const remote = execFileSync('git', ['remote', 'get-url', 'origin'], {
+        cwd: dir, stdio: ['pipe', 'pipe', 'ignore']
+      }).toString().trim();
+      info.gitRemote = remote;
+    } catch {}
+
+    try {
+      info.branch = execFileSync('git', ['branch', '--show-current'], {
+        cwd: dir, stdio: ['pipe', 'pipe', 'ignore']
+      }).toString().trim();
+    } catch {}
+
+    try {
+      info.lastCommit = execFileSync('git', ['log', '-1', '--format=%H'], {
+        cwd: dir, stdio: ['pipe', 'pipe', 'ignore']
+      }).toString().trim();
+      info.lastCommitMessage = execFileSync('git', ['log', '-1', '--format=%s'], {
+        cwd: dir, stdio: ['pipe', 'pipe', 'ignore']
+      }).toString().trim();
+    } catch {}
+
+    try {
+      const status = execFileSync('git', ['status', '--porcelain'], {
+        cwd: dir, stdio: ['pipe', 'pipe', 'ignore'], timeout: 5000
+      }).toString().trim();
+      info.hasDirtyWork = status.length > 0;
+    } catch {}
+  }
+
+  return info;
+}
+
+/**
+ * Get total size of a directory (excluding common heavy dirs).
+ */
+async function getDirSize(dir) {
+  let size = 0;
+  const skip = new Set(['node_modules', '.git', '__pycache__', '.venv', 'dist', 'build']);
+
+  const walk = async (d) => {
+    let entries;
+    try { entries = await fs.readdir(d, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      if (e.isDirectory()) {
+        if (!skip.has(e.name)) await walk(path.join(d, e.name));
+      } else {
+        try {
+          const stat = await fs.stat(path.join(d, e.name));
+          size += stat.size;
+        } catch {}
+      }
+    }
+  };
+  await walk(dir);
+  return size;
+}