memoir-cli 3.11.3 → 3.14.0

package/src/commands/push.js

@@ -1,3 +1,5 @@
+import { projectIdentity } from '../memory/scope.js';
+import { restoreStoredMemories, stageMemories } from '../memory/store.js';
 import chalk from 'chalk';
 import fs from 'fs-extra';
 import path from 'path';
@@ -8,85 +10,70 @@ import gradient from 'gradient-string';
 import { execFileSync } from 'child_process';
 import { getConfig, autoSetup } from '../config.js';
 import { extractMemories, adapters } from '../adapters/index.js';
-import { syncToLocal, syncToGit } from '../providers/index.js';
+import { syncToLocal, syncToGit, withLocalBackupLock, cloneForSync, remoteHasFile, checkoutFromRemote } from '../providers/index.js';
 import inquirer from 'inquirer';
 import { appendEvent } from '../events/log.js';
-import { findClaudeSessions, parseSession, generateContextHandoff, shouldIgnoreProject, persistDecisions, isQuality } from '../context/capture.js';
+import { findClaudeSessions, parseSession, generateContextHandoff, shouldIgnoreProject, persistDecisions, isQuality, enrichWithGit } from '../context/capture.js';
+import { saveHandoff, handoffFilename } from '../context/handoffs.js';
 import { scanForSecrets, printSecurityReport } from '../security/scanner.js';
-import { encryptDirectory, createVerifyToken } from '../security/encryption.js';
+import { encryptDirectory, decryptDirectory, createVerifyToken } from '../security/encryption.js';
 import { getRawConfig, saveConfig, migrateConfigToV2 } from '../config.js';
 import { scanWorkspace } from '../workspace/tracker.js';
 import { promptActivate } from './activate.js';
 import { paths as sessionPaths, readSession, writeSession, mergeSessions, addNote, recordSessionEnd } from '../session/state.js';
 import { migrateSessionData } from '../session/migrations.js';
 import { withSessionLock } from '../session/lock.js';
+import { listSafeFiles, readSafeFile, writeSafeFile } from '../security/files.js';
 import { renderSession } from '../session/render.js';
 import { injectInto, detectAvailableTargets } from '../session/inject.js';
 
