@compr/opscontext-mcp 2.5.4 → 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/cli.js

@@ -646,7 +646,7 @@ import { SERVER_COMMANDS, suggestCommands } from "./cli-commands.js";
 import { collectProjectOps, collectSystemOps } from "./collectors.js";
 import { scanCodeDir } from "./code-chunker.js";
 import { listProjects, runComplianceAudit, formatProjectList, formatPlan, scoreProject, runScoreCanary, formatScoreReport, generateScoreHTML, generateProjectScoreMD, } from "./agents.js";
-import { listLearnings, learningsToChunks, learningsStats, formatLearnings, saveLearning, deleteLearning, importLearningsFromFile, autoImportFromSources, LEARNING_CATEGORIES, } from "./learnings.js";
+import { listLearnings, parseSince, learningsToChunks, learningsStats, formatLearnings, saveLearning, deleteLearning, importLearningsFromFile, autoImportFromSources, LEARNING_CATEGORIES, } from "./learnings.js";
 import { saveSession, loadSession, listSessions, deleteSession, formatSession, formatSessionList, } from "./sessions.js";
 import { activate, deactivate, getActivationStatus, gateCheck, } from "./activation.js";
 import { syncTierA, syncTierB, loadCommunityStore, communityRulesToChunks, mergeWithDedup, STORE_PATH as COMMUNITY_STORE_PATH, } from "./community-sync.js";
@@ -755,12 +755,37 @@ async function cliListProjects() {
     const text = formatProjectList(projects);
     console.log(`\n${text}`);
 }
-async function cliListLearnings(category) {
+async function cliListLearnings(args) {
+    // list-learnings [category] [--since today|yesterday|ISO]. [LOCK] [LEARNINGS-LIST-SHOWS-CREATED]
+    let category;
+    let sinceSpec;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--since") {
+            sinceSpec = args[i + 1];
+            if (!sinceSpec) {
+                console.error("--since needs a value: today, yesterday, or an ISO date");
+                process.exit(1);
+            }
+            i++;
+        }
+        else if (!category) {
+            category = args[i];
+        }
+    }
+    let since;
+    if (sinceSpec) {
+        const parsed = parseSince(sinceSpec);
+        if (!parsed) {
+            console.error(`--since "${sinceSpec}" is not today, yesterday, or an ISO date. Refusing to answer with a zero.`);
+            process.exit(1);
+        }
+        since = parsed;
+    }
     // Project-scoped: only show learnings for workspace projects + universal
     const projectDirs = loadProjectDirs();
     const projectNames = projectDirs.map((d) => d.name);
     const learnings = listLearnings(category, projectNames);
