total-recall-brain 3.23.0 → 3.23.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "total-recall-brain",
-  "version": "3.23.0",
+  "version": "3.23.1",
   "description": "Personal AI system — database-free, SSSS-powered intelligence engine deployable to any POSIX host.",
   "type": "module",
   "workspaces": [

package/src/core/daemon-loop.mjs

@@ -13,6 +13,8 @@
 
 import path from 'path';
 import fs from 'fs';
+import { fileURLToPath } from 'node:url';
+import { readProcessCommand, entryPathHint, shouldHonorPidLock } from './pid-lock.mjs';
 import { createScheduler, updateTaskStatus, persistTaskToDisk } from './scheduler.mjs';
 import { scanAndIngest } from './session-watcher.mjs';
 import { syncAllRepos } from './repo-sync.mjs';
@@ -111,20 +113,36 @@ export function acquirePidLock() {
     if (fs.existsSync(PID_FILE)) {
       const existingPid = parseInt(fs.readFileSync(PID_FILE, 'utf8').trim(), 10);
       if (existingPid && !isNaN(existingPid)) {
-        try {
-          process.kill(existingPid, 0); // Check if process is alive (signal 0 = no-op check)
+        // Liveness alone cannot tell our daemon from whatever else inherited
+        // the number after a reboot — observed here holding a PID that had
+        // since been handed to an unrelated desktop app, which would refuse
+        // every start from then on.
+        const verdict = shouldHonorPidLock(existingPid, {
+          isAlive: (pid) => {
+            try {
+              process.kill(pid, 0); // signal 0 = no-op liveness check
+              return true;
+            } catch {
+              return false;
+            }
+          },
+          readCommand: readProcessCommand,
+          entryHint: entryPathHint(fileURLToPath(import.meta.url)),
+        });
+        if (verdict.honor) {
           logger.error({
             subsystem: 'daemon-loop',
             message: `Another daemon is already running (PID: ${existingPid}). Exiting.`,
           });
           process.exit(1);
-        } catch {
-          // Process is dead — stale PID file
-          logger.info({
-            subsystem: 'daemon-loop',
-            message: `Stale PID file found (PID: ${existingPid} is dead). Overwriting.`,
-          });
         }
+        logger.info({
+          subsystem: 'daemon-loop',
+          message:
+            verdict.reason === 'pid-reused'
+              ? `Stale PID file found (PID ${existingPid} now belongs to another program). Overwriting.`
+              : `Stale PID file found (PID: ${existingPid} is dead). Overwriting.`,
+        });
       }
     }
   } catch {

package/src/{server → core}/pid-lock.mjs

@@ -11,19 +11,20 @@
  * already running", and it did so on every boot from then on — an outage with
  * an error message that sent you looking for a process that was never there.
  *
- * So liveness is necessary but not sufficient: the process has to look like
- * this server before its lock is honored.
+ * So liveness is necessary but not sufficient: the process has to look like the
+ * program that wrote the lock before the lock is honored. Shared by the server
+ * and the daemon, which had the same check and therefore the same bug.
  */
 
 import { spawnSync } from 'node:child_process';
 import path from 'node:path';
 
 /**
- * The tail of our own entry path (`server/index.mjs`), derived rather than
- * written down so it stays correct wherever the package is installed and never
- * hardcodes a checkout location.
+ * The tail of an entry path (`server/index.mjs`, `core/daemon-loop.mjs`),
+ * derived from the caller's own module URL rather than written down, so it stays
+ * correct wherever the package is installed and hardcodes no checkout location.
  */
-export function serverEntryHint(entryPath) {
+export function entryPathHint(entryPath) {
   return path.join(path.basename(path.dirname(entryPath)), path.basename(entryPath));
 }
 

package/src/server/index.mjs

@@ -28,7 +28,7 @@ import {
   requireScope
 } from './auth.mjs';
 import { logger, logEvents } from "../core/logger.mjs";
-import { readProcessCommand, serverEntryHint, shouldHonorPidLock } from './pid-lock.mjs';
+import { readProcessCommand, entryPathHint, shouldHonorPidLock } from '../core/pid-lock.mjs';
 import { drainActiveEmbeddings } from './routes/sessions.mjs';
 import { agentDir as configAgentDir, brainDir as configBrainDir, port as configPort, host as configHost, nodeEnv } from '../core/config.mjs';
 import { getDaemonStatus, ensureDaemonRunning } from '../core/daemon-control.mjs';
@@ -69,7 +69,7 @@ function acquireServerPidLock() {
             }
           },
           readCommand: readProcessCommand,
-          entryHint: serverEntryHint(fileURLToPath(import.meta.url)),
+          entryHint: entryPathHint(fileURLToPath(import.meta.url)),
         });
         if (verdict.honor) {
           logger.error('server', `Another server instance is already running (PID: ${existingPid}). Exiting.`);