@compr/opscontext-mcp 2.5.5 → 2.5.6

package/dist/audit.d.ts

@@ -1,4 +1,4 @@
-export type AuditEvent = "learning.save" | "learning.delete" | "learning.import" | "learning.export" | "session.save" | "session.delete" | "activation.activate" | "activation.deactivate" | "activation.heartbeat" | "activation.signature_reject" | "activation.legacy_signature" | "firewall.escalate" | "hook.block" | "hook.bypass" | "policy.skipped" | "browser.prompt" | "browser.response" | "browser.tool_call" | "browser.session_start" | "browser.session_end" | "browser.capture_miss" | "vscode.prompt_submit" | "vscode.tool_call" | "vscode.session_start" | "drift.detected" | "notification.fired" | "community.sync_ok" | "community.sync_error" | "audit.rotate" | "audit.redact";
+export type AuditEvent = "learning.save" | "learning.delete" | "learning.store_unreadable" | "learning.store_shrink_refused" | "learning.import" | "learning.export" | "session.save" | "session.delete" | "activation.activate" | "activation.deactivate" | "activation.heartbeat" | "activation.signature_reject" | "activation.legacy_signature" | "firewall.escalate" | "hook.block" | "hook.bypass" | "policy.skipped" | "browser.prompt" | "browser.response" | "browser.tool_call" | "browser.session_start" | "browser.session_end" | "browser.capture_miss" | "vscode.prompt_submit" | "vscode.tool_call" | "vscode.session_start" | "drift.detected" | "notification.fired" | "community.sync_ok" | "community.sync_error" | "audit.rotate" | "audit.redact";
 export interface AuditRecord {
     ts: string;
     event: AuditEvent;

package/dist/learnings.d.ts

@@ -17,11 +17,21 @@ export interface LearningsStore {
 /** Valid categories for learnings */
 export declare const LEARNING_CATEGORIES: readonly ["deployment", "api", "database", "frontend", "backend", "devops", "security", "performance", "testing", "debugging", "tooling", "git", "dependencies", "architecture", "data", "infrastructure", "mobile", "other"];
 export type LearningCategory = (typeof LEARNING_CATEGORIES)[number];
+/** Cross-process, re-entrant (within this process) lock around the store file. */
+export declare function withStoreLock<T>(fn: () => T): T;
+/**
+ * Run `fn` with ONE load and at most ONE save of the store, under the lock. Inside, every
+ * loadStore() returns the same in-memory store and every saveStore() only marks it dirty.
+ */
+export declare function withStoreBatch<T>(fn: () => T): T;
+/** Test seam for the writer's tripwire; not part of the API. */
+export declare function __writeStoreForTests(store: LearningsStore): void;
 /**
  * Save a new learning. Returns the created learning with ID.
  * Rejects rules shorter than MIN_RULE_LENGTH and auto-corrects "other" category.
  */
-export declare function saveLearning(category: string, rule: string, context: string, project?: string): Learning;
+export declare function saveLearning(...args: Parameters<typeof saveLearningUnlocked>): Learning;
+declare function saveLearningUnlocked(category: string, rule: string, context: string, project?: string): Learning;
 /**
  * Search learnings by keyword. Returns matches sorted by relevance.
  */
@@ -118,4 +128,5 @@ export interface FormatLearningsOptions {
     sinceSpec?: string;
 }
 export declare function formatLearnings(learnings: Learning[], opts?: FormatLearningsOptions): string;
+export {};
 //# sourceMappingURL=learnings.d.ts.map

package/dist/learnings.js

@@ -1,6 +1,6 @@
 // LOCKED — verified March 3 2026 — learning store: quality gates, auto-categorize, dedup, project-scoped filtering
 // DO NOT RE-AUDIT — min 15 chars, inferCategory(), autoImportFromSources() all verified v1.19.1
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync, copyFileSync, rmSync, statSync, readdirSync, unlinkSync } from "fs";
 import { join, dirname } from "path";
 import { homedir } from "os";
 import { fileURLToPath } from "url";
@@ -98,32 +98,203 @@ function mergeDefaults(store) {
     }
     return added > 0;
 }
