@compr/opscontext-mcp 2.5.3 → 2.5.5

package/dist/index.js

@@ -10,10 +10,11 @@ import { collectProjectOps, collectSystemOps } from "./collectors.js";
 import { loadCache, saveCache } from "./cache.js";
 import { listProjects, checkPorts, runComplianceAudit, formatProjectList, formatPortMap, formatPlan, scoreProject, formatScoreReport, runScoreCanary, } from "./agents.js";
 import { saveSession, loadSession, listSessions, deleteSession, formatSession, formatSessionList, } from "./sessions.js";
-import { verifyChain, readAuditLog, filterByRange } from "./audit.js";
+import { verifyChain, readAuditLog, filterByRange, autoRotateAuditLog } from "./audit.js";
 import { startEventIngestServer } from "./http-server.js";
 import { detect } from "./detector.js";
-import { saveLearning, searchLearnings, listLearnings, deleteLearning, learningsToChunks, learningsStats, formatLearnings, importLearningsFromFile, autoImportFromSources, LEARNING_CATEGORIES, } from "./learnings.js";
+import { buildCostReport } from "./cost-report.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";
@@ -609,6 +610,9 @@ server.tool("audit_verify", "Verify the integrity of the local audit log chain.
     const summary = [];
     summary.push(`Audit chain: ${report.ok ? "✅ INTACT" : "❌ BROKEN"}`);
     summary.push(`Total records: ${report.total}`);
+    if ((report.redactedIndices ?? []).length > 0) {
+        summary.push(`Redacted and acknowledged on the chain: ${report.redactedIndices.length} record(s), not counted as altered`);
+    }
     if (since || until) {
         summary.push(`Range filter: ${since ?? "start"} → ${until ?? "now"}  (${filtered.length} record(s) in range)`);
     }
@@ -623,6 +627,28 @@ server.tool("audit_verify", "Verify the integrity of the local audit log chain.
     return respond("audit_verify", summary.join("\n"));
 });
 // ---------------------------------------------------------------------------
+// Tool: agent_cost (multi-agent token / cost / capacity report)
+// ---------------------------------------------------------------------------
+// Same renderer as `contextengine cost`. [LOCK] [COST-REPORT-ONE-RENDERER]
+// Free tool: it reads the caller's own Claude Code transcripts on this machine,
+// nothing leaves it. Added 2026-08-21, one day after the CLI (707fcc8).
+server.tool("agent_cost", "Multi-agent cost report from Claude Code's own transcripts on this machine: tokens moved (cache read/write, fresh input, output), valued cost at API list prices (marked NOTIONAL on a subscription, UNPRICED when no rate matches), capacity intensity (subagents, failed, died at window, tool calls per agent, cache reuse), top runs, and context_burn / fanout_without_canary signals. Call it after a fan-out to read what it consumed, or before one to compare with the last. Thresholds come from .contextengine/policy.json agent_cost, else built-in defaults.", {
+    days: z.number().int().positive().optional().describe("Only runs started within the last N days"),
+    project: z.string().optional().describe("Filter by project slug as it appears in ~/.claude/projects (e.g. -Users-yan-Projects-ContextEngine)"),
+    session: z.string().optional().describe("Filter by parent session id"),
+    run: z.string().optional().describe("Filter by run id (wf_... or task group id)"),
+    top: z.number().int().positive().max(50).optional().describe("How many runs to list (default 10)"),
+    json: z.boolean().optional().describe("Return the structured JSON report instead of the text one"),
+    policy_dir: z.string().optional().describe("Absolute path of the repo whose .contextengine/policy.json supplies agent_cost thresholds and rates. Default: the MCP server's working directory, which under launchd is the home dir, not a repo; the report names which source it used on its 'thresholds:' line"),
+}, async ({ days, project, session, run, top, json, policy_dir }) => {
+    // [COST-POLICY-DIR-IS-EXPLICIT] — the daemon's cwd is not a project. Without this the MCP
+    // surface silently priced with built-in defaults while the CLI in the repo read policy.json.
+    const report = buildCostReport({ days, project, session, run, top }, policy_dir || process.cwd());
+    if (json && report.json)
+        return respond("agent_cost", JSON.stringify(report.json, null, 2));
+    return respond("agent_cost", report.text);
+});
+// ---------------------------------------------------------------------------
 // Tool: drift_status (Detector — read current drift signals)
 // ---------------------------------------------------------------------------
 // Agents should call this between major task phases. If any 'critical' signal
