shieldcortex 4.14.6 → 4.14.8

package/dist/cli/doctor.js

@@ -753,6 +753,31 @@ async function checkAutoMemorySampling() {
  * timestamp is missing or older than 30 min, consolidation has likely
  * stalled — STM won't graduate to LTM.
  */
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ESRCH')
+            return false; // No such process — definitely dead
+        if (code === 'EPERM')
+            return true; // Process exists but owned by another user
+        return null; // Unknown — don't make claims
+    }
+}
+function workerRecoveryFix() {
+    // The right recovery is platform-dependent. On a headless Linux host (most
+    // common shape: OpenClaw + bot user, no Claude Code), the durable answer
+    // is `service install --headless` plus `loginctl enable-linger`. On macOS
+    // and on dev machines running Claude Code, restarting the editor spawns
+    // a fresh MCP-bound worker.
+    if (process.platform === 'linux') {
+        return 'For persistence, run `shieldcortex service install --headless` (recommended on headless hosts) or restart Claude Code';
+    }
+    return 'Restart Claude Code or run `shieldcortex service install` to supervise the worker';
+}
 async function checkBrainWorker() {
     if (process.env.SHIELDCORTEX_DISABLE_WORKER === '1') {
         return {
@@ -767,7 +792,7 @@ async function checkBrainWorker() {
             label: 'Brain worker',
             status: 'warn',
             message: 'no worker.json — worker has not run yet',
-            fix: 'Start an MCP-bound session (Claude Code) or run `shieldcortex worker` to drive consolidation',
+            fix: workerRecoveryFix(),
         };
     }
     try {
@@ -778,23 +803,40 @@ async function checkBrainWorker() {
                 label: 'Brain worker',
                 status: 'warn',
                 message: 'worker.json present but lastLightTick missing/invalid',
-                fix: 'Restart Claude Code to spawn a fresh MCP server',
+                fix: workerRecoveryFix(),
             };
         }
         const ageMs = Date.now() - last.getTime();
         const ageMin = Math.round(ageMs / 60000);
+        const pid = typeof raw.pid === 'number' ? raw.pid : null;
+        const profile = raw.profile ?? '?';
+        // Pid liveness changes the meaning of staleness. A stale tick from a
+        // *dead* process is a different failure mode than a stale tick from a
+        // *running* process — only the first means "the worker crashed and
+        // nothing's coming". The fix-hint diverges accordingly.
+        const alive = pid != null ? isPidAlive(pid) : null;
+        if (pid != null && alive === false) {
+            return {
+                label: 'Brain worker',
+                status: 'warn',
+                message: `process gone (pid ${pid} dead, last tick ${ageMin}m ago, profile=${profile})`,
+                fix: workerRecoveryFix(),
+            };
+        }
         if (ageMs > 30 * 60 * 1000) {
             return {
                 label: 'Brain worker',
                 status: 'warn',
-                message: `last tick ${ageMin}m ago (profile=${raw.profile ?? '?'}, pid=${raw.pid ?? '?'})`,
-                fix: 'Restart Claude Code or run `shieldcortex worker` to resume consolidation',
+                message: `last tick ${ageMin}m ago (profile=${profile}, pid=${pid ?? '?'}${alive === true ? ', alive' : ''})`,
+                fix: alive === true
+                    ? 'Worker process alive but ticks stalled — restart Claude Code or `shieldcortex service repair`'
+                    : workerRecoveryFix(),
             };
         }
         return {
             label: 'Brain worker',
             status: 'pass',
-            message: `last tick ${ageMin}m ago (profile=${raw.profile ?? '?'}, pid=${raw.pid ?? '?'})`,
+            message: `last tick ${ageMin}m ago (profile=${profile}, pid=${pid ?? '?'})`,
         };
     }
     catch (err) {

package/dist/cli/update.js

@@ -150,15 +150,22 @@ async function fetchLatestVersion() {
         return null;
     }
 }
-async function stepNpmPackage(currentVersion, latestVersion) {
+async function stepNpmPackage(currentVersion, latestVersion, force) {
     if (!latestVersion) {
         const result = await step('npm package', async () => ({ status: 'warn', summary: 'registry unreachable' }));
         return { updated: false, result };
     }
-    if (latestVersion === currentVersion) {
+    if (latestVersion === currentVersion && !force) {
         const result = await step('npm package', async () => `v${currentVersion} (current)`);
         return { updated: false, result };
     }
+    if (latestVersion === currentVersion && force) {
+        const result = await step('npm package', async () => {
+            runQuiet('npm', ['install', '-g', 'shieldcortex@latest', '--silent', '--no-audit', '--no-fund'], { timeout: 180000 });
+            return `v${currentVersion} (reinstalled)`;
+        });
+        return { updated: true, result };
+    }
     const result = await step('npm package', async () => {
         runQuiet('npm', ['install', '-g', 'shieldcortex@latest', '--silent', '--no-audit', '--no-fund'], { timeout: 180000 });
         return `v${currentVersion} → v${latestVersion}`;
@@ -262,13 +269,17 @@ export async function runUpdate() {
     const home = homedir();
     const currentVersion = readPackageVersion();
     const flowStart = Date.now();
+    const force = process.argv.includes('--force') || process.argv.includes('-f');
     // Header — show current version immediately, then update with latest once we know it.
     // (We resolve `latest` before drawing the arrow so the banner is correct.)
     const latestVersion = await fetchLatestVersion();
     header(currentVersion, latestVersion);
+    if (force) {
+        process.stdout.write(`  ${paint('yellow', '!')}  ${paint('gray', '--force: reinstall everything regardless of version')}\n\n`);
+    }
     let mainUpdated = false;
     try {
-        const npmStep = await stepNpmPackage(currentVersion, latestVersion);
+        const npmStep = await stepNpmPackage(currentVersion, latestVersion, force);
         mainUpdated = npmStep.updated;
     }
     catch {

package/dist/index.js

@@ -342,6 +342,26 @@ async function startWorkerMode(dbPath) {
     const { startDefaultWorker } = await import('./worker/brain-worker.js');
     initDatabase(dbPath);
     startDefaultWorker();
+    // Resilience handlers (v4.14.8). Without these, any throw outside a tick's
+    // try/catch — module load errors from optional integrations, fetch socket
+    // errors that leak past best-effort wrappers, transient SQLite errors during
+    // schema migration on startup — would crash the entire worker process and
+    // leave a stale `worker.json` (pid recorded, no further ticks). systemd
+    // would restart it under `service install`, but users running
+    // `shieldcortex worker` interactively had no supervisor.
+    process.on('uncaughtException', (err) => {
+        console.error('[BrainWorker] uncaughtException — continuing:', err);
+    });
+    process.on('unhandledRejection', (reason) => {
+        console.error('[BrainWorker] unhandledRejection — continuing:', reason);
+    });
+    // Ignore SIGHUP so SSH disconnect doesn't kill an interactive
+    // `shieldcortex worker` session. systemd users get this for free, but
+    // anyone running it from a terminal previously lost the worker the moment
+    // they logged out.
+    process.on('SIGHUP', () => {
+        console.error('[BrainWorker] SIGHUP ignored — keeping worker alive');
+    });
     console.log(`
 ╔══════════════════════════════════════════════════════════════╗
 ║             ShieldCortex Worker Service                     ║
@@ -350,6 +370,10 @@ async function startWorkerMode(dbPath) {
 ║  Heartbeats keep this device online in ShieldCortex Cloud   ║
 ║  Sync retries and graph maintenance remain active           ║
 ╚══════════════════════════════════════════════════════════════╝
+
+  For persistence across reboots, run:
+    shieldcortex service install --headless
+  (otherwise this process dies when the parent shell exits)
   `);
     const keepAlive = setInterval(() => {
         // Intentionally empty. BrainWorker timers are unref()'d, so the service

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shieldcortex",
-  "version": "4.14.6",
+  "version": "4.14.8",
   "description": "Trustworthy memory and security for AI agents. Recall debugging, review queue, OpenClaw session capture, and memory poisoning defence for Claude Code, Codex, OpenClaw, LangChain, and MCP agents.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/plugins/openclaw/dist/openclaw.plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "shieldcortex-realtime",
-  "version": "4.14.6",
+  "version": "4.14.8",
   "name": "ShieldCortex Real-time Scanner",
   "description": "Real-time defence scanning on LLM input, memory extraction on LLM output, and active tool call interception with approval gating.",
   "kind": null,