promptcase 1.0.4 → 1.0.6

package/README.md

@@ -2,6 +2,8 @@
 
 A background daemon that captures AI prompts you send to Claude Code and syncs them to your [PromptCase](https://promptcase.app) account for later search, tagging, and organisation.
 
+> Install once, authenticate once, then forget. The daemon runs in the background and syncs your prompts every minute.
+
 ## Install
 
 ```bash
@@ -26,18 +28,35 @@ promptcase sync
 promptcase show
 ```
 
-The daemon runs in the background and auto-starts on system boot (LaunchAgent on macOS, user-level systemd on Linux, Startup folder on Windows).
+The daemon auto-starts on login/boot and runs in the background.
 
 ## Commands
 
 | Command | Description |
 | --- | --- |
-| `promptcase init` | Authenticate and start the daemon |
-| `promptcase status` | Show auth, daemon, and auto-start status |
+| `promptcase init` | Authenticate and (re)start the daemon |
+| `promptcase status` | Show auth, daemon, lifetime sync counter, and auto-start status |
 | `promptcase sync` | Force a sync and run diagnostics |
 | `promptcase show` | Show recent synced prompts |
-| `promptcase stop` | Stop the running daemon (auto-start preserved) |
+| `promptcase stop` | Stop the running daemon (auto-start is preserved for next boot) |
 | `promptcase logout` | Stop daemon, revoke token, clear credentials |
+| `promptcase start` | **Internal** — run the daemon in the foreground. Invoked by the auto-start service (LaunchAgent / systemd / Startup folder). You don't normally need to run this directly. |
+
+## How it works
+
+1. **`promptcase init`** authenticates with your PromptCase account and spawns a single background daemon.
+2. The daemon captures prompts from `~/.claude/projects/` and `~/.claude/history.jsonl`.
+3. Every 60 seconds it uploads new prompts to your account.
+4. The server deduplicates by content hash, so re-syncing the same prompt is safe.
+5. **One daemon at a time** is guaranteed by an exclusive `mkdir`-based lock — you can't accidentally start a second one.
+
+### Auto-start
+
+Auto-start is installed by `init` and survives reboot:
+
+- **macOS** — LaunchAgent at `~/Library/LaunchAgents/app.promptcase.daemon.plist` (uses `RunAtLoad=true`)
+- **Linux** — user-level systemd service at `~/.config/systemd/user/promptcase.service` (run `systemctl --user enable promptcase` to enable)
+- **Windows** — `.bat` in the Startup folder (runs on next user login)
 
 ## Non-interactive authentication
 
@@ -49,19 +68,36 @@ echo '{"access_token":"...","refresh_token":"...","expires_in":15552000}' | prom
 
 ## Configuration
 
-Config and credentials are stored in `~/.promptcase/`. Logs:
+| Path | Purpose |
+| --- | --- |
+| `~/.promptcase/daemon.pid` | Current daemon PID |
+| `~/.promptcase/daemon.pid.lock/` | Single-instance lock directory (created on first start) |
+| `~/.promptcase/daemon.log` | Daemon stdout |
+| `~/.promptcase/daemon.error.log` | Daemon stderr |
+| `~/Library/Preferences/promptcase-nodejs/config.json` (macOS) | Credentials + sync state (managed by `conf`) |
+| `%APPDATA%/promptcase-nodejs/config.json` (Windows) | Same, on Windows |
+| `~/.config/configstore/promptcase-nodejs.json` (Linux) | Same, on Linux |
+
+## Lifecycle
 
-- `~/.promptcase/daemon.log` (stdout)
-- `~/.promptcase/daemon.error.log` (stderr)
+- `promptcase stop` — kills the daemon. Auto-start plist stays, so the daemon resumes on next boot. Run `promptcase init` to start it again without rebooting.
+- `promptcase logout` — kills the daemon AND removes your stored credentials.
 
 ## Troubleshooting
 
 ```bash
-promptcase status   # overall health
-promptcase sync     # diagnose and force a refresh
-promptcase logout && promptcase init   # reset credentials
+promptcase status    # overall health, lifetime count, lock state
+promptcase sync      # force a sync right now
+promptcase stop && promptcase init   # full daemon restart
+promptcase logout && promptcase init  # re-authenticate from scratch
 ```
 
+If `promptcase status` warns about multiple daemons running, run `promptcase stop` and wait a few seconds.
+
+## Privacy
+
+The daemon only reads `~/.claude/` (Claude Code's local data directory). It sends each prompt's content and metadata (timestamp, project path) to the PromptCase server over HTTPS. No other files are accessed.
+
 ## License
 
-MIT
+MIT

package/dist/commands/init.js

@@ -8,6 +8,9 @@
 import inquirer from 'inquirer';
 import { Command } from 'commander';
 import { exec, spawn } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
 import { APIService } from '../services/api.js';
 import { DaemonService } from '../services/daemon.js';
 import { getConfig } from '../lib/config.js';
@@ -89,6 +92,15 @@ async function verifyAndShowUser(api) {
 }
 /**
  * Start daemon in detached background process
+ *
+ * Polls for the lock dir to appear (the daemon writes the lock as soon as it
+ * finishes starting). This avoids the previous 1500ms fixed wait that would
+ * give false "Daemon may not have started" warnings on slow machines where
+ * Node + module load + lock acquisition took longer than 1500ms — the daemon
+ * would actually be running, but the parent had already given up and
+ * returned, leaving the user to think the spawn failed. The 1500ms was a
+ * too-tight deadline and the real signal is "lock dir exists" which means
+ * "daemon is fully initialized".
  */
 async function startDaemonDetached(apiUrl) {
     // Detach the daemon process so it runs independently
@@ -98,12 +110,21 @@ async function startDaemonDetached(apiUrl) {
         windowsHide: true,
     });
     child.unref();
-    // Give it a moment to start
-    await new Promise(resolve => setTimeout(resolve, 1500));
-    // Verify it started
-    const daemon = new DaemonService(apiUrl);
-    const isRunning = await daemon.isRunning();
-    if (isRunning) {
+    // Poll for the lock to appear. The daemon writes the lock dir as the
+    // first step of its lifecycle, so seeing it is a reliable "running" signal.
+    // Cap at 10 seconds — if the lock hasn't appeared by then, the daemon
+    // process must have died.
+    const lockPath = path.join(os.homedir(), '.promptcase', 'daemon.pid.lock');
+    const deadline = Date.now() + 10_000;
+    let acquired = false;
+    while (Date.now() < deadline) {
+        if (fs.existsSync(lockPath)) {
+            acquired = true;
+            break;
+        }
+        await new Promise(resolve => setTimeout(resolve, 200));
+    }
+    if (acquired) {
         console.log('   ✅ Daemon started in background');
     }
     else {
@@ -249,6 +270,18 @@ export async function initFlow(apiUrl = DEFAULT_API_URL) {
         const autoStartSuccess = await daemon.setupAutoStart();
         if (autoStartSuccess) {
             console.log('   ✅ Auto-start configured');
+            // Re-enable in case it was previously disabled via bootout. Required
+            // because `launchctl bootout` leaves the service disabled across
+            // sessions; without re-enabling, the daemon won't survive reboot.
+            if (process.platform === 'darwin') {
+                try {
+                    const { execFileSync } = await import('child_process');
+                    execFileSync('launchctl', ['enable', `gui/${process.getuid?.() ?? ''}/app.promptcase.daemon`], { stdio: 'ignore' });
+                }
+                catch {
+                    // Best effort — keep going
+                }
+            }
         }
         else {
             console.log('   ⚠️  Auto-start setup failed');

package/dist/commands/status.js

@@ -5,10 +5,47 @@ import { Command } from 'commander';
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import { execFileSync } from 'child_process';
 import { APIService } from '../services/api.js';
 import { DaemonService } from '../services/daemon.js';
 import { getConfig } from '../lib/config.js';
 import { DEFAULT_API_URL } from '../lib/constants.js';
+/**
+ * Count `PromptCase Daemon` processes currently running. This is a
+ * defense-in-depth check for the duplicate-sync bug — if more than one
+ * daemon is alive, every sync loop duplicates work for the same user.
+ */
+function countDaemonProcesses() {
+    try {
+        if (process.platform === 'win32') {
+            // tasklist: count lines containing "node.exe" in process list
+            const out = execFileSync('tasklist', ['/FI', 'IMAGENAME eq node.exe'], {
+                encoding: 'utf-8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            return out.split('\n').filter((l) => /node\.exe/i.test(l)).length;
+        }
+        // macOS / Linux: pgrep matches "PromptCase Daemon" process title.
+        // Falls back to scanning "node ...promptcase" lines if pgrep missing.
+        try {
+            const out = execFileSync('pgrep', ['-f', 'PromptCase Daemon'], {
+                encoding: 'utf-8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            return out.trim().split('\n').filter(Boolean).length;
+        }
+        catch {
+            const out = execFileSync('ps', ['-A', '-o', 'command='], {
+                encoding: 'utf-8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            return out.split('\n').filter((l) => /node.*promptcase.*start/.test(l) || /PromptCase Daemon/.test(l)).length;
+        }
+    }
+    catch {
+        return -1; // unknown
+    }
+}
 export function createStatusCommand(apiUrl = DEFAULT_API_URL) {
     const command = new Command('status');
     command
@@ -78,6 +115,15 @@ export function createStatusCommand(apiUrl = DEFAULT_API_URL) {
                 const nextSyncDate = new Date(daemonStatus.nextSyncAt);
                 console.log(`   Next sync:      ${nextSyncDate.toLocaleString()}`);
             }
+            // Defense in depth: warn if the system shows >1 daemon running,
+            // even when our lock-based `isRunning()` says one is alive. This
+            // catches the case where another daemon was spawned manually.
+            const count = countDaemonProcesses();
+            if (count > 1) {
+                console.log(`\n   ⚠️  ${count} promptcase daemons are running.`);
+                console.log('      Run `promptcase stop` and `promptcase init` to clean up.');
+                console.log('      Multiple daemons will sync the same prompts, causing duplicates.');
+            }
         }
         else {
             console.log('   Status:         🔴 Not running');

package/dist/commands/stop.js

@@ -1,42 +1,129 @@
 /**
- * Stop command - Stop daemon for this OS session
+ * Stop command - Stop the daemon process
  *
  * Behavior:
- * - Stops the daemon process if running
- * - Keeps auto-start configuration intact so daemon restarts on next boot
+ * - Signals the live daemon to exit (sends SIGTERM/SIGINT, not just file cleanup)
+ * - Cleans up lock + PID files so a subsequent `init` can re-acquire the lock
+ * - Auto-start plist stays in place — daemon will re-spawn on next boot
  */
 import { Command } from 'commander';
+import { execFile } from 'child_process';
+import fs from 'fs';
+import path from 'path';
 import { DaemonService } from '../services/daemon.js';
 import { DEFAULT_API_URL } from '../lib/constants.js';
+/**
+ * Read the live daemon's PID from either the PID file or the lock dir.
+ * Returns null if no daemon is running.
+ */
+function readLiveDaemonPid() {
+    const candidates = [
+        path.join(process.env.HOME || '', '.promptcase', 'daemon.pid'),
+        path.join(process.env.HOME || '', '.promptcase', 'daemon.pid.lock', 'pid'),
+    ];
+    for (const file of candidates) {
+        try {
+            const content = fs.readFileSync(file, 'utf-8').trim();
+            const pid = parseInt(content, 10);
+            if (!Number.isNaN(pid) && pid > 0)
+                return pid;
+        }
+        catch {
+            // Try next
+        }
+    }
+    return null;
+}
+/**
+ * Signal a process to exit gracefully. Falls back to SIGKILL if it refuses.
+ * Returns true if the process exited within `timeoutMs`, false otherwise.
+ */
+function signalProcess(pid, timeoutMs = 5000) {
+    return new Promise((resolve) => {
+        if (process.platform === 'win32') {
+            // taskkill /F /PID to terminate; on Windows SIGTERM is emulated
+            execFile('taskkill', ['/F', '/PID', String(pid)], () => resolve(true));
+            return;
+        }
+        try {
+            process.kill(pid, 'SIGTERM');
+        }
+        catch {
+            resolve(true);
+            return;
+        }
+        const start = Date.now();
+        const poll = setInterval(() => {
+            try {
+                process.kill(pid, 0); // probe
+                if (Date.now() - start > timeoutMs) {
+                    // Force-kill
+                    try {
+                        process.kill(pid, 'SIGKILL');
+                    }
+                    catch { }
+                    clearInterval(poll);
+                    resolve(true);
+                }
+            }
+            catch {
+                // Process is gone
+                clearInterval(poll);
+                resolve(true);
+            }
+        }, 200);
+        // Hard ceiling
+        setTimeout(() => {
+            clearInterval(poll);
+            try {
+                process.kill(pid, 0);
+                try {
+                    process.kill(pid, 'SIGKILL');
+                }
+                catch { }
+                resolve(false);
+            }
+            catch {
+                resolve(true);
+            }
+        }, timeoutMs + 1500);
+    });
+}
 export function createStopCommand(apiUrl = DEFAULT_API_URL) {
     const command = new Command('stop');
     command
-        .description('Stop the daemon for this OS session (auto-start on next boot preserved)')
+        .description('Stop the daemon process (auto-start survives for next boot)')
         .action(async () => {
         const daemon = new DaemonService(apiUrl);
         console.log('\n🛑 Stopping PromptCase Daemon\n');
-        const isRunning = await daemon.isRunning();
-        if (!isRunning) {
+        // Check what we know about the daemon state
+        const fileStateAlive = await daemon.isRunning();
+        const livePid = readLiveDaemonPid();
+        if (!fileStateAlive && !livePid) {
             console.log('   Daemon is not running.\n');
             return;
         }
-        const success = await daemon.stop();
-        if (success) {
+        // Clean up files (lock, PID file, status)
+        // This is safe to do regardless of whether the process exits — the
+        // daemon's own SIGTERM handler will also clean these.
+        const fileSuccess = await daemon.stop();
+        // Actually kill the live daemon process if there is one
+        let processExited = true;
+        if (livePid && livePid !== process.pid) {
+            processExited = await signalProcess(livePid);
+        }
+        if (processExited && fileSuccess) {
             console.log('   ✅ Daemon stopped successfully');
-            console.log('   ℹ️  Auto-start is still configured. Daemon will restart on next boot.');
+        }
+        else if (!processExited) {
+            console.log('   ⚠️  Daemon did not stop gracefully — sending SIGKILL next time');
+            console.log('      Run: kill -9 ' + livePid);
         }
         else {
-            console.log('   ⚠️  Could not stop daemon gracefully. Kill the process manually:');
-            if (process.platform === 'win32') {
-                console.log('      taskkill /F /IM node.exe');
-            }
-            else {
-                console.log('      pkill -f "promptcase start"');
-            }
+            console.log('   ⚠️  Some cleanup failed. Check "promptcase status".');
         }
-        console.log('\n   Auto-start preserved. To completely remove auto-start, run:');
-        console.log('     promptcase logout');
-        console.log('   Or manually remove the LaunchAgent / systemd service / .bat file.\n');
+        console.log('   ℹ️  Auto-start is still configured. Daemon will re-launch after reboot.');
+        console.log('   ℹ️  Run "promptcase init" to start the daemon now without rebooting.\n');
     });
     return command;
 }

package/dist/commands/sync.js

@@ -48,6 +48,7 @@ export function createSyncCommand(apiUrl = DEFAULT_API_URL) {
             const daemonStatus = await config.getDaemonStatus();
             console.log(`      Status: Running (PID ${daemonStatus.pid})`);
             console.log(`      Last sync: ${daemonStatus.lastSyncAt ? new Date(daemonStatus.lastSyncAt).toLocaleString() : 'Never'}`);
+            console.log('      ℹ️  Daemon is already running — will defer to its 60s loop instead of double-uploading');
         }
         else {
             console.log('      Status: Not running');
@@ -64,16 +65,24 @@ export function createSyncCommand(apiUrl = DEFAULT_API_URL) {
             console.log('      ⚠️  Claude Code not installed (~/.claude not found)');
             console.log('      Nothing to capture until Claude Code is installed and used.');
         }
-        // 5. Perform sync
-        console.log('\n   🔄 Triggering sync...');
-        const initialized = await daemon.initialize();
-        if (!initialized) {
-            console.log('   ❌ Failed to initialize daemon');
-            return;
+        // 5. Perform sync (only if no daemon is running). When the daemon is
+        // alive, its own 60s loop will pick up any new prompts — running a
+        // second sync here would race with it and cause duplicate uploads.
+        let status = null;
+        if (isRunning) {
+            console.log('\n   🔄 Skipping foreground sync — daemon handles it');
+        }
+        else {
+            console.log('\n   🔄 Triggering sync...');
+            const initialized = await daemon.initialize();
+            if (!initialized) {
+                console.log('   ❌ Failed to initialize daemon');
+                return;
+            }
+            status = await daemon.sync();
         }
-        const status = await daemon.sync();
         console.log('\n   📈 Results:');
-        if (status.lastSyncAt) {
+        if (status && status.lastSyncAt) {
             console.log(`      Last sync: ${status.lastSyncAt.toLocaleString()}`);
             console.log(`      Total synced (lifetime): ${status.promptsSynced} prompts`);
             if (status.errors.length > 0) {
@@ -81,6 +90,13 @@ export function createSyncCommand(apiUrl = DEFAULT_API_URL) {
                 status.errors.slice(-3).forEach((err) => console.log(`         - ${err}`));
             }
         }
+        else if (isRunning) {
+            // Deferred to daemon — show its status instead
+            const daemonStatus = await config.getDaemonStatus();
+            console.log(`      Daemon is alive (PID ${daemonStatus.pid})`);
+            console.log(`      Last sync: ${daemonStatus.lastSyncAt ? new Date(daemonStatus.lastSyncAt).toLocaleString() : 'Never'}`);
+            console.log(`      Total synced: ${daemonStatus.promptsSynced ?? 0} prompts (lifetime)`);
+        }
         // 6. If daemon is not running, start it
         if (!isRunning) {
             console.log('\n   🚀 Daemon was not running. Starting now in background...');

package/dist/services/daemon.js

@@ -40,27 +40,39 @@ export class DaemonService {
         return path.join(configDir, 'daemon.pid');
     }
     /**
-     * Check if daemon is already running
+     * Check if daemon is already running.
+     *
+     * Uses the lock directory as the authoritative check — the lock is the
+     * actual mutual exclusion mechanism. If a live process holds the lock,
+     * the daemon is running.
      */
     async isRunning() {
-        if (!fs.existsSync(this.pidFile)) {
+        const lockDir = this.pidFile + '.lock';
+        if (!fs.existsSync(lockDir)) {
             return false;
         }
         try {
-            const pid = parseInt(fs.readFileSync(this.pidFile, 'utf-8').trim(), 10);
-            // On Unix, check if process exists
+            // Read the PID of the holding process
+            const otherPid = parseInt(fs.readFileSync(path.join(lockDir, 'pid'), 'utf-8').trim(), 10);
+            if (Number.isNaN(otherPid) || otherPid === process.pid) {
+                return false;
+            }
+            // On Unix, probe the process with kill(pid, 0)
             if (process.platform !== 'win32') {
                 try {
-                    process.kill(pid, 0);
+                    process.kill(otherPid, 0);
                     return true;
                 }
                 catch {
-                    // Process doesn't exist
-                    await this.cleanupPidFile();
+                    // Lock holder is dead — clean up stale lock
+                    try {
+                        fs.rmSync(lockDir, { recursive: true, force: true });
+                    }
+                    catch { }
                     return false;
                 }
             }
-            // On Windows, just check if PID file exists
+            // On Windows: lock exists AND pid was readable — assume alive
             return true;
         }
         catch {
@@ -85,6 +97,92 @@ export class DaemonService {
             fs.unlinkSync(this.pidFile);
         }
     }
+    /**
+     * Acquire an exclusive lock for this daemon instance.
+     *
+     * Uses POSIX-atomic `mkdir` as a cross-platform mutex. Two daemons racing
+     * to start will both try to `mkdir` the same directory; the kernel
+     * guarantees only one succeeds, the other gets EEXIST and exits cleanly.
+     *
+     * This is what prevents the duplicate-sync bug: only one daemon can hold
+     * the lock at a time. The lock directory contains a file with the
+     * current PID for diagnostics.
+     *
+     * On Windows, mkdir also fails if the directory exists, so the same
+     * pattern works there too.
+     */
+    async acquireExclusiveLock() {
+        try {
+            const lockDir = this.pidFile + '.lock';
+            // Ensure the parent dir exists before we try to mkdir the lock inside
+            // it. Without this, the very first run on a clean machine gets ENOENT
+            // because ~/.promptcase/ doesn't exist yet (writePidFile creates it
+            // later, but only if it gets to run).
+            const parentDir = path.dirname(lockDir);
+            if (!fs.existsSync(parentDir)) {
+                fs.mkdirSync(parentDir, { recursive: true });
+            }
+            try {
+                fs.mkdirSync(lockDir);
+                // We won the race — write our PID into the lock dir for diagnostics
+                fs.writeFileSync(path.join(lockDir, 'pid'), process.pid.toString());
+                return true;
+            }
+            catch (err) {
+                if (err.code === 'EEXIST') {
+                    // Another daemon holds the lock. Check if it's actually alive
+                    // by reading the pid file inside.
+                    try {
+                        const otherPid = parseInt(fs.readFileSync(path.join(lockDir, 'pid'), 'utf-8').trim(), 10);
+                        if (otherPid === process.pid) {
+                            // We somehow already hold the lock (shouldn't happen,
+                            // but guard against it). Allow start.
+                            return true;
+                        }
+                        // Probe whether the other process still exists
+                        try {
+                            process.kill(otherPid, 0);
+                            // Yes, another daemon is alive. Refuse.
+                            return false;
+                        }
+                        catch {
+                            // Stale lock — the holding process is dead. Clean it up
+                            // and retry once.
+                            fs.rmSync(lockDir, { recursive: true, force: true });
+                            return this.acquireExclusiveLock();
+                        }
+                    }
+                    catch {
+                        // Lock dir exists but we can't read the pid file. Treat as
+                        // stale and force-replace.
+                        try {
+                            fs.rmSync(lockDir, { recursive: true, force: true });
+                        }
+                        catch { }
+                        return this.acquireExclusiveLock();
+                    }
+                }
+                // Some other FS error (EACCES, ENOSPC, etc.) — fall through
+                // and let the daemon run anyway rather than blocking start.
+                return true;
+            }
+        }
+        catch {
+            return true;
+        }
+    }
+    /**
+     * Release the exclusive lock (called from `stop()` and on SIGINT/SIGTERM).
+     */
+    async releaseExclusiveLock() {
+        try {
+            const lockDir = this.pidFile + '.lock';
+            fs.rmSync(lockDir, { recursive: true, force: true });
+        }
+        catch {
+            // Best effort — if the dir doesn't exist, that's fine.
+        }
+    }
     /**
      * Initialize with stored credentials
      */
@@ -133,14 +231,29 @@ export class DaemonService {
     }
     /**
      * Start the daemon (foreground process)
+     *
+     * Acquires an exclusive flock on the PID file. If another daemon is
+     * already running, returns `false` immediately so the caller can exit
+     * cleanly. This is what prevents the duplicate-sync bug (two daemons
+     * each doing their own 60s sync loop on the same user account).
      */
     async start() {
+        // Acquire single-instance lock FIRST — don't even read credentials
+        // if another daemon holds the lock. Saves work and avoids logging
+        // misleading "Authenticated" output during a concurrent start attempt.
+        const gotLock = await this.acquireExclusiveLock();
+        if (!gotLock) {
+            console.error('Another promptcase daemon is already running.');
+            console.error('Check `promptcase status` or run `promptcase stop` first.');
+            return false;
+        }
         // Initialize with credentials
         if (!await this.initialize()) {
             console.error('No credentials found. Run "promptcase init" first.');
+            await this.releaseExclusiveLock();
             return false;
         }
-        // Write PID file
+        // Write PID file (lock is already held on it — same fd)
         await this.writePidFile();
         // Start sync loop
         const syncInterval = await this.configService.getSyncInterval();
@@ -182,7 +295,10 @@ export class DaemonService {
         setInterval(async () => {
             await this.saveRefreshedTokens();
         }, 60 * 60 * 1000);
-        // Handle graceful shutdown
+        // Handle graceful shutdown. Release the flock on every signal so a
+        // respawn (LaunchAgent KeepAlive) can acquire it cleanly. If the
+        // process is killed with SIGKILL or via uncaughtException, the kernel
+        // releases the flock automatically when the process exits.
         process.on('SIGINT', async () => {
             console.log('\n\n🛑 Stopping daemon...');
             await this.stop();
@@ -207,6 +323,7 @@ export class DaemonService {
             this.syncInterval = null;
         }
         await this.cleanupPidFile();
+        await this.releaseExclusiveLock();
         this.status.isRunning = false;
         await this.configService.setDaemonStatus({
             isRunning: false,
@@ -347,8 +464,6 @@ export class DaemonService {
     </array>
     <key>RunAtLoad</key>
     <true/>
-    <key>KeepAlive</key>
-    <true/>
     <key>ProcessType</key>
     <string>Background</string>
     <key>StandardOutPath</key>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "promptcase",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "CLI daemon to capture and sync AI prompts to PromptCase web app",
   "main": "dist/index.js",
   "bin": {