@@ -893,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);
 });
 // ---------------------------------------------------------------------------
@@ -1131,6 +1168,24 @@ async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error("[ContextEngine] 🚀 MCP server running on stdio (keyword search ready)");
+    // 3a. Audit log auto-rotation. Deferred so the first requests are answered before the
+    // synchronous verify + rewrite (a few seconds on a 500k-record chain) blocks the loop.
+    // [LOCK] [AUTO-ROTATE-HYSTERESIS-AND-ONE-RUNNER]
+    // Measured 2026-08-21: ~13k records/hour on this machine, so the 100k trigger is hours
+    // away, not a day; a server that is never restarted must still rotate. Hourly recheck.
+    const runAutoRotate = () => {
+        try {
+            const o = autoRotateAuditLog();
+            if (o.action === "rotated" || o.action === "refused" || o.action === "error" || o.action === "in_progress") {
+                console.error(`[ContextEngine] 📦 audit auto-rotate (${o.action}): ${o.detail}`);
+            }
+        }
+        catch (err) {
+            console.error(`[ContextEngine] ⚠ audit auto-rotate failed: ${err.message}`);
+        }
+    };
+    setTimeout(runAutoRotate, 3_000).unref();
+    setInterval(runAutoRotate, 60 * 60_000).unref();
     // 3b. Write server-meta.json so the VS Code extension can read tool count
     // without needing an active MCP session. Single source of truth =
     // src/tools-manifest.ts (asserted by tests/tools-manifest.test.ts).

package/dist/learnings.d.ts

@@ -104,5 +104,18 @@ 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;
 //# sourceMappingURL=learnings.d.ts.map

package/dist/learnings.js

@@ -680,12 +680,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 +768,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/dist/tools-manifest.d.ts

@@ -24,14 +24,14 @@
  * Every tool name registered on the MCP server, in registration order.
  * Order is not load-bearing — kept stable for easier diffs.
  */
-export declare const ALL_TOOLS: readonly ["search_context", "list_sources", "read_source", "reindex", "list_projects", "check_ports", "run_audit", "score_project", "save_session", "load_session", "list_sessions", "delete_session", "audit_verify", "drift_status", "end_session", "save_learning", "list_learnings", "delete_learning", "import_learnings", "activate", "activation_status"];
+export declare const ALL_TOOLS: readonly ["search_context", "list_sources", "read_source", "reindex", "list_projects", "check_ports", "run_audit", "score_project", "save_session", "load_session", "list_sessions", "delete_session", "audit_verify", "drift_status", "agent_cost", "end_session", "save_learning", "list_learnings", "delete_learning", "import_learnings", "activate", "activation_status"];
 /**
  * The 4 tools gated behind PRO activation. Subset of `ALL_TOOLS`.
  * Must match `PREMIUM_TOOLS` in `src/activation.ts` (asserted by test).
  */
 export declare const PREMIUM_TOOL_NAMES: readonly ["score_project", "run_audit", "check_ports", "list_projects"];
 /** Total count — what users see as "Active on all N MCP tools". */
-export declare const TOOL_COUNT: 21;
+export declare const TOOL_COUNT: 22;
 /** Free-tier tool count — everything except `PREMIUM_TOOL_NAMES`. */
 export declare const FREE_TOOL_COUNT: number;
 //# sourceMappingURL=tools-manifest.d.ts.map

package/dist/tools-manifest.js

@@ -39,6 +39,7 @@ export const ALL_TOOLS = [
     "delete_session",
     "audit_verify",
     "drift_status",
+    "agent_cost",
     "end_session",
     "save_learning",
     "list_learnings",

package/package.json

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