-    const text = formatLearnings(learnings);
+    const text = formatLearnings(learnings, { since, sinceSpec });
     console.log(`\n${text}`);
 }
 async function cliSaveLearning(args) {
@@ -2458,7 +2483,8 @@ Usage:
   contextengine search <query> [-n N]  Search indexed knowledge (default: top 5)
   contextengine list-sources           Show all indexed sources with chunk counts
   contextengine list-projects          Discover and analyze all projects (Pro)
-  contextengine list-learnings [cat]   List all learnings (optional: filter by category)
+  contextengine list-learnings [cat] [--since today|yesterday|ISO]
+                                       List learnings with their created instant (UTC + Europe/Zurich)
   contextengine save-learning <text> -c <category>  Save a learning
   contextengine delete-learning <id>   Delete a learning by ID
   contextengine import-learnings <file> [-c cat] [-p project]  Bulk-import learnings
@@ -2579,8 +2605,7 @@ else if (command === "list-projects") {
     });
 }
 else if (command === "list-learnings") {
-    const category = process.argv[3];
-    cliListLearnings(category).catch((err) => {
+    cliListLearnings(process.argv.slice(3)).catch((err) => {
         console.error("Error:", err);
         process.exit(1);
     });

package/dist/index.js

@@ -14,7 +14,7 @@ import { verifyChain, readAuditLog, filterByRange, autoRotateAuditLog } from "./
 import { startEventIngestServer } from "./http-server.js";
 import { detect } from "./detector.js";
 import { buildCostReport } from "./cost-report.js";
-import { saveLearning, searchLearnings, listLearnings, deleteLearning, learningsToChunks, learningsStats, formatLearnings, importLearningsFromFile, autoImportFromSources, LEARNING_CATEGORIES, } from "./learnings.js";
+import { saveLearning, searchLearnings, listLearnings, deleteLearning, learningsToChunks, learningsStats, formatLearnings, importLearningsFromFile, autoImportFromSources, LEARNING_CATEGORIES, parseSince } from "./learnings.js";
 import { communityRulesToChunks, mergeWithDedup, loadCommunityStore, } from "./community-sync.js";
 import { readFileSync, existsSync, watch, statSync, writeFileSync, mkdirSync } from "fs";
 import { basename, join, dirname } from "path";
@@ -919,10 +919,21 @@ server.tool("list_learnings", "List all permanent learnings, optionally filtered
         .string()
         .optional()
         .describe("Filter by category (deployment, api, database, etc.). Omit to show all."),
-}, async ({ category }) => {
+    since: z
+        .string()
+        .optional()
+        .describe("Only learnings created at or after this boundary: 'today', 'yesterday' (Europe/Zurich calendar days) or an ISO date/instant. Every entry shows its created instant, UTC plus Europe/Zurich."),
+}, async ({ category, since }) => {
     // Project-scoped: only show learnings for active workspace projects + universal (no project)
+    let sinceDate;
+    if (since) {
+        const parsed = parseSince(since);
+        if (!parsed)
+            return respond("list_learnings", `❌ since="${since}" is not today, yesterday, or an ISO date. No list rendered, so this is not a zero.`);
+        sinceDate = parsed;
+    }
     const learnings = listLearnings(category, activeProjectNames);
-    const text = formatLearnings(learnings);
+    const text = formatLearnings(learnings, { since: sinceDate, sinceSpec: since });
     return respond("list_learnings", text);
 });
 // ---------------------------------------------------------------------------

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.
  */
@@ -104,5 +114,19 @@ export declare function learningsStats(): {
 /**
  * Format learnings for display.
  */
-export declare function formatLearnings(learnings: Learning[]): string;
+export declare const LEARNINGS_LOCAL_TZ = "Europe/Zurich";
+/** `2026-09-05 10:30Z (12:30 CEST)`; `undated` when the record carries no usable instant. */
+export declare function formatLearnedAt(iso: string | undefined, tz?: string): string;
+/** `today` | `yesterday` (calendar days in `tz`) | any ISO date or instant. `null` when unparseable. */
+export declare function parseSince(spec: string, now?: Date, tz?: string): Date | null;
+/** Records created at or after `since`, oldest first. Undated records are excluded and counted by the caller. */
+export declare function filterSince(learnings: Learning[], since: Date): Learning[];
+export interface FormatLearningsOptions {
+    /** Already-parsed boundary; the caller resolves the spec so an invalid one errors before rendering. */
+    since?: Date;
+    /** The spec as typed, echoed in the header so the reader sees which boundary applied. */
+    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 };
 }
 /**
@@ -680,12 +862,76 @@ export function learningsStats() {
 /**
  * Format learnings for display.
  */
-export function formatLearnings(learnings) {
+// [LOCKED] [LEARNINGS-LIST-SHOWS-CREATED] 2026-09-05
+// [NEVER] print a learning without its `created` instant, and [NEVER] answer "what was
+//         saved since X" by probing learnings.json with a hand-written key.
+// WHY: on 2026-09-05 an agent read a date field the records do not have (`createdAt`),
+//      got an empty string for every record, and answered "0 saved today" with full
+//      confidence; a second agent made the same mistake the same morning. A probe on a
+//      missing key returns a confident zero, never an error. The store had 22 records
+//      from that day, under `created`. Until then the listing showed the date only,
+//      so "today" was also ambiguous around midnight between UTC and Yan's clock.
+// FIX: one renderer shows `created` as the UTC instant plus the Europe/Zurich wall
+//      time, and `--since today|yesterday|ISO` is a first-class filter whose empty
+//      result names the boundary it applied. An unparseable spec is an error, not zero.
+export const LEARNINGS_LOCAL_TZ = "Europe/Zurich";
+/** `2026-09-05 10:30Z (12:30 CEST)`; `undated` when the record carries no usable instant. */
+export function formatLearnedAt(iso, tz = LEARNINGS_LOCAL_TZ) {
+    if (!iso)
+        return "undated";
+    const d = new Date(iso);
+    if (Number.isNaN(d.getTime()))
+        return "undated";
+    const utc = d.toISOString().slice(0, 16).replace("T", " ") + "Z";
+    const local = new Intl.DateTimeFormat("en-GB", {
+        timeZone: tz, hour: "2-digit", minute: "2-digit", hour12: false, timeZoneName: "short",
+    }).format(d);
+    return `${utc} (${local})`;
+}
+/** Midnight of the given calendar day in `tz`, as a UTC instant. Offset read from Intl, never guessed. */
+function localMidnightUtc(y, m, d, tz) {
+    const guess = new Date(Date.UTC(y, m - 1, d, 0, 0, 0));
+    const off = new Intl.DateTimeFormat("en-US", { timeZone: tz, timeZoneName: "longOffset" })
+        .formatToParts(guess).find((p) => p.type === "timeZoneName")?.value ?? "GMT";
+    const mm = /GMT([+-])(\d{2}):(\d{2})/.exec(off);
+    const minutes = mm ? (mm[1] === "-" ? -1 : 1) * (parseInt(mm[2], 10) * 60 + parseInt(mm[3], 10)) : 0;
+    return new Date(guess.getTime() - minutes * 60_000);
+}
+/** `today` | `yesterday` (calendar days in `tz`) | any ISO date or instant. `null` when unparseable. */
+export function parseSince(spec, now = new Date(), tz = LEARNINGS_LOCAL_TZ) {
+    const s = spec.trim().toLowerCase();
+    if (s === "today" || s === "yesterday") {
+        const parts = new Intl.DateTimeFormat("en-CA", { timeZone: tz, year: "numeric", month: "2-digit", day: "2-digit" })
+            .formatToParts(now);
+        const get = (t) => parseInt(parts.find((p) => p.type === t)?.value ?? "0", 10);
+        const midnight = localMidnightUtc(get("year"), get("month"), get("day"), tz);
+        return s === "today" ? midnight : new Date(midnight.getTime() - 86_400_000);
+    }
+    if (!/^\d{4}-\d{2}-\d{2}/.test(spec.trim()))
+        return null;
+    const d = new Date(spec.trim());
+    return Number.isNaN(d.getTime()) ? null : d;
+}
+/** Records created at or after `since`, oldest first. Undated records are excluded and counted by the caller. */
+export function filterSince(learnings, since) {
+    return learnings
+        .filter((l) => l.created && !Number.isNaN(new Date(l.created).getTime()) && new Date(l.created).getTime() >= since.getTime())
+        .sort((a, b) => new Date(a.created).getTime() - new Date(b.created).getTime());
+}
+export function formatLearnings(learnings, opts = {}) {
+    let sinceNote = "";
+    if (opts.since) {
+        learnings = filterSince(learnings, opts.since);
+        sinceNote = ` since ${opts.sinceSpec ?? opts.since.toISOString()} = ${formatLearnedAt(opts.since.toISOString())}`;
+    }
     if (learnings.length === 0) {
+        if (opts.since) {
+            return `0 learnings${sinceNote}. The boundary above is the one that was applied; if that looks wrong, the store is at ~/.contextengine/learnings.json and its date field is \`created\`.`;
+        }
         return "No learnings stored yet. Use `save_learning` to add operational rules.";
     }
     const lines = [];
-    lines.push(`# 💡 Learnings Store (${learnings.length} rules)\n`);
+    lines.push(`# 💡 Learnings Store (${learnings.length} rules${sinceNote})\n`);
     // Group by category
     const byCategory = new Map();
     for (const l of learnings) {
@@ -704,8 +950,7 @@ export function formatLearnings(learnings) {
                 lines.push(`- **Context:** ${l.context}`);
             if (l.tags?.length)
                 lines.push(`- **Tags:** ${l.tags.join(", ")}`);
-            if (l.created)
-                lines.push(`- **Learned:** ${l.created.split("T")[0]}`);
+            lines.push(`- **Learned:** ${formatLearnedAt(l.created)}`);
             lines.push("");
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@compr/opscontext-mcp",
-  "version": "2.5.4",
+  "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",