-// Best-effort fetch of the CURRENT remote session.json, so push.js can merge
-// before overwrite instead of blindly clobbering it (see below). Returns the
-// remote session state (already migrated to SCHEMA_VERSION) or null if the
-// Tri-state, because the difference is destructive: 'none' means nothing is
-// there (safe to write ours), 'ok' carries the remote session for merging,
-// and 'unreadable' means A REMOTE EXISTS BUT WE CANNOT READ IT — encrypted,
-// slow clone, corrupt JSON. On 'unreadable' the caller MUST NOT stage
-// session.json at all, so the remote copy survives the mirror sweep.
-// The old boolean version returned null for 'unreadable', which collapsed
-// to merged = local and silently clobbered the other machine's state —
-// worst on encrypted remotes, where the "protection" was a complete no-op.
-async function fetchRemoteSessionBestEffort(config) {
+// A failed read never authorizes replacing an existing snapshot. Encrypted
+// snapshots are authenticated before merging, using the same user-held key.
+async function fetchRemoteSessionBestEffort(config, getPassphrase) {
+  let cloneDir = null;
+  let plainDir = null;
   try {
-    if (config.provider === 'local' || config.provider?.includes?.('local')) {
-      const resolvedDest = (config.localPath || '').replace(/^~/, os.homedir());
-      if (!resolvedDest) return { status: 'none', session: null };
-      if (await fs.pathExists(path.join(resolvedDest, 'manifest.enc'))) return { status: 'unreadable', session: null }; // encrypted
-      const remotePath = path.join(resolvedDest, 'session.json');
-      if (!(await fs.pathExists(remotePath))) return { status: 'none', session: null };
-      try {
-        const raw = JSON.parse(await fs.readFile(remotePath, 'utf8'));
-        const { state } = migrateSessionData(raw);
-        return { status: 'ok', session: state };
-      } catch {
-        return { status: 'unreadable', session: null }; // exists but corrupt
-      }
-    }
-
-    if (config.provider === 'git' || config.provider?.includes?.('git')) {
-      const repoUrl = config.gitRepo;
-      if (!repoUrl) return { status: 'none', session: null };
-      const peekDir = path.join(os.tmpdir(), `memoir-push-peek-${Date.now()}`);
-      await fs.ensureDir(peekDir);
-      try {
-        try {
-          // Same budget as the real sync clone — the old 30s peek against a
-          // 60s sync meant a 35-second clone failed the peek but succeeded
-          // the mirror, deterministically wiping the remote session.
-          execFileSync('git', ['clone', '--depth', '1', repoUrl, '.'], { cwd: peekDir, stdio: 'ignore', timeout: 120000 });
-        } catch {
-          // Unreachable or first push. If the LATER sync clone succeeds
-          // where this one failed, treating it as 'none' would clobber —
-          // but with equal timeouts that window is a genuine remote flap,
-          // and 'unreadable' here would wedge first-time pushes forever.
-          return { status: 'none', session: null };
-        }
-        if (await fs.pathExists(path.join(peekDir, 'manifest.enc'))) return { status: 'unreadable', session: null }; // encrypted
-        const remotePath = path.join(peekDir, 'session.json');
-        if (!(await fs.pathExists(remotePath))) return { status: 'none', session: null };
-        try {
-          const raw = JSON.parse(await fs.readFile(remotePath, 'utf8'));
-          const { state } = migrateSessionData(raw);
-          return { status: 'ok', session: state };
-        } catch {
-          return { status: 'unreadable', session: null };
+    let source;
+    if (config.provider?.includes('local')) {
+      source = (config.localPath || '').replace(/^~/, os.homedir());
+      if (!source || !await fs.pathExists(source)) return { session: null };
+    } else if (config.provider?.includes('git')) {
+      cloneDir = await fs.mkdtemp(path.join(os.tmpdir(), 'memoir-push-peek-'));
+      cloneForSync(config.gitRepo, cloneDir, { timeout: 120000 });
+      source = cloneDir;
+      // Materialize the complete tree before merging a snapshot. Correctness
+      // comes before the old optimization that omitted encrypted session data.
+      if (remoteHasFile(cloneDir, 'manifest.enc') || config.encrypt !== false) {
+        if (remoteHasFile(cloneDir, '.')) {
+          if (!checkoutFromRemote(cloneDir, '.')) throw new Error('Could not read prior backup');
         }
-      } finally {
-        await fs.remove(peekDir).catch(() => {});
+      } else if (remoteHasFile(cloneDir, 'session.json') && !checkoutFromRemote(cloneDir, 'session.json')) {
+        throw new Error('Could not read prior session');
       }
+    } else { throw new Error('Unsupported backup provider'); }
+
+    if (cloneDir && remoteHasFile(cloneDir, 'projects.json') && !checkoutFromRemote(cloneDir, 'projects.json')) throw new Error('Could not read prior project mapping');
+    if (cloneDir && remoteHasFile(cloneDir, 'memoir-memories') && !checkoutFromRemote(cloneDir, 'memoir-memories')) throw new Error('Could not read prior memory records');
+    const encrypted = await fs.pathExists(path.join(source, 'manifest.enc'));
+    if (encrypted) {
+      if (config.encrypt === false) throw new Error('The destination is encrypted. Restore it before choosing a new plaintext destination.');
+      plainDir = await fs.mkdtemp(path.join(os.tmpdir(), 'memoir-prior-'));
+      await decryptDirectory(source, plainDir, await getPassphrase());
+      source = plainDir;
+    }
+    const file = path.join(source, 'session.json');
+    let session = null;
+    if (await fs.pathExists(file)) {
+      const migrated = migrateSessionData(JSON.parse((await readSafeFile(source, 'session.json')).toString('utf8')));
+      if (migrated.future) throw new Error('Backup uses a newer session schema; upgrade Memoir first.');
+      session = migrated.state;
     }
-  } catch {
-    // Never let a merge-fetch failure block the push.
+    return { session, cloneDir, plainDir, source, encrypted };
+  } catch (err) {
+    if (cloneDir) await fs.remove(cloneDir).catch(() => {});
+    if (plainDir) await fs.remove(plainDir).catch(() => {});
+    throw new Error('Previous backup could not be verified; it was left unchanged. ' + err.message);
   }
-  return { status: 'none', session: null };
 }
 
 // Recursively scan every staged file (the REAL tool memory/config files about
@@ -143,7 +130,7 @@ export async function pushCommand(options = {}) {
     const setupSpinner = ora({ text: chalk.gray('Setting up memoir automatically...'), spinner: 'dots' }).start();
     config = await autoSetup();
     if (config) {
-      setupSpinner.succeed(chalk.green('Auto-configured') + chalk.gray(` → ${config.gitRepo}`));
+      setupSpinner.succeed(chalk.green('Auto-configured') + chalk.gray(` → ${config.gitRepo || config.localPath}`));
     } else {
       setupSpinner.fail(chalk.red('Could not detect GitHub username'));
       console.log('\n' + boxen(
@@ -154,6 +141,11 @@ export async function pushCommand(options = {}) {
     }
   }
 
+  // Serialize the complete read/merge/write cycle, including encrypted reads.
+  if (config.provider?.includes('local') && !options.localLockHeld) {
+    return withLocalBackupLock(config, () => pushCommand({ ...options, localLockHeld: true }));
+  }
+
   console.log();
   const spinner = ora({ text: chalk.gray('Scanning for AI tools...'), spinner: 'dots' }).start();
 
@@ -161,6 +153,18 @@ export async function pushCommand(options = {}) {
   await fs.ensureDir(stagingDir);
 
   let encryptedDir = null;
+  let remoteCloneDir = null;
+  let remotePlainDir = null;
+  let backupPassphrase = process.env.MEMOIR_PASSPHRASE || '';
+  const getPassphrase = async () => {
+    if (backupPassphrase.length >= 6) return backupPassphrase;
+    if (!process.stdin.isTTY) throw new Error('Encrypted backup requires MEMOIR_PASSPHRASE; no files were uploaded.');
+    spinner.stop();
+    const answer = await inquirer.prompt([{ type: 'password', name: 'passphrase', message: 'Encryption passphrase:', mask: '*', validate: value => value.length >= 6 || 'Use at least 6 characters' }]);
+    backupPassphrase = answer.passphrase;
+    spinner.start();
+    return backupPassphrase;
+  };
 
   try {
     // Profile-level tool filter (config.only) merged with CLI --only flag
@@ -168,7 +172,7 @@ export async function pushCommand(options = {}) {
     const onlyFilter = onlyRaw ? onlyRaw.split(',').map(t => t.trim().toLowerCase()) : null;
     const foundAny = await extractMemories(stagingDir, spinner, onlyFilter);
 
-    if (!foundAny) {
+    if (!foundAny && !await fs.pathExists(sessionPaths.session)) {
       spinner.stop();
       console.log('\n' + boxen(
         chalk.yellow('No AI tools detected on this machine.\n\n') +
@@ -185,24 +189,18 @@ export async function pushCommand(options = {}) {
     try {
       const sessions = findClaudeSessions();
       if (sessions.length > 0) {
-        const parsed = parseSession(sessions[0].path);
-        if (parsed.userMessages.length > 0) {
+        const parsed = enrichWithGit(parseSession(sessions[0].path));
+        if (parsed.cwd && projectIdentity(parsed.cwd) === projectIdentity() && parsed.userMessages.length > 0) {
           // Scan the generated handoff for any remaining secrets
           const handoff = generateContextHandoff(parsed);
           const { found, clean } = scanForSecrets(handoff);
 
-          // Save handoff to staging dir
-          const handoffDir = path.join(stagingDir, 'handoffs');
-          await fs.ensureDir(handoffDir);
-          const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
-          await fs.writeFile(path.join(handoffDir, `${timestamp}-claude.md`), clean);
-          await fs.writeFile(path.join(handoffDir, 'latest.md'), clean);
-
-          // Also save locally for memoir resume
-          const localHandoffDir = path.join(os.homedir(), '.config', 'memoir', 'handoffs');
-          await fs.ensureDir(localHandoffDir);
-          await fs.writeFile(path.join(localHandoffDir, `${timestamp}-claude.md`), clean);
-          await fs.writeFile(path.join(localHandoffDir, 'latest.md'), clean);
+          // Staged copy for upload + local copy for `memoir resume`, same
+          // filename; the local dir is pruned to a bounded window.
+          await saveHandoff(clean, {
+            dirs: [path.join(stagingDir, 'handoffs'), path.join(os.homedir(), '.config', 'memoir', 'handoffs')],
+            filename: handoffFilename(),
+          });
 
           // Quality filter: auto-extracted decisions come from regex patterns
           // that sometimes catch table cells, prose fragments, or truncated
@@ -223,13 +221,7 @@ export async function pushCommand(options = {}) {
           };
           const qualityDecisions = parsed.decisions.filter(d => isQuality(decisionText(d)));
 
-          // Persist decisions to Claude's memory so they survive across sessions
-          let decisionCount = 0;
-          if (qualityDecisions.length > 0) {
-            try {
-              decisionCount = persistDecisions(qualityDecisions);
-            } catch {}
-          }
+          let decisionCount = qualityDecisions.length;
 
           // Also feed structured decisions into session.json so they appear in
           // the pinned block and sync cross-machine. Dedupe against anything
@@ -242,15 +234,30 @@ export async function pushCommand(options = {}) {
             for (const d of qualityDecisions.slice(0, 10)) {
               const text = decisionText(d);
               if (existingTexts.has(text.toLowerCase())) continue;
-              await addNote(text, { why: d.context ? `auto-captured: ${d.context.slice(0, 80)}` : undefined });
+              // A `why` that merely restates the text is not a rationale —
+              // for rename/tech captures decisionText() IS d.context, so the
+              // old line produced `why: "auto-captured: switch to Sonnet"`
+              // under text "switch to Sonnet". Content-free, and it made
+              // auto-captures indistinguishable from real reasoning in the
+              // pinned block. Emit no why rather than a fake one.
+              const ctx = String(d.context || '').trim();
+              const restates = !ctx || ctx.toLowerCase() === text.trim().toLowerCase();
+              await addNote(text, { project: parsed.cwd, why: restates ? undefined : `auto-captured: ${ctx.slice(0, 80)}` });
             }
-            // Record a session summary in history for "recent sessions" section
+            // Record a session summary in history for "recent sessions" section.
+            // Project + branch + the last thing the user asked for — the old
+            // summary was the transcript's random slug ("Worked on
+            // calm-bubbling-liskov"), which told the next session nothing.
             const filesList = Array.from(parsed.filesWritten || []).slice(0, 10);
             const durationMin = (parsed.firstTimestamp && parsed.lastTimestamp)
               ? Math.floor((new Date(parsed.lastTimestamp) - new Date(parsed.firstTimestamp)) / 60000)
               : null;
-            const summary = parsed.slug ? `Worked on ${parsed.slug}` : `${filesList.length} file(s) touched`;
-            await recordSessionEnd({ summary, filesTouched: filesList, durationMin });
+            const lastAsk = [...parsed.userMessages].reverse().find((m) => m.length > 10) || '';
+            const project = parsed.cwd ? path.basename(parsed.cwd) : (parsed.slug || 'session');
+            const branch = parsed.gitBranch && parsed.gitBranch !== 'HEAD' ? ` (${parsed.gitBranch})` : '';
+            const ask = lastAsk.replace(/\s+/g, ' ').trim().slice(0, 90);
+            const summary = ask ? `${project}${branch}: ${ask}` : `${project}${branch}`;
+            await recordSessionEnd({ summary, filesTouched: filesList, durationMin, sessionId: parsed.sessionId || null, project: parsed.cwd });
             // Re-render into every detected tool so the pinned block reflects
             // what was just auto-captured from the .jsonl
             try {
@@ -294,60 +301,48 @@ export async function pushCommand(options = {}) {
     let workspaceManifest = null;
     spinner.text = chalk.gray('Scanning workspace...');
     try {
-      workspaceManifest = await scanWorkspace(stagingDir, spinner);
-    } catch {
-      // Workspace scan is best-effort
+      if (options.workspace === true || config.workspace === true) workspaceManifest = await scanWorkspace(stagingDir, spinner);
+    } catch (err) {
+      throw new Error('Workspace capture failed: ' + err.message);
     }
 
-    // Include session.json (continuity state) so it syncs across machines.
-    //
-    // MERGE-BEFORE-OVERWRITE: this used to be a blind fs.copy() of the LOCAL
-    // session.json, and syncToGit/syncToLocal do a full-mirror overwrite of
-    // the remote (clone-or-init, delete every tracked file, copy the local
-    // staging dir wholesale over it, commit, push). Any machine that pushed
-    // without having restored first would silently and completely destroy
-    // whatever ANY OTHER machine had added to the remote in the interim —
-    // goals, next-actions, decisions, everything. Not an edge case: it's the
-    // default behavior of the most common operation in the tool (autopush
-    // fires after every single Claude Code response).
-    //
-    // Best-effort fetch the current remote session.json first, migrate it,
-    // and merge with mergeSessions (the same newest-timestamp-wins
-    // union-by-text function restore.js already uses) BEFORE writing the
-    // result to both the staging dir (for upload) and back to the local
-    // session.json (so this machine also gains whatever the remote had that
-    // it didn't) — symmetric with restore.js instead of a blind overwrite.
-    let sessionIncluded = false;
-    let preserveRemoteSession = false;
-    try {
-      if (await fs.pathExists(sessionPaths.session)) {
-        const { status, session: remote } = await fetchRemoteSessionBestEffort(config);
-        if (status === 'unreadable') {
-          // A remote session exists and we could not read it (encrypted,
-          // slow, corrupt). Staging ours anyway would mirror-overwrite the
-          // one copy we couldn't merge — the exact clobber this guard
-          // exists to prevent. Leave session.json out of the staging dir
-          // and tell the sync to leave the remote copy alone.
-          preserveRemoteSession = true;
-          try { appendEvent('sync_degraded', { reason: 'remote_session_unreadable' }); } catch {}
-        } else {
-          // Read AND merge AND write inside one lock. Reading outside it and
-          // locking only the write is a check-then-act: a concurrent MCP
-          // memoir_note in that window is silently dropped. This is the most
-          // reachable instance of that bug — it sits on the autopush path.
-          let merged;
-          await withSessionLock(sessionPaths.sessionLock, async () => {
-            const local = await readSession();
-            merged = remote ? mergeSessions(local, remote) : local;
-            if (remote) await writeSession(merged);
-          });
-          await fs.writeFile(path.join(stagingDir, 'session.json'), JSON.stringify(merged, null, 2));
-          sessionIncluded = true;
+    const prior = await fetchRemoteSessionBestEffort(config, getPassphrase);
+    remoteCloneDir = prior.cloneDir || null;
+    remotePlainDir = prior.plainDir || null;
+    if (prior.source) await restoreStoredMemories(prior.source);
+    // Keep mappings for projects that exist only on another machine.
+    if (prior.source && await fs.pathExists(path.join(prior.source, 'projects.json'))) {
+      const remoteProjects = JSON.parse((await readSafeFile(prior.source, 'projects.json')).toString());
+      let localProjects = {};
+      if (await fs.pathExists(path.join(stagingDir, 'projects.json'))) localProjects = JSON.parse((await readSafeFile(stagingDir, 'projects.json')).toString());
+      await writeSafeFile(stagingDir, 'projects.json', JSON.stringify({ ...remoteProjects, ...localProjects }, null, 2));
+    }
+
+    await stageMemories(stagingDir);
+    // Re-encryption always starts with a complete prior snapshot. Overlay
+    // current files, preserve files absent on this machine, merge session below.
+    if ((config.encrypt !== false || prior.encrypted) && prior.source) {
+      const priorFiles = await listSafeFiles(prior.source).catch(async err => {
+        // A checked-out Git tree contains .git, which is transport metadata.
+        if (remoteCloneDir === prior.source) {
+          const files = execFileSync('git', ['ls-files', '-z'], { cwd: prior.source, encoding: 'utf8' }).split('\0').filter(Boolean);
+          return files;
         }
+        throw err;
+      });
+      for (const rel of priorFiles) {
+        if (rel.startsWith('memoir-memories/')) continue; // Already reconciled, including purge tombstones.
+        if (!await fs.pathExists(path.join(stagingDir, rel))) await writeSafeFile(stagingDir, rel, await readSafeFile(prior.source, rel));
       }
-    } catch {
-      // Best-effort — don't fail the push over this
     }
+    let merged;
+    await withSessionLock(sessionPaths.sessionLock, async () => {
+      const local = await readSession();
+      merged = prior.session ? mergeSessions(local, prior.session) : local;
+      await writeSession(merged);
+    });
+    await writeSafeFile(stagingDir, 'session.json', JSON.stringify(merged, null, 2));
+    const sessionIncluded = true;
 
     // Count what was found
     const found = [];
@@ -369,13 +364,8 @@ export async function pushCommand(options = {}) {
     //   • --redact            → strip secrets in place, then upload (sanitized)
     //   • otherwise           → WARN and continue
     //   • background autopush → stay silent and continue
-    // We deliberately do NOT hard-block. This is a zero-knowledge encrypted
-    // backup of the user's OWN files; silently refusing to back up — which the
-    // detached `autopush` Stop-hook path (stdio:'ignore', MEMOIR_AUTOPUSH=1, no
-    // TTY) would hit on any false-positive match — is a worse failure than
-    // backing up. A future `--strict` flag could fail-closed for the
-    // encrypt-off / shared-destination case. Wrapped so a scanner error can
-    // never break the push.
+    // Redaction is explicit and heuristic. Plaintext backups can contain
+    // secrets; a warning does not promise that every secret was detected.
     const background = process.env.MEMOIR_AUTOPUSH === '1';
     try {
       const { findings } = await scanStagedFiles(stagingDir, { redact: options.redact === true });
@@ -408,7 +398,7 @@ export async function pushCommand(options = {}) {
     // Encrypt if enabled (or ask on first push if not configured)
     let uploadDir = stagingDir;
     let encrypted = false;
-    let shouldEncrypt = config.encrypt;
+    let shouldEncrypt = prior.encrypted || config.encrypt;
 
     if (shouldEncrypt === undefined) {
       if (background || !process.stdin.isTTY) {
@@ -418,7 +408,8 @@ export async function pushCommand(options = {}) {
         // otherwise push unencrypted THIS ONCE without persisting the
         // choice — a backup beats no backup, and the next interactive push
         // still gets the real question (default Yes).
-        shouldEncrypt = Boolean(process.env.MEMOIR_PASSPHRASE);
+        if (!process.env.MEMOIR_PASSPHRASE) throw new Error('Choose encryption explicitly with memoir init before sending this backup, or set MEMOIR_PASSPHRASE.');
+        shouldEncrypt = true;
         if (!shouldEncrypt) {
           config.encrypt = undefined; // do not let the fallthrough persist "off"
         }
@@ -456,17 +447,7 @@ export async function pushCommand(options = {}) {
     if (shouldEncrypt) {
       // Headless pushes can supply the passphrase via env; interactive
       // pushes are asked as before.
-      let passphrase = process.env.MEMOIR_PASSPHRASE || '';
-      if (!passphrase || passphrase.length < 6) {
-        spinner.stop();
-        ({ passphrase } = await inquirer.prompt([{
-          type: 'password',
-          name: 'passphrase',
-          message: '🔒 Encryption passphrase:',
-          mask: '*',
-          validate: (input) => input.length >= 6 ? true : 'Passphrase must be at least 6 characters'
-        }]));
-      }
+      const passphrase = await getPassphrase();
       spinner.start(chalk.gray('Deriving encryption key...'));
 
       encryptedDir = path.join(os.tmpdir(), `memoir-encrypted-${Date.now()}`);
@@ -479,6 +460,19 @@ export async function pushCommand(options = {}) {
       const token = await createVerifyToken(passphrase);
       await fs.writeFile(path.join(encryptedDir, 'verify.enc'), token);
 
+      if (prior.source && !prior.encrypted) {
+        const verified = await fs.mkdtemp(path.join(os.tmpdir(), 'memoir-encryption-check-'));
+        try {
+          await decryptDirectory(encryptedDir, verified, passphrase);
+          const expected = (await listSafeFiles(stagingDir)).sort();
+          const actual = (await listSafeFiles(verified)).sort();
+          if (JSON.stringify(expected) !== JSON.stringify(actual)) throw new Error('Encryption migration verification failed');
+          for (const rel of expected) {
+            if (!(await readSafeFile(stagingDir, rel)).equals(await readSafeFile(verified, rel))) throw new Error('Encryption migration content mismatch');
+          }
+        } finally { await fs.remove(verified); }
+      }
+
       uploadDir = encryptedDir;
       encrypted = true;
     }
@@ -486,9 +480,13 @@ export async function pushCommand(options = {}) {
     spinner.text = chalk.gray('Uploading to ' + (config.provider === 'git' ? 'GitHub' : 'local storage') + '...');
 
     if (config.provider === 'local' || config.provider.includes('local')) {
-      await syncToLocal(config, uploadDir, spinner);
+      await syncToLocal(config, uploadDir, spinner, { verifiedReplacement: encrypted, lockHeld: options.localLockHeld });
     } else if (config.provider === 'git' || config.provider.includes('git')) {
-      await syncToGit(config, uploadDir, spinner, preserveRemoteSession ? { preserve: ['session.json'] } : {});
+      await syncToGit(config, uploadDir, spinner, {
+        cloneDir: remoteCloneDir,
+        additive: !encrypted,
+      });
+      remoteCloneDir = null; // syncToGit removed it
     } else {
       spinner.fail(chalk.red(`Unknown provider: ${config.provider}`));
       return;
@@ -535,7 +533,7 @@ export async function pushCommand(options = {}) {
     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 bundleCount = workspaceManifest.projects.filter(p => p.bundleFile || p.type === 'files').length;
       const parts = [];
       if (gitCount > 0) parts.push(`${gitCount} git`);
       if (bundleCount > 0) parts.push(`${bundleCount} bundled`);
@@ -559,11 +557,16 @@ export async function pushCommand(options = {}) {
     }
   } catch (error) {
     spinner.fail(chalk.red('Sync failed: ') + error.message);
+    throw error;
   } finally {
+    if (remotePlainDir) await fs.remove(remotePlainDir).catch(() => {});
     await fs.remove(stagingDir);
     // Clean up encrypted dir if it was created
     if (encryptedDir) {
       await fs.remove(encryptedDir).catch(() => {});
     }
+    if (remoteCloneDir) {
+      await fs.remove(remoteCloneDir).catch(() => {});
+    }
   }
 }

package/src/commands/recall.js

@@ -0,0 +1,42 @@
+// `memoir recall <query>` — the same search the memoir_recall MCP tool runs,
+// from the terminal. Exists so a human can see exactly what their AI would
+// be handed for a question ("what would it see if it asked about X?"),
+// which is the fastest way to notice a memory that was never written, or
+// one that needs an `aliases:` line to be findable.
+
+import chalk from 'chalk';
+import { searchMemories } from '../memory/search.js';
+
+export async function recallCommand(query, options = {}) {
+  const q = String(query || '').trim();
+  if (!q) {
+    console.log(chalk.yellow('\nUsage: ') + chalk.cyan('memoir recall "what you want to find" [--limit N] [--json]\n'));
+    return;
+  }
+  const limit = Math.max(1, Math.min(50, parseInt(options.limit, 10) || 10));
+  const t0 = Date.now();
+  const res = await searchMemories(q, { limit, project: options.project });
+  const ms = Date.now() - t0;
+
+  if (options.json) {
+    console.log(JSON.stringify({ query: q, terms: res.terms, total: res.total, results: res.results }, null, 2));
+    return;
+  }
+
+  if (!res.results.length) {
+    console.log('\n' + chalk.yellow(`  No memories match "${q}"`) +
+      (res.terms.length ? chalk.gray(` (searched: ${res.terms.join(', ')})`) : '') + '\n');
+    return;
+  }
+
+  console.log('\n' + chalk.cyan.bold(`  ${res.total} match${res.total === 1 ? '' : 'es'} for "${q}"`) +
+    chalk.gray(` · top ${res.results.length} · ${ms}ms · terms: ${res.terms.join(', ')}`) + '\n');
+  res.results.forEach((r, i) => {
+    const cov = r.matched < res.terms.length ? chalk.gray(` · ${r.matched}/${res.terms.length} terms`) : '';
+    console.log(chalk.green(`  ${i + 1}. `) + chalk.white.bold(`${r.tool} / ${r.path}`) + cov);
+    const meta = [r.type, r.description].filter(Boolean).join(' · ');
+    if (meta) console.log(chalk.gray(`     ${meta}`));
+    for (const line of r.passage.split('\n')) console.log(chalk.white('     ' + line));
+    console.log('');
+  });
+}