synap 0.8.0 → 0.8.2

package/.claude/skills/synap-assistant/SKILL.md

@@ -409,36 +409,65 @@ View or update configuration.
 ```bash
 synap config                                 # Show all settings + paths
 synap config dataDir                         # Show data directory
-synap config dataDir ~/synap-data            # Set custom data directory
 synap config --reset                         # Reset to defaults
 ```
 
+#### `synap save`, `synap pull`, `synap sync`
+Git sync commands for multi-device workflow.
+
+```bash
+# Save (commit + push)
+synap save                                   # Commit + push with auto timestamp
+synap save "message"                         # Commit + push with custom message
+synap save -m "message"                      # Same as above
+synap save --dry-run                         # Preview changes without committing
+synap save --no-push                         # Commit locally, don't push
+
+# Pull
+synap pull                                   # Pull latest from remote
+synap pull --force                           # Pull even with uncommitted local changes
+
+# Sync (pull + save)
+synap sync                                   # Pull then save (full round-trip)
+synap sync "end of day"                      # Sync with custom commit message
+synap sync --dry-run                         # Preview what would happen
+synap sync --no-push                         # Pull and commit, but don't push
+```
+
+**Git sync error codes:**
+| Code | Meaning |
+|------|---------|
+| `NOT_GIT_REPO` | Data directory is not a git repository |
+| `DIRTY_WORKING_TREE` | Uncommitted changes block pull (use `--force`) |
+| `MERGE_CONFLICT` | Pull resulted in merge conflicts |
+| `NO_REMOTE` | No git remote configured |
+| `PUSH_FAILED` | Remote exists but push failed |
+
 ## Workflow Patterns
 
 ### Multi-Device Sync Setup
 
-For users who want to sync their synap across devices:
-
-1. **Set custom data directory:**
+1. **Set data directory:**
    ```bash
    synap config dataDir ~/synap-data
    ```
 
-2. **Initialize git (optional):**
+2. **Initialize git (one-time):**
    ```bash
-   cd ~/synap-data
+   cd $(synap config dataDir)
    git init
    git remote add origin git@github.com:user/synap-data.git
+   synap save "Initial commit"
    ```
 
-3. **Daily sync workflow:**
+3. **Daily workflow:**
    ```bash
-   cd ~/synap-data && git pull    # Start of day
-   # ... use synap normally ...
-   cd ~/synap-data && git add . && git commit -m "sync" && git push  # End of day
+   synap pull    # Start of day
+   synap save    # End of day
+   synap sync    # Or full round-trip
    ```
 
