shieldcortex 4.14.2 → 4.14.4

package/dist/cli/doctor.js

@@ -371,7 +371,10 @@ export async function checkAutoMemoryHooks() {
     // when the user hasn't configured anything yet.
     let gateStop = false;
     let gateSessionEnd = false;
-    let samplingTurns = 10;
+    // Default lowered 10 → 5 in v4.14.0 — keep this fallback in sync with
+    // scripts/lib/auto-memory-config.mjs so doctor reports the same value
+    // the runtime gate would resolve to when no override is present.
+    let samplingTurns = 5;
     try {
         const cfg = await import('../cloud/config.js');
         const enable = cfg.getAutoMemoryEnableConfig();
@@ -501,23 +504,36 @@ async function checkProcesses() {
     return results;
 }
 // ── Check 6: Disk usage ───────────────────────────────────
-async function checkDiskUsage() {
-    const scDir = getShieldCortexDir();
+/**
+ * The 100 MB safety limit applies to the data portion of `~/.shieldcortex/`
+ * — DB, state, audit logs, telemetry. The `models/` subtree (local Review
+ * Copilot weights, embedding caches) can legitimately reach hundreds of MB
+ * for users who opted into local AI inference, and should not trip the same
+ * warning as runaway memory growth. v4.14.3 and earlier counted everything
+ * under `~/.shieldcortex/`, producing a false `Disk: at limit!` for any
+ * user with a local AI model cached.
+ */
+export async function checkDiskUsage(scDir = getShieldCortexDir()) {
     if (!fs.existsSync(scDir)) {
         return { label: 'Disk', status: 'pass', message: '0 B / 100 MB limit (directory not yet created)' };
     }
     try {
-        let totalSize = 0;
-        function walkDir(dir) {
+        let dataSize = 0;
+        let modelsSize = 0;
+        function walkInto(dir, bucket) {
             const entries = fs.readdirSync(dir, { withFileTypes: true });
             for (const entry of entries) {
                 const fullPath = path.join(dir, entry.name);
                 try {
                     if (entry.isDirectory()) {
-                        walkDir(fullPath);
+                        walkInto(fullPath, bucket);
                     }
                     else if (entry.isFile()) {
-                        totalSize += fs.statSync(fullPath).size;
+                        const size = fs.statSync(fullPath).size;
+                        if (bucket === 'models')
+                            modelsSize += size;
+                        else
+                            dataSize += size;
                     }
                 }
                 catch {
@@ -525,18 +541,43 @@ async function checkDiskUsage() {
                 }
             }
         }
-        walkDir(scDir);
-        const limit = 100 * 1024 * 1024; // 100 MB
-        const pct = (totalSize / limit) * 100;
-        const sizeStr = `${formatBytes(totalSize)} / 100 MB limit`;
+        const topLevel = fs.readdirSync(scDir, { withFileTypes: true });
+        for (const entry of topLevel) {
+            const fullPath = path.join(scDir, entry.name);
+            try {
+                if (entry.isDirectory()) {
+                    walkInto(fullPath, entry.name === 'models' ? 'models' : 'data');
+                }
+                else if (entry.isFile()) {
+                    dataSize += fs.statSync(fullPath).size;
+                }
+            }
+            catch {
+                // Skip inaccessible top-level entries
+            }
+        }
+        const limit = 100 * 1024 * 1024; // 100 MB applies to the data portion only
+        const pct = (dataSize / limit) * 100;
+        const dataStr = `${formatBytes(dataSize)} / 100 MB limit`;
+        const modelsStr = modelsSize > 0 ? ` + ${formatBytes(modelsSize)} models` : '';
         if (pct >= 95) {
-            return { label: 'Disk', status: 'fail', message: `${sizeStr} — at limit!`, fix: 'Run consolidation or delete old memories' };
+            return {
+                label: 'Disk',
+                status: 'fail',
+                message: `${dataStr}${modelsStr} — at limit!`,
+                fix: 'Run `shieldcortex memories prune --execute` or `memories dedupe --execute` to trim the DB',
+            };
         }
         else if (pct >= 80) {
-            return { label: 'Disk', status: 'warn', message: `${sizeStr} — approaching limit`, fix: 'Consider running consolidation to free space' };
+            return {
+                label: 'Disk',
+                status: 'warn',
+                message: `${dataStr}${modelsStr} — approaching limit`,
+                fix: 'Consider running `shieldcortex memories prune` or `memories dedupe`',
+            };
         }
         else {
-            return { label: 'Disk', status: 'pass', message: sizeStr };
+            return { label: 'Disk', status: 'pass', message: `${dataStr}${modelsStr}` };
         }
     }
     catch (err) {

package/dist/index.js

@@ -646,13 +646,27 @@ ${bold}DOCS${reset}
         // own release cadences; skipping them when main is current caused v4.9 → v4.10
         // users to be stuck on v4.9 of the plugin until they manually removed the
         // extension dir and re-ran `openclaw plugins install`.
+        //
+        // OpenClaw 2026.5.5 added a guard that refuses `plugins install` when the
+        // plugin is already present at ~/.openclaw/npm/node_modules/<scope>/<name>
+        // and tells the caller to use `update` or `--force`. Our reconcile always
+        // *wants* to overwrite — that's the entire point of the step — so we pass
+        // --force unconditionally. Works for fresh installs too (no-op when no
+        // existing plugin to replace).
         try {
             const extDir = path.join(home, '.openclaw', 'extensions', 'shieldcortex-realtime');
-            if (fs.existsSync(extDir)) {
+            const npmDir = path.join(home, '.openclaw', 'npm', 'node_modules', '@drakon-systems', 'shieldcortex-realtime');
+            if (fs.existsSync(extDir) || fs.existsSync(npmDir)) {
                 console.log('Reconciling OpenClaw plugin...');
-                fs.rmSync(extDir, { recursive: true, force: true });
+                // Best-effort cleanup of the legacy extensions/ path so 2026.5.x doesn't
+                // see two install records. The npm/node_modules/ path is owned by the
+                // OpenClaw installer and `--force` will replace it.
                 try {
-                    execSync('openclaw plugins install @drakon-systems/shieldcortex-realtime@latest', {
+                    fs.rmSync(extDir, { recursive: true, force: true });
+                }
+                catch { /* ignore */ }
+                try {
+                    execSync('openclaw plugins install --force @drakon-systems/shieldcortex-realtime@latest', {
                         stdio: 'inherit',
                         timeout: 60000,
                         env: { ...process.env, HOME: home },
@@ -661,7 +675,7 @@ ${bold}DOCS${reset}
                 }
                 catch {
                     console.warn('⚠ OpenClaw plugin reinstall failed — run manually:');
-                    console.warn('  openclaw plugins install @drakon-systems/shieldcortex-realtime');
+                    console.warn('  openclaw plugins install --force @drakon-systems/shieldcortex-realtime');
                 }
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shieldcortex",
-  "version": "4.14.2",
+  "version": "4.14.4",
   "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.2",
+  "version": "4.14.4",
   "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,