shieldcortex 4.14.7 → 4.14.9

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

@@ -10,7 +10,7 @@
  *
  * Behaviour-preserving — every step does what the old inline flow did.
  */
-import { spawnSync } from 'child_process';
+import { spawn } from 'child_process';
 import fs from 'fs';
 import path from 'path';
 import { homedir } from 'os';
@@ -94,22 +94,59 @@ async function step(label, fn) {
     }
 }
 function runQuiet(cmd, args, opts = {}) {
-    const result = spawnSync(cmd, args, {
-        stdio: ['ignore', 'pipe', 'pipe'],
-        encoding: 'utf-8',
-        timeout: opts.timeout,
-        env: opts.env ?? process.env,
-        shell: false,
+    // Async on purpose: spawnSync blocks the event loop, which froze the spinner
+    // for the full duration of `npm install` (30–60s). Using `spawn` lets the
+    // setInterval-driven braille animation keep ticking while the child runs.
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: opts.env ?? process.env,
+            shell: false,
+        });
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        let timer = null;
+        child.stdout?.setEncoding('utf-8');
+        child.stderr?.setEncoding('utf-8');
+        child.stdout?.on('data', (chunk) => { stdout += chunk; });
+        child.stderr?.on('data', (chunk) => { stderr += chunk; });
+        if (opts.timeout) {
+            timer = setTimeout(() => {
+                timedOut = true;
+                child.kill('SIGTERM');
+                // Grace period before SIGKILL — long npm tarball extracts can take
+                // a few seconds to wind down even after SIGTERM.
+                setTimeout(() => { try {
+                    child.kill('SIGKILL');
+                }
+                catch { /* already dead */ } }, 5000).unref();
+            }, opts.timeout);
+            timer.unref();
+        }
+        child.on('error', (err) => {
+            if (timer)
+                clearTimeout(timer);
+            reject(err);
+        });
+        child.on('close', (code) => {
+            if (timer)
+                clearTimeout(timer);
+            if (timedOut) {
+                const err = new Error(`timeout: ${cmd} ${args.join(' ')}`);
+                err.stdout = stdout;
+                err.stderr = stderr;
+                return reject(err);
+            }
+            if (typeof code === 'number' && code !== 0) {
+                const err = new Error(`exit ${code}: ${cmd} ${args.join(' ')}`);
+                err.stdout = stdout;
+                err.stderr = stderr;
+                return reject(err);
+            }
+            resolve({ stdout, stderr });
+        });
     });
-    if (result.error)
-        throw result.error;
-    if (typeof result.status === 'number' && result.status !== 0) {
-        const err = new Error(`exit ${result.status}: ${cmd} ${args.join(' ')}`);
-        err.stdout = result.stdout;
-        err.stderr = result.stderr;
-        throw err;
-    }
-    return { stdout: result.stdout || '', stderr: result.stderr || '' };
 }
 // ── Header / footer ─────────────────────────────────────────
 function header(currentVersion, latestVersion) {
@@ -143,7 +180,7 @@ function readPackageVersion() {
 }
 async function fetchLatestVersion() {
     try {
-        const { stdout } = runQuiet('npm', ['view', 'shieldcortex', 'version'], { timeout: 10000 });
+        const { stdout } = await runQuiet('npm', ['view', 'shieldcortex', 'version'], { timeout: 10000 });
         return stdout.trim() || null;
     }
     catch {
@@ -161,13 +198,13 @@ async function stepNpmPackage(currentVersion, latestVersion, force) {
     }
     if (latestVersion === currentVersion && force) {
         const result = await step('npm package', async () => {
-            runQuiet('npm', ['install', '-g', 'shieldcortex@latest', '--silent', '--no-audit', '--no-fund'], { timeout: 180000 });
+            await 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 });
+        await runQuiet('npm', ['install', '-g', 'shieldcortex@latest', '--silent', '--no-audit', '--no-fund'], { timeout: 180000 });
         return `v${currentVersion} → v${latestVersion}`;
     });
     return { updated: true, result };
@@ -184,7 +221,7 @@ async function stepOpenClawPlugin(home) {
         }
         catch { /* ignore */ }
         try {
-            runQuiet('openclaw', ['plugins', 'install', '--force', '@drakon-systems/shieldcortex-realtime@latest'], { timeout: 60000, env: { ...process.env, HOME: home } });
+            await runQuiet('openclaw', ['plugins', 'install', '--force', '@drakon-systems/shieldcortex-realtime@latest'], { timeout: 60000, env: { ...process.env, HOME: home } });
             return '@latest installed';
         }
         catch {
@@ -205,7 +242,7 @@ async function stepOpenClawSkill(home) {
     }
     return await step('OpenClaw skill', async () => {
         try {
-            runQuiet('openclaw', ['skills', 'install', 'shieldcortex', '--force'], {
+            await runQuiet('openclaw', ['skills', 'install', 'shieldcortex', '--force'], {
                 timeout: 60000,
                 env: { ...process.env, HOME: home },
             });

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.7",
+  "version": "4.14.9",
   "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.7",
+  "version": "4.14.9",
   "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,