-4. **On a new device:**
+4. **New device:**
    ```bash
    git clone git@github.com:user/synap-data.git ~/synap-data
    synap config dataDir ~/synap-data
@@ -568,6 +597,13 @@ For projects requiring ongoing progress logging (standups, journals, learning lo
 4. **Confirm bulk operations** - Operations affecting >10 entries require confirmation
 5. **Don't over-organize** - Simple thoughts don't need tags, priorities, and parents
 
+**Git sync safety**:
+
+6. **Preview before sync** - Use `--dry-run` to preview changes before committing
+7. **Handle conflicts carefully** - `MERGE_CONFLICT` errors require manual resolution
+8. **Protect uncommitted work** - `pull` checks for dirty tree; use `--force` only when safe
+9. **Commit messages are safe** - Never executed as shell commands (stdin-based commit)
+
 ## Proactive Recommendation Patterns
 
 - If raw entries are piling up, suggest `synap triage`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synap",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "A CLI for externalizing your working memory",
   "main": "src/cli.js",
   "bin": {

package/src/cli.js

@@ -19,6 +19,11 @@ async function main() {
   const chalk = (await import('chalk')).default;
   const boxen = (await import('boxen')).default;
 
+  // Common requires used across commands
+  const { execSync, spawnSync } = require('child_process');
+  const os = require('os');
+  const path = require('path');
+
   // Check for updates (non-blocking)
   const updateNotifier = (await import('update-notifier')).default;
   updateNotifier({ pkg }).notify();
@@ -93,6 +98,81 @@ async function main() {
     return '(<1m)';
   };
 
+  // Helper: Check if data directory is a git repo
+  const isGitRepo = () => {
+    const path = require('path');
+    const gitDir = path.join(storage.getDataDir(), '.git');
+    return fs.existsSync(gitDir);
+  };
+
+  // Helper: Check if working tree has uncommitted changes
+  const isDirty = () => {
+    const dataDir = storage.getDataDir();
+    try {
+      execSync('git diff --quiet', { cwd: dataDir, stdio: 'pipe' });
+      execSync('git diff --cached --quiet', { cwd: dataDir, stdio: 'pipe' });
+      return false;
+    } catch {
+      return true;
+    }
+  };
+
+  // Helper: Check if there are merge conflicts (UU, AA, DD, etc.)
+  const hasConflicts = () => {
+    const dataDir = storage.getDataDir();
+    try {
+      const status = execSync('git status --porcelain', { cwd: dataDir, encoding: 'utf-8' });
+      const conflictPatterns = /^(UU|AA|DD|AU|UA|DU|UD) /m;
+      return conflictPatterns.test(status);
+    } catch {
+      return false;
+    }
+  };
+
+  // Helper: Get list of conflicted files
+  const getConflictFiles = () => {
+    const dataDir = storage.getDataDir();
+    try {
+      const status = execSync('git status --porcelain', { cwd: dataDir, encoding: 'utf-8' });
+      return status.split('\n')
+        .filter(line => /^(UU|AA|DD|AU|UA|DU|UD) /.test(line))
+        .map(line => line.slice(3).trim());
+    } catch {
+      return [];
+    }
+  };
+
+  // Helper: Check if git remote is configured
+  const hasRemote = () => {
+    const dataDir = storage.getDataDir();
+    try {
+      const remotes = execSync('git remote', { cwd: dataDir, encoding: 'utf-8' });
+      return remotes.trim().length > 0;
+    } catch {
+      return false;
+    }
+  };
+
+  // Helper: Get diff stats for preview without staging/unstaging
+  const getDiffStats = () => {
+    const dataDir = storage.getDataDir();
+    try {
+      const status = execSync('git status --porcelain', { cwd: dataDir, encoding: 'utf-8' });
+      if (!status.trim()) return '';
+
+      const unstaged = execSync('git diff --stat', { cwd: dataDir, encoding: 'utf-8' });
+      const untracked = status.split('\n').filter(l => l.startsWith('??')).length;
+
+      let result = unstaged.trim();
+      if (untracked > 0) {
+        result += `\n ${untracked} untracked file(s)`;
+      }
+      return result;
+    } catch {
+      return '';
+    }
+  };
+
   // ============================================
   // CAPTURE COMMANDS
   // ============================================
@@ -675,6 +755,7 @@ async function main() {
     .option('-s, --status <status>', 'Filter by status')
     .option('--not-type <type>', 'Exclude entries of this type')
     .option('--since <duration>', 'Only search recent entries')
+    .option('--include-archived', 'Include archived entries in search')
     .option('-n, --limit <n>', 'Max results', '20')
     .option('--json', 'Output as JSON')
     .action(async (queryParts, options) => {
@@ -684,6 +765,7 @@ async function main() {
         status: options.status,
         notType: options.notType,
         since: options.since,
+        includeArchived: options.includeArchived,
         limit: parseInt(options.limit, 10)
       });
 
@@ -748,11 +830,6 @@ async function main() {
 
       if (Object.keys(updates).length === 0) {
         // Interactive edit - open $EDITOR
-        const { execSync } = require('child_process');
-        const fs = require('fs');
-        const os = require('os');
-        const path = require('path');
-
         const tmpFile = path.join(os.tmpdir(), `synap-${entry.id.slice(0, 8)}.txt`);
         fs.writeFileSync(tmpFile, entry.content);
 
@@ -1780,8 +1857,6 @@ async function main() {
           }
 
           preferences.loadPreferences();
-          const { execSync } = require('child_process');
-          const fs = require('fs');
 
           const editor = config.editor || process.env.EDITOR || 'vi';
           const preferencesPath = preferences.getPreferencesPath();
@@ -2035,16 +2110,6 @@ async function main() {
       const os = require('os');
       const path = require('path');
 
-      let hasEntries = false;
-      if (fs.existsSync(storage.ENTRIES_FILE)) {
-        try {
-          const data = JSON.parse(fs.readFileSync(storage.ENTRIES_FILE, 'utf8'));
-          hasEntries = Array.isArray(data.entries) && data.entries.length > 0;
-        } catch {
-          hasEntries = false;
-        }
-      }
-
       let skillResult = { prompted: false };
       let dataLocationResult = { configured: false };
       
@@ -2070,7 +2135,7 @@ async function main() {
             message: 'Where should synap store your data?',
             choices: [
               { 
-                name: `Default (${path.join(os.homedir(), '.config', 'synap')})`, 
+                name: `Default (${storage.DATA_DIR})`, 
                 value: 'default',
                 description: 'Recommended for most users'
               },
@@ -2083,10 +2148,8 @@ async function main() {
           });
 
           if (dataChoice === 'custom') {
-            const defaultSuggestion = path.join(os.homedir(), 'synap-data');
             const customPath = await input({
               message: 'Enter path for synap data:',
-              default: defaultSuggestion,
               validate: (val) => {
                 if (!val.trim()) return 'Path is required';
                 const expanded = val.replace(/^~/, os.homedir());
@@ -2121,20 +2184,10 @@ async function main() {
           }
         }
 
-        // Step 2: Quick capture test
-        console.log('\n[2/4] Quick capture test...');
-        let createdEntry = null;
-        if (!hasEntries) {
-          createdEntry = await storage.addEntry({
-            content: 'My first thought',
-            type: config.defaultType || 'idea',
-            source: 'setup'
-          });
-          console.log(`      synap add "My first thought"`);
-          console.log(`      ${chalk.green('✓')} Created entry ${createdEntry.id.slice(0, 8)}`);
-        } else {
-          console.log(`      ${chalk.gray('Existing entries detected, skipping.')}`);
-        }
+        // Step 2: Quick capture example
+        console.log('\n[2/4] Quick capture...');
+        console.log(`      Try: ${chalk.cyan('synap add "My first thought"')}`);
+        console.log(`      ${chalk.green('✓')} Ready to capture`)
 
         // Step 3: Configuration
         console.log('\n[3/4] Configuration...');
@@ -2185,19 +2238,8 @@ async function main() {
       }
 
       // JSON mode - minimal interaction
-      let createdEntry = null;
-      if (!hasEntries) {
-        createdEntry = await storage.addEntry({
-          content: 'My first thought',
-          type: config.defaultType || 'idea',
-          source: 'setup'
-        });
-      }
-
       console.log(JSON.stringify({
         success: true,
-        mode: hasEntries ? 'existing' : 'first-run',
-        entry: createdEntry,
         config: { defaultType: config.defaultType || 'idea' },
         skill: {
           prompted: false,
@@ -2434,6 +2476,419 @@ async function main() {
       }
     });
 
+  // ============================================
+  // SYNC COMMANDS
+  // ============================================
+
+  program
+    .command('save [message...]')
+    .description('Commit and push synap data to git remote')
+    .option('-m, --message <message>', 'Commit message')
+    .option('--dry-run', 'Show what would be committed without committing')
+    .option('--no-push', 'Commit but do not push to remote')
+    .option('--json', 'Output as JSON')
+    .action(async (messageParts, options) => {
+      const dataDir = storage.getDataDir();
+
+      if (!isGitRepo()) {
+        if (options.json) {
+          console.log(JSON.stringify({
+            success: false,
+            error: 'Data directory is not a git repository',
+            code: 'NOT_GIT_REPO',
+            setup: [
+              `cd ${dataDir}`,
+              'git init',
+              'git remote add origin git@github.com:user/synap-data.git',
+              'synap save "Initial commit"'
+            ]
+          }, null, 2));
+        } else {
+          console.error(chalk.red('Data directory is not a git repository'));
+          console.log(chalk.gray('\nSetup git sync:'));
+          console.log(chalk.cyan(`  cd ${dataDir}`));
+          console.log(chalk.cyan('  git init'));
+          console.log(chalk.cyan('  git remote add origin git@github.com:user/synap-data.git'));
+          console.log(chalk.cyan('  synap save "Initial commit"'));
+        }
+        process.exit(1);
+      }
+
+      // Build commit message
+      let commitMessage = options.message;
+      if (!commitMessage && messageParts && messageParts.length > 0) {
+        commitMessage = messageParts.join(' ');
+      }
+      if (!commitMessage) {
+        const now = new Date();
+        const timestamp = now.toISOString().replace('T', ' ').slice(0, 16);
+        commitMessage = `synap sync ${timestamp}`;
+      }
+
+      // Dry-run mode: show preview only
+      if (options.dryRun) {
+        const stats = getDiffStats();
+        if (options.json) {
+          console.log(JSON.stringify({
+            success: true,
+            dryRun: true,
+            message: commitMessage,
+            changes: stats || 'No changes to commit'
+          }, null, 2));
+        } else {
+          console.log(chalk.cyan('Dry run - would commit with message:'));
+          console.log(chalk.yellow(`  "${commitMessage}"`));
+          if (stats) {
+            console.log(chalk.cyan('\nChanges:'));
+            console.log(stats);
+          } else {
+            console.log(chalk.yellow('No changes to commit'));
+          }
+        }
+        return;
+      }
+
+      try {
+        // Stage all changes
+        execSync('git add .', { cwd: dataDir, stdio: 'pipe' });
+
+        // Check if there are changes to commit
+        let hasChanges = true;
+        try {
+          execSync('git diff --cached --quiet', { cwd: dataDir, stdio: 'pipe' });
+          hasChanges = false;
+        } catch {
+          // Non-zero exit means there are staged changes
+          hasChanges = true;
+        }
+
+        if (!hasChanges) {
+          if (options.json) {
+            console.log(JSON.stringify({ success: true, message: 'Nothing to commit', pushed: false }));
+          } else {
+            console.log(chalk.yellow('Nothing to commit'));
+          }
+          return;
+        }
+
+        // Commit using stdin to prevent shell injection
+        const commitResult = spawnSync('git', ['commit', '-F', '-'], {
+          cwd: dataDir,
+          input: commitMessage,
+          encoding: 'utf-8',
+          stdio: ['pipe', 'pipe', 'pipe']
+        });
+
+        if (commitResult.status !== 0) {
+          throw new Error(commitResult.stderr || 'Commit failed');
+        }
+
+        // Push (unless --no-push flag)
+        let pushed = false;
+        let pushError = null;
+        let pushErrorCode = null;
+
+        if (options.push !== false) {
+          // Check if remote exists
+          if (!hasRemote()) {
+            pushError = 'No git remote configured';
+            pushErrorCode = 'NO_REMOTE';
+          } else {
+            try {
+              execSync('git push', { cwd: dataDir, stdio: 'pipe' });
+              pushed = true;
+            } catch (err) {
+              pushError = 'Push failed (check network or remote permissions)';
+              pushErrorCode = 'PUSH_FAILED';
+            }
+          }
+        } else {
+          pushError = 'Push skipped (--no-push flag)';
+        }
+
+        if (options.json) {
+          const result = {
+            success: true,
+            message: commitMessage,
+            pushed
+          };
+          if (pushError) result.pushError = pushError;
+          if (pushErrorCode) result.pushErrorCode = pushErrorCode;
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(chalk.green(`Committed: "${commitMessage}"`));
+          if (pushed) {
+            console.log(chalk.green('Pushed to remote'));
+          } else {
+            console.log(chalk.yellow(pushError));
+          }
+        }
+      } catch (err) {
+        if (options.json) {
+          console.log(JSON.stringify({ success: false, error: err.message, code: 'GIT_ERROR' }));
+        } else {
+          console.error(chalk.red(`Git error: ${err.message}`));
+        }
+        process.exit(1);
+      }
+    });
+
+  program
+    .command('pull')
+    .description('Pull latest synap data from git remote')
+    .option('--force', 'Pull even if there are uncommitted local changes')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      const dataDir = storage.getDataDir();
+
+      if (!isGitRepo()) {
+        if (options.json) {
+          console.log(JSON.stringify({
+            success: false,
+            error: 'Data directory is not a git repository',
+            code: 'NOT_GIT_REPO'
+          }, null, 2));
+        } else {
+          console.error(chalk.red('Data directory is not a git repository'));
+          console.log(chalk.gray('Run: synap save --help for setup instructions'));
+        }
+        process.exit(1);
+      }
+
+      // Check for uncommitted changes
+      if (isDirty() && !options.force) {
+        if (options.json) {
+          console.log(JSON.stringify({
+            success: false,
+            error: 'Working tree has uncommitted changes',
+            code: 'DIRTY_WORKING_TREE',
+            hint: 'Run `synap save` first or use `--force`'
+          }, null, 2));
+        } else {
+          console.error(chalk.red('Working tree has uncommitted changes'));
+          console.log(chalk.gray('Run `synap save` first or use `synap pull --force`'));
+        }
+        process.exit(1);
+      }
+
+      try {
+        const output = execSync('git pull', { cwd: dataDir, encoding: 'utf-8' });
+
+        if (options.json) {
+          console.log(JSON.stringify({
+            success: true,
+            message: output.trim() || 'Already up to date',
+            updated: !output.includes('Already up to date')
+          }, null, 2));
+        } else {
+          console.log(chalk.green(output.trim() || 'Already up to date'));
+        }
+      } catch (err) {
+        // Check for merge conflicts after failed pull
+        if (hasConflicts()) {
+          const conflictFiles = getConflictFiles();
+          if (options.json) {
+            console.log(JSON.stringify({
+              success: false,
+              error: 'Merge conflicts detected',
+              code: 'MERGE_CONFLICT',
+              conflictFiles,
+              hint: `Resolve conflicts: cd ${dataDir} && git status`
+            }, null, 2));
+          } else {
+            console.error(chalk.red('Merge conflicts detected'));
+            console.log(chalk.yellow('Conflicted files:'));
+            for (const file of conflictFiles) {
+              console.log(chalk.yellow(`  - ${file}`));
+            }
+            console.log(chalk.gray(`\nResolve conflicts: cd ${dataDir} && git status`));
+          }
+          process.exit(1);
+        }
+
+        if (options.json) {
+          console.log(JSON.stringify({ success: false, error: err.message, code: 'GIT_ERROR' }));
+        } else {
+          console.error(chalk.red(`Git error: ${err.message}`));
+        }
+        process.exit(1);
+      }
+    });
+
+  program
+    .command('sync [message...]')
+    .description('Pull latest, then commit and push (full round-trip)')
+    .option('-m, --message <message>', 'Commit message')
+    .option('--dry-run', 'Show what would be committed without committing')
+    .option('--no-push', 'Commit but do not push to remote')
+    .option('--json', 'Output as JSON')
+    .action(async (messageParts, options) => {
+      const dataDir = storage.getDataDir();
+
+      if (!isGitRepo()) {
+        if (options.json) {
+          console.log(JSON.stringify({
+            success: false,
+            error: 'Data directory is not a git repository',
+            code: 'NOT_GIT_REPO'
+          }, null, 2));
+        } else {
+          console.error(chalk.red('Data directory is not a git repository'));
+          console.log(chalk.gray('Run: synap save --help for setup instructions'));
+        }
+        process.exit(1);
+      }
+
+      // Build commit message
+      let commitMessage = options.message;
+      if (!commitMessage && messageParts && messageParts.length > 0) {
+        commitMessage = messageParts.join(' ');
+      }
+      if (!commitMessage) {
+        const now = new Date();
+        const timestamp = now.toISOString().replace('T', ' ').slice(0, 16);
+        commitMessage = `synap sync ${timestamp}`;
+      }
+
+      // Dry-run mode: show preview only
+      if (options.dryRun) {
+        const stats = getDiffStats();
+        if (options.json) {
+          console.log(JSON.stringify({
+            success: true,
+            dryRun: true,
+            message: commitMessage,
+            changes: stats || 'No changes to commit'
+          }, null, 2));
+        } else {
+          console.log(chalk.cyan('Dry run - would sync with message:'));
+          console.log(chalk.yellow(`  "${commitMessage}"`));
+          if (stats) {
+            console.log(chalk.cyan('\nLocal changes:'));
+            console.log(stats);
+          } else {
+            console.log(chalk.yellow('No local changes to commit'));
+          }
+        }
+        return;
+      }
+
+      const results = { pulled: false, committed: false, pushed: false, errors: [] };
+
+      // Pull first
+      try {
+        const pullOutput = execSync('git pull', { cwd: dataDir, encoding: 'utf-8' });
+        results.pulled = true;
+        results.pullMessage = pullOutput.trim() || 'Already up to date';
+      } catch (err) {
+        // Check for merge conflicts
+        if (hasConflicts()) {
+          const conflictFiles = getConflictFiles();
+          results.errors.push({
+            step: 'pull',
+            error: 'Merge conflicts detected',
+            code: 'MERGE_CONFLICT',
+            conflictFiles,
+            hint: `Resolve conflicts: cd ${dataDir} && git status`
+          });
+        } else {
+          results.errors.push({ step: 'pull', error: err.message, code: 'GIT_ERROR' });
+        }
+      }
+
+      // Stage and commit (only if pull succeeded)
+      if (results.pulled) {
+        try {
+          execSync('git add .', { cwd: dataDir, stdio: 'pipe' });
+
+          let hasChanges = true;
+          try {
+            execSync('git diff --cached --quiet', { cwd: dataDir, stdio: 'pipe' });
+            hasChanges = false;
+          } catch {
+            hasChanges = true;
+          }
+
+          if (hasChanges) {
+            // Commit using stdin to prevent shell injection
+            const commitResult = spawnSync('git', ['commit', '-F', '-'], {
+              cwd: dataDir,
+              input: commitMessage,
+              encoding: 'utf-8',
+              stdio: ['pipe', 'pipe', 'pipe']
+            });
+
+            if (commitResult.status !== 0) {
+              throw new Error(commitResult.stderr || 'Commit failed');
+            }
+
+            results.committed = true;
+            results.commitMessage = commitMessage;
+          } else {
+            results.commitMessage = 'Nothing to commit';
+          }
+        } catch (err) {
+          results.errors.push({ step: 'commit', error: err.message, code: 'GIT_ERROR' });
+        }
+      }
+
+      // Push (unless --no-push flag or nothing committed)
+      if (results.committed && options.push !== false) {
+        if (!hasRemote()) {
+          results.errors.push({ step: 'push', error: 'No git remote configured', code: 'NO_REMOTE' });
+        } else {
+          try {
+            execSync('git push', { cwd: dataDir, stdio: 'pipe' });
+            results.pushed = true;
+          } catch (err) {
+            results.errors.push({ step: 'push', error: 'Push failed (check network or remote permissions)', code: 'PUSH_FAILED' });
+          }
+        }
+      } else if (results.committed && options.push === false) {
+        results.pushSkipped = true;
+      }
+
+      if (options.json) {
+        console.log(JSON.stringify({
+          success: results.errors.length === 0,
+          ...results
+        }, null, 2));
+      } else {
+        if (results.pulled) {
+          console.log(chalk.green(`Pulled: ${results.pullMessage}`));
+        }
+        if (results.committed) {
+          console.log(chalk.green(`Committed: "${results.commitMessage}"`));
+        } else if (results.pullMessage !== 'Already up to date' || !results.pulled) {
+          console.log(chalk.yellow(results.commitMessage || 'Nothing to commit'));
+        }
+        if (results.pushed) {
+          console.log(chalk.green('Pushed to remote'));
+        } else if (results.pushSkipped) {
+          console.log(chalk.yellow('Push skipped (--no-push flag)'));
+        } else if (results.committed) {
+          const pushErr = results.errors.find(e => e.step === 'push');
+          console.log(chalk.yellow(pushErr ? pushErr.error : 'Push failed'));
+        }
+        for (const err of results.errors) {
+          if (err.step !== 'push' || !results.committed) {
+            console.error(chalk.red(`${err.step}: ${err.error}`));
+          }
+          if (err.conflictFiles) {
+            console.log(chalk.yellow('Conflicted files:'));
+            for (const file of err.conflictFiles) {
+              console.log(chalk.yellow(`  - ${file}`));
+            }
+            console.log(chalk.gray(`\n${err.hint}`));
+          }
+        }
+      }
+
+      if (results.errors.length > 0) {
+        process.exit(1);
+      }
+    });
+
   // Parse and execute
   await program.parseAsync(process.argv);
 }

package/src/deletion-log.js

@@ -8,6 +8,8 @@ const fs = require('fs');
 const path = require('path');
 const storage = require('./storage');
 
+const MAX_DELETION_LOG_ENTRIES = 1000;
+
 /**
  * Get deletion log file path (dynamic, based on DATA_DIR)
  */
@@ -73,9 +75,9 @@ async function logDeletions(entries) {
     });
   }
 
-  // Keep last 1000 deletions
-  if (log.length > 1000) {
-    log.length = 1000;
+  // Keep last N deletions
+  if (log.length > MAX_DELETION_LOG_ENTRIES) {
+    log.length = MAX_DELETION_LOG_ENTRIES;
   }
 
   saveLog(log);

package/src/storage.js

@@ -127,9 +127,10 @@ const VALID_DATE_FORMATS = ['relative', 'absolute', 'locale'];
 
 /**
  * Atomic file write - write to temp file then rename
+ * Uses PID + timestamp to avoid race conditions between processes
  */
 function atomicWriteSync(filePath, data) {
-  const tmpPath = filePath + '.tmp';
+  const tmpPath = `${filePath}.tmp.${process.pid}.${Date.now()}`;
   fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
   fs.renameSync(tmpPath, filePath);
 }
@@ -144,7 +145,9 @@ function loadEntries() {
   }
   try {
     return JSON.parse(fs.readFileSync(ENTRIES_FILE, 'utf8'));
-  } catch {
+  } catch (err) {
+    console.error(`Warning: entries.json is corrupted: ${err.message}`);
+    console.error(`File location: ${ENTRIES_FILE}`);
     return { version: 1, entries: [] };
   }
 }
@@ -167,7 +170,9 @@ function loadArchive() {
   }
   try {
     return JSON.parse(fs.readFileSync(ARCHIVE_FILE, 'utf8'));
-  } catch {
+  } catch (err) {
+    console.error(`Warning: archive.json is corrupted: ${err.message}`);
+    console.error(`File location: ${ARCHIVE_FILE}`);
     return { version: 1, entries: [] };
   }
 }
@@ -422,15 +427,13 @@ function parseDate(input) {
 }
 
 /**
- * Add a new entry
+ * Create an entry object from options (shared by addEntry and addEntries)
  */
-async function addEntry(options) {
-  const data = loadEntries();
-
+function createEntry(options, existingEntries, timestamp) {
   // Resolve partial parent ID to full ID
   let parentId = options.parent;
   if (parentId) {
-    const parentEntry = data.entries.find(e => e.id.startsWith(parentId));
+    const parentEntry = existingEntries.find(e => e.id.startsWith(parentId));
     if (parentEntry) {
       parentId = parentEntry.id;
     }
@@ -446,7 +449,6 @@ async function addEntry(options) {
     }
   }
 
-  const now = new Date().toISOString();
   const entry = {
     id: uuidv4(),
     content: options.content,
@@ -458,8 +460,8 @@ async function addEntry(options) {
     parent: parentId || undefined,
     related: [],
     due: dueDate,
-    createdAt: now,
-    updatedAt: now,
+    createdAt: timestamp,
+    updatedAt: timestamp,
     source: options.source || 'cli'
   };
 
@@ -468,6 +470,17 @@ async function addEntry(options) {
     if (entry[key] === undefined) delete entry[key];
   });
 
+  return entry;
+}
+
+/**
+ * Add a new entry
+ */
+async function addEntry(options) {
+  const data = loadEntries();
+  const now = new Date().toISOString();
+  const entry = createEntry(options, data.entries, now);
+
   data.entries.push(entry);
   saveEntries(data);
 
@@ -485,46 +498,7 @@ async function addEntries(entriesData) {
   const now = new Date().toISOString();
 
   for (const options of entriesData) {
-    // Resolve partial parent ID to full ID
-    let parentId = options.parent;
-    if (parentId) {
-      const parentEntry = data.entries.find(e => e.id.startsWith(parentId));
-      if (parentEntry) {
-        parentId = parentEntry.id;
-      }
-    }
-
-    // Parse due date if provided
-    let dueDate = undefined;
-    const dueInput = typeof options.due === 'string' ? options.due.trim() : options.due;
-    if (dueInput) {
-      dueDate = parseDate(dueInput);
-      if (!dueDate) {
-        throw new Error(`Invalid due date: ${options.due}`);
-      }
-    }
-
-    const entry = {
-      id: uuidv4(),
-      content: options.content,
-      title: options.title || extractTitle(options.content),
-      type: VALID_TYPES.includes(options.type) ? options.type : 'idea',
-      status: VALID_STATUSES.includes(options.status) ? options.status : (options.priority ? 'active' : 'raw'),
-      priority: options.priority && [1, 2, 3].includes(options.priority) ? options.priority : undefined,
-      tags: options.tags || [],
-      parent: parentId || undefined,
-      related: [],
-      due: dueDate,
-      createdAt: now,
-      updatedAt: now,
-      source: options.source || 'cli'
-    };
-
-    // Clean up undefined fields
-    Object.keys(entry).forEach(key => {
-      if (entry[key] === undefined) delete entry[key];
-    });
-
+    const entry = createEntry(options, data.entries, now);
     data.entries.push(entry);
     created.push(entry);
   }
@@ -552,9 +526,15 @@ async function getEntry(id) {
   let entry = data.entries.find(e => e.id === id);
   if (entry) return entry;
 
-  // Try partial match (first 8 chars)
+  // Try partial match
   const matches = data.entries.filter(e => e.id.startsWith(id));
   if (matches.length === 1) return matches[0];
+  if (matches.length > 1) {
+    const error = new Error(`Ambiguous ID: ${id} matches ${matches.length} entries`);
+    error.code = 'AMBIGUOUS_ID';
+    error.matches = matches.map(e => ({ id: e.id, title: e.title }));
+    throw error;
+  }
 
   // Check archive
   const archive = loadArchive();
@@ -563,6 +543,12 @@ async function getEntry(id) {
 
   const archiveMatches = archive.entries.filter(e => e.id.startsWith(id));
   if (archiveMatches.length === 1) return archiveMatches[0];
+  if (archiveMatches.length > 1) {
+    const error = new Error(`Ambiguous ID: ${id} matches ${archiveMatches.length} archived entries`);
+    error.code = 'AMBIGUOUS_ID';
+    error.matches = archiveMatches.map(e => ({ id: e.id, title: e.title }));
+    throw error;
+  }
 
   return null;
 }
@@ -584,8 +570,7 @@ async function getEntriesByIds(ids) {
  */
 async function getChildren(parentId) {
   const data = loadEntries();
-  // Match if parent starts with the given ID OR if the given ID starts with parent
-  return data.entries.filter(e => e.parent && (e.parent.startsWith(parentId) || parentId.startsWith(e.parent)));
+  return data.entries.filter(e => e.parent && e.parent.startsWith(parentId));
 }
 
 /**
@@ -764,6 +749,12 @@ async function searchEntries(query, options = {}) {
   const data = loadEntries();
   let entries = [...data.entries];
 
+  // Include archived entries if requested
+  if (options.includeArchived) {
+    const archive = loadArchive();
+    entries = [...entries, ...archive.entries];
+  }
+
   const lowerQuery = query.toLowerCase();
 
   // Text search (content, title, and tags)
@@ -1006,6 +997,7 @@ async function renameTag(oldTag, newTag) {
     const idx = entry.tags.indexOf(oldTag);
     if (idx !== -1) {
       entry.tags[idx] = newTag;
+      entry.tags = [...new Set(entry.tags)];
       entry.updatedAt = new Date().toISOString();
       count++;
     }
@@ -1015,6 +1007,7 @@ async function renameTag(oldTag, newTag) {
     const idx = entry.tags.indexOf(oldTag);
     if (idx !== -1) {
       entry.tags[idx] = newTag;
+      entry.tags = [...new Set(entry.tags)];
       entry.updatedAt = new Date().toISOString();
       count++;
     }
@@ -1091,8 +1084,17 @@ async function importEntries(entries, options = {}) {
   const data = loadEntries();
   let added = 0;
   let updated = 0;
+  let skipped = 0;
 
   for (const entry of entries) {
+    // Validate required fields
+    if (!entry.id || typeof entry.id !== 'string' ||
+        !entry.content || typeof entry.content !== 'string' ||
+        !entry.createdAt || typeof entry.createdAt !== 'string') {
+      skipped++;
+      continue;
+    }
+
     const existing = data.entries.find(e => e.id === entry.id);
 
     if (existing) {
@@ -1109,7 +1111,7 @@ async function importEntries(entries, options = {}) {
 
   saveEntries(data);
 
-  return { added, updated };
+  return { added, updated, skipped };
 }
 
 module.exports = {