shieldcortex 4.33.1 → 4.34.0

package/dist/setup/openclaw.js

@@ -10,7 +10,7 @@ import path from 'path';
 import os from 'os';
 import { execSync, spawnSync } from 'child_process';
 import { fileURLToPath, pathToFileURL } from 'url';
-import { resolveRealtimeProjectDir, readRealtimeProjectManifest, findEoverrideRiskPins, isRealtimePluginDisabledInConfig, } from '../integrations/openclaw-plugin-state.js';
+import { resolveRealtimeProjectDir, readRealtimeProjectManifest, findEoverrideRiskPins, findLatentEoverridePins, stripManagedPinsFromManifest, isRealtimePluginDisabledInConfig, } from '../integrations/openclaw-plugin-state.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const HOOK_NAME = 'cortex-memory';
@@ -1144,6 +1144,13 @@ export async function repairOpenClawManagedPins(homeArg) {
         return { status: 'not-installed', message: 'Realtime plugin not installed; no managed pins to reconcile.' };
     }
     const risks = findEoverrideRiskPins(manifest);
+    // Strip-set: every managed peer co-present in overrides (latent EOVERRIDE),
+    // not just the currently-mismatched ones. OpenClaw refreshes the override
+    // from its bundled workspace mid-install while preserving the stale dep pin,
+    // so a manifest that looks clean at rest still throws EOVERRIDE on reinstall
+    // (edith, 2026-06-14). Stripping the co-present dep pin lets the reinstall
+    // re-derive it at the current override version.
+    const latentPins = findLatentEoverridePins(manifest);
     const disabled = isRealtimePluginDisabledInConfig(home);
     const selfVersion = readSelfVersion();
     const deps = (typeof manifest.dependencies === 'object' && manifest.dependencies
@@ -1155,7 +1162,9 @@ export async function repairOpenClawManagedPins(homeArg) {
     }
     console.log('Reconciling OpenClaw managed plugin pins (EOVERRIDE guard):');
     if (risks.length)
-        console.log(`  - version-drifted pins: ${risks.map((r) => `${r.name} (${r.dependencyVersion}→${r.overrideVersion})`).join(', ')}`);
+        console.log(`  - version-drifted now: ${risks.map((r) => `${r.name} (${r.dependencyVersion}→${r.overrideVersion})`).join(', ')}`);
+    if (latentPins.length)
+        console.log(`  - stripping override-shadowed peer pin(s): ${latentPins.join(', ')} (re-derived at the current override on reinstall)`);
     if (staleShieldcortex)
         console.log(`  - stale shieldcortex lib pin: ${String(deps.shieldcortex)} → ${selfVersion}`);
     if (disabled)
@@ -1168,10 +1177,12 @@ export async function repairOpenClawManagedPins(homeArg) {
         console.log(`  - safety backup: ${`${manifestPath}.repair-backup-${ts}`.replace(home, '~')}`);
     }
     catch { /* best-effort */ }
-    // 2. Strip drifted pins (reinstall re-derives them at the override version)
-    //    and advance the stale shieldcortex pin.
-    for (const r of risks)
-        delete deps[r.name];
+    // 2. Strip co-present (latent) pins from deps AND managedPeerDependencies so
+    //    the reinstall re-derives them at the CURRENT override version, then
+    //    advance the stale shieldcortex lib pin. `deps` is the same object the
+    //    strip mutates in place; shieldcortex is never override-shadowed so it
+    //    survives the strip.
+    stripManagedPinsFromManifest(manifest, latentPins);
     if (staleShieldcortex && selfVersion)
         deps.shieldcortex = selfVersion;
     manifest.dependencies = deps;
@@ -1211,7 +1222,7 @@ export async function repairOpenClawManagedPins(homeArg) {
     if (residual.length > 0) {
         return { status: 'failed', message: `Reinstall succeeded but pins still drift: ${residual.map((r) => r.name).join(', ')}. Backup: ${manifestPath}.repair-backup-${ts}` };
     }
-    const parts = [`Reconciled ${risks.length} drifted pin(s)`];
+    const parts = [`Reconciled ${latentPins.length} override-shadowed pin(s)`];
     if (staleShieldcortex)
         parts.push(`advanced shieldcortex to ${selfVersion}`);
     if (disabled)

package/dist/tools/context.d.ts

@@ -6,6 +6,7 @@
  */
 import { z } from 'zod';
 import { getMemoryStats } from '../memory/store.js';
+import { type SalienceDistribution } from '../memory/metrics.js';
 import { Memory, ContextSummary, ConsolidationResult } from '../memory/types.js';
 export declare const getContextSchema: z.ZodObject<{
     project: z.ZodOptional<z.ZodString>;
@@ -118,9 +119,10 @@ export declare function executeStats(input: {
 }): {
     success: boolean;
     stats?: ReturnType<typeof getMemoryStats>;
+    salience?: SalienceDistribution;
     error?: string;
 };
-export declare function formatStats(stats: ReturnType<typeof getMemoryStats>): string;
+export declare function formatStats(stats: ReturnType<typeof getMemoryStats>, salience?: SalienceDistribution): string;
 export declare const exportSchema: z.ZodObject<{
     project: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {

package/dist/tools/context.js

@@ -7,6 +7,8 @@
 import { z } from 'zod';
 import { generateContextSummary, formatContextSummary, startSession, endSession, getSuggestedContext, consolidate, previewConsolidation, exportMemories, importMemories, } from '../memory/consolidate.js';
 import { getMemoryStats } from '../memory/store.js';
+import { getSalienceDistribution } from '../memory/metrics.js';
+import { getDatabase } from '../database/init.js';
 import { resolveProject } from '../context/project-context.js';
 // Input schema for getting context
 export const getContextSchema = z.object({
@@ -208,7 +210,9 @@ export function executeStats(input) {
         const resolvedProject = resolveProject(input.project);
         const projectFilter = resolvedProject ?? undefined;
         const stats = getMemoryStats(projectFilter);
-        return { success: true, stats };
+        // Phase 0: include the salience-wall instrument so memory_stats surfaces it.
+        const salience = getSalienceDistribution(getDatabase(), projectFilter);
+        return { success: true, stats, salience };
     }
     catch (error) {
         return {
@@ -217,7 +221,7 @@ export function executeStats(input) {
         };
     }
 }
-export function formatStats(stats) {
+export function formatStats(stats, salience) {
     const lines = [
         '## Memory Statistics',
         '',
@@ -233,6 +237,13 @@ export function formatStats(stats) {
     for (const [category, count] of Object.entries(stats.byCategory)) {
         lines.push(`  - ${category}: ${count}`);
     }
+    // Phase 0: the salience-wall instrument. Raw salience saturates for surviving
+    // memories, so a high wall % means the score has stopped discriminating.
+    if (salience) {
+        lines.push('', '### Memory Quality', `  - At salience wall (≥0.95): ${salience.wall.ltmAtOrAbove095}/${salience.wall.ltmTotal} long-term (${salience.wall.ltmPct}%)`, `  - Fragments in wall: ${salience.fragments.atOrAbove095} (${salience.fragments.pctOfWall}%)`);
+        for (const w of salience.warnings)
+            lines.push(`  ⚠ ${w}`);
+    }
     return lines.join('\n');
 }
 // Export/Import

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shieldcortex",
-  "version": "4.33.1",
+  "version": "4.34.0",
   "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/scripts/prompt-recall-hook.mjs

@@ -22,6 +22,7 @@ import { truncatePreservingWords } from './lib/truncate.mjs';
 import { compareRecallResults } from './lib/recall-rank.mjs';
 import { computeEffectiveSalience } from './lib/salience.mjs';
 import { writeRecallLog } from './lib/recall-log.mjs';
+import { recordHookInvocation } from './lib/telemetry.mjs';
 import { filterByRelevance, extractQueryTerms } from './lib/recall-relevance.mjs';
 
 // ==================== CONFIG ====================
@@ -535,6 +536,11 @@ process.stdin.on('end', async () => {
         UPDATE memories SET access_count = access_count + 1, last_accessed = datetime('now')
         WHERE id IN (${placeholders})
       `).run(...ids);
+      // Phase 0 measurement: record the recall injection in hook_invocations
+      // (reusing the connection we already opened). This is the cumulative
+      // "is the store actually read into prompts?" signal — fires = recalls
+      // that injected ≥1, memories_extracted = count injected. Best-effort.
+      recordHookInvocation(writeDb, { hookName: 'prompt-recall', memoriesExtracted: memories.length });
       writeDb.close();
     } catch {
       // Non-critical — don't block on access count update