-function loadStore() {
+// [LOCKED] [STORE-NEVER-STARTS-FRESH-OVER-DATA] 2026-09-05
+// [NEVER] turn an unreadable learnings.json into an empty store, write the store with a
+//         bare writeFileSync, or let two processes write it without the lock below.
+// WHY: on 2026-09-05 (16:34Z) the whole store was rebuilt from scratch: every id
+//      replaced, every `created` reset, the save_learning-only records gone. Cause, read
+//      from the code and the audit log: every MCP server (launchd, VS Code, Claude Code)
+//      watches ~880 doc files and re-imports all of them on any change, one full-file
+//      rewrite PER RULE; with two or three servers doing that at once, one read a
+//      half-written file, `catch { start fresh }` turned it into an empty store, and the
+//      next save overwrote 2,808 records with the rebuilt set. The audit log shows 54
+//      such bursts since 2026-06-23 and 143,352 ids created for a store of ~2,800: the
+//      same race, repeatedly, and the likeliest source of the 66 audit-chain forks.
+// FIX: (1) atomic writes, temp file + rename, so a reader never sees a torn file;
+//      (2) an unreadable existing file is copied to learnings.json.corrupt-<ts> and the
+//          load THROWS, it never becomes an empty store; (3) a saved store that is less
+//          than half the on-disk one (and the disk one has >= 100 records) is refused
+//          unless CONTEXTENGINE_ALLOW_SHRINK=1; (4) a cross-process lock directory
+//          around every load-modify-save; (5) imports run as ONE batch: one load, one
+//          save, instead of one rewrite per rule; (6) a daily learnings.json.bak-YYYYMMDD
+//          before the first write of the day, last 7 kept.
+const STORE_LOCK_DIR = LEARNINGS_PATH + ".lock";
+const LOCK_STALE_MS = 30_000;
+let lockDepth = 0;
+let batchStore = null;
+let batchDirty = false;
+function sleepMs(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+/** Cross-process, re-entrant (within this process) lock around the store file. */
+export function withStoreLock(fn) {
+    if (lockDepth > 0) {
+        lockDepth++;
+        try {
+            return fn();
+        }
+        finally {
+            lockDepth--;
+        }
+    }
+    ensureDir();
+    const timeoutMs = parseInt(process.env.CONTEXTENGINE_LOCK_TIMEOUT_MS || "10000", 10);
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        try {
+            mkdirSync(STORE_LOCK_DIR);
+            try {
+                writeFileSync(join(STORE_LOCK_DIR, "pid"), String(process.pid));
+            }
+            catch { /* diagnostics only */ }
+            break;
+        }
+        catch (e) {
+            if (e?.code !== "EEXIST")
+                throw e;
+            let age = 0;
+            try {
+                age = Date.now() - statSync(STORE_LOCK_DIR).mtimeMs;
+            }
+            catch {
+                age = 0;
+            }
+            if (age > LOCK_STALE_MS) {
+                // Holder died (or hung) without releasing: take it over.
+                try {
+                    rmSync(STORE_LOCK_DIR, { recursive: true, force: true });
+                }
+                catch { /* retry below */ }
+                continue;
+            }
+            if (Date.now() > deadline) {
+                throw new Error(`learnings store is locked by another process (${STORE_LOCK_DIR}, ${Math.round(age / 1000)}s old); refusing to write over it`);
+            }
+            sleepMs(25);
+        }
+    }
+    lockDepth = 1;
+    try {
+        return fn();
+    }
+    finally {
+        lockDepth = 0;
+        try {
+            rmSync(STORE_LOCK_DIR, { recursive: true, force: true });
+        }
+        catch { /* best effort */ }
+    }
+}
+/**
+ * Run `fn` with ONE load and at most ONE save of the store, under the lock. Inside, every
+ * loadStore() returns the same in-memory store and every saveStore() only marks it dirty.
+ */
+export function withStoreBatch(fn) {
+    if (batchStore)
+        return fn(); // already batching (re-entrant)
+    return withStoreLock(() => {
+        batchStore = readStoreFromDisk();
+        batchDirty = false;
+        try {
+            const out = fn();
+            if (batchDirty)
+                writeStoreToDisk(batchStore);
+            return out;
+        }
+        finally {
+            batchStore = null;
+            batchDirty = false;
+        }
+    });
+}
+function readStoreFromDisk() {
     let store;
     if (existsSync(LEARNINGS_PATH)) {
+        const raw = readFileSync(LEARNINGS_PATH, "utf-8");
         try {
-            store = JSON.parse(readFileSync(LEARNINGS_PATH, "utf-8"));
-            // Filter out corrupted entries missing required 'rule' field
-            store.learnings = store.learnings.filter((l) => typeof l.rule === "string" && l.rule.length > 0);
+            store = JSON.parse(raw);
+            if (!store || !Array.isArray(store.learnings))
+                throw new Error("no learnings array");
         }
-        catch {
-            // Corrupted file — start fresh
-            store = { version: 1, count: 0, learnings: [] };
+        catch (e) {
+            const keep = `${LEARNINGS_PATH}.corrupt-${new Date().toISOString().replace(/[:.]/g, "-")}`;
+            try {
+                copyFileSync(LEARNINGS_PATH, keep);
+            }
+            catch { /* the original stays in place regardless */ }
+            safeAppend("learning.store_unreadable", { path: LEARNINGS_PATH, bytes: raw.length, kept: keep, error: String(e?.message || e) });
+            throw new Error(`${LEARNINGS_PATH} exists but is unreadable (${e?.message || e}); refusing to start fresh over it. Copy kept at ${keep}. Another process may be mid-write: retry in a moment.`);
         }
+        // Filter out corrupted entries missing required 'rule' field
+        store.learnings = store.learnings.filter((l) => typeof l.rule === "string" && l.rule.length > 0);
     }
     else {
         store = { version: 1, count: 0, learnings: [] };
     }
     // Auto-merge bundled defaults on first load or when new defaults are added
     if (mergeDefaults(store)) {
-        saveStore(store);
+        if (batchStore)
+            batchDirty = true;
+        else
+            writeStoreToDisk(store);
     }
     return store;
 }
-function saveStore(store) {
+function loadStore() {
+    if (batchStore)
+        return batchStore;
+    return readStoreFromDisk();
+}
+function dailyBackup() {
+    if (!existsSync(LEARNINGS_PATH))
+        return;
+    const day = new Date().toISOString().slice(0, 10).replace(/-/g, "");
+    const bak = `${LEARNINGS_PATH}.bak-${day}`;
+    if (existsSync(bak))
+        return;
+    try {
+        copyFileSync(LEARNINGS_PATH, bak);
+        const dir = dirname(LEARNINGS_PATH);
+        const daily = readdirSync(dir).filter((f) => /^learnings\.json\.bak-\d{8}$/.test(f)).sort();
+        for (const f of daily.slice(0, Math.max(0, daily.length - 7)))
+            unlinkSync(join(dir, f));
+    }
+    catch { /* a missing backup must never block a save */ }
+}
+function writeStoreToDisk(store) {
     ensureDir();
     store.count = store.learnings.length;
-    writeFileSync(LEARNINGS_PATH, JSON.stringify(store, null, 2));
+    // Shrink tripwire: the exact shape of the 2026-09-05 loss was a near-empty store
+    // written over a full one.
+    if (existsSync(LEARNINGS_PATH) && process.env.CONTEXTENGINE_ALLOW_SHRINK !== "1") {
+        let onDisk = -1;
+        try {
+            onDisk = (JSON.parse(readFileSync(LEARNINGS_PATH, "utf-8")).learnings || []).length;
+        }
+        catch {
+            onDisk = -1;
+        }
+        if (onDisk >= 100 && store.learnings.length < onDisk / 2) {
+            safeAppend("learning.store_shrink_refused", { on_disk: onDisk, attempted: store.learnings.length });
+            throw new Error(`refusing to write ${store.learnings.length} learnings over a store of ${onDisk}: that is the shape of a wipe, not an edit. Set CONTEXTENGINE_ALLOW_SHRINK=1 if this is deliberate.`);
+        }
+    }
+    dailyBackup();
+    const tmp = `${LEARNINGS_PATH}.tmp-${process.pid}-${Date.now()}`;
+    writeFileSync(tmp, JSON.stringify(store, null, 2));
+    renameSync(tmp, LEARNINGS_PATH);
+}
+function saveStore(store) {
+    if (batchStore) {
+        batchStore = store;
+        batchDirty = true;
+        return;
+    }
+    writeStoreToDisk(store);
+}
+/** Test seam for the writer's tripwire; not part of the API. */
+export function __writeStoreForTests(store) {
+    withStoreLock(() => writeStoreToDisk(store));
 }
 /** Generate a short unique ID */
 function generateId() {
@@ -156,7 +327,10 @@ const MIN_RULE_LENGTH = 15;
  * Save a new learning. Returns the created learning with ID.
  * Rejects rules shorter than MIN_RULE_LENGTH and auto-corrects "other" category.
  */
-export function saveLearning(category, rule, context, project) {
+export function saveLearning(...args) {
+    return withStoreLock(() => saveLearningUnlocked(...args));
+}
+function saveLearningUnlocked(category, rule, context, project) {
     const trimmedRule = rule.trim();
     // Quality gate: reject junk rules
     if (trimmedRule.length < MIN_RULE_LENGTH) {
@@ -278,6 +452,9 @@ export function listLearnings(category, projects) {
  * Delete a learning by ID.
  */
 export function deleteLearning(id) {
+    return withStoreLock(() => deleteLearningUnlocked(id));
+}
+function deleteLearningUnlocked(id) {
     const store = loadStore();
     const index = store.learnings.findIndex((l) => l.id === id);
     if (index === -1)
@@ -299,9 +476,10 @@ export function importLearningsFromFile(filePath, defaultCategory = "other", def
     }
     const content = readFileSync(filePath, "utf-8");
     const ext = filePath.split(".").pop()?.toLowerCase();
-    const result = ext === "json"
+    // One load, one save for the whole file. [LOCK] [STORE-NEVER-STARTS-FRESH-OVER-DATA]
+    const result = withStoreBatch(() => ext === "json"
         ? importFromJson(content, defaultProject)
-        : importFromMarkdown(content, defaultCategory, defaultProject);
+        : importFromMarkdown(content, defaultCategory, defaultProject));
     // Aggregate event correlating the individual learning.save records emitted
     // inside the loop. Useful for compliance attribution: "this batch came from
     // file X".
@@ -650,20 +828,24 @@ export function autoImportFromSources(sources) {
     let totalImported = 0;
     let totalUpdated = 0;
     let processed = 0;
-    for (const source of sources) {
-        // Only process markdown files
-        if (!source.path.endsWith(".md"))
-            continue;
-        if (!existsSync(source.path))
-            continue;
-        // Extract project name from source name (e.g., "ContextEngine — copilot-instructions.md")
-        const project = source.name.split(" — ")[0]?.trim() || undefined;
-        const result = importLearningsFromFile(source.path, "other", project);
-        totalImported += result.imported;
-        totalUpdated += result.updated;
-        if (result.imported > 0 || result.updated > 0)
-            processed++;
-    }
+    // One load and one save for the whole sweep (~880 files), instead of one full-file
+    // rewrite per rule per file. [LOCK] [STORE-NEVER-STARTS-FRESH-OVER-DATA]
+    withStoreBatch(() => {
+        for (const source of sources) {
+            // Only process markdown files
+            if (!source.path.endsWith(".md"))
+                continue;
+            if (!existsSync(source.path))
+                continue;
+            // Extract project name from source name (e.g., "ContextEngine — copilot-instructions.md")
+            const project = source.name.split(" — ")[0]?.trim() || undefined;
+            const result = importLearningsFromFile(source.path, "other", project);
+            totalImported += result.imported;
+            totalUpdated += result.updated;
+            if (result.imported > 0 || result.updated > 0)
+                processed++;
+        }
+    });
     return { total: processed, imported: totalImported, updated: totalUpdated };
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@compr/opscontext-mcp",
-  "version": "2.5.5",
+  "version": "2.5.6",
   "description": "OpsContext for AI Agents — read-only fleet visibility (PM2/nginx/Docker/git/cron) + tamper-evident audit log + policy-as-code hooks. The ops + compliance layer Claude Code can't grow natively.",
   "type": "module",
   "main": "dist/index.js",
@@ -18,7 +18,8 @@
     "test:watch": "vitest",
     "lint": "eslint src/",
     "prepublishOnly": "node scripts/check-npm-token-expiry.mjs && npm run build && node scripts/obfuscate-rubric.mjs",
-    "check-token": "node scripts/check-npm-token-expiry.mjs"
+    "check-token": "node scripts/check-npm-token-expiry.mjs",
+    "verify-release": "bash scripts/verify-release.sh"
   },
   "keywords": [
     "mcp",