@compr/opscontext-mcp 2.10.0 → 2.11.0

package/dist/cli.js

@@ -651,7 +651,7 @@ import { listLearnings, parseSince, learningsToChunks, learningsStats, formatLea
 import { saveSession, loadSession, listSessions, deleteSession, formatSession, formatSessionList, } from "./sessions.js";
 import { activate, deactivate, getActivationStatus, gateCheckFresh, } from "./activation.js";
 import { syncTierA, syncTierB, loadCommunityStore, communityRulesToChunks, mergeWithDedup, STORE_PATH as COMMUNITY_STORE_PATH, } from "./community-sync.js";
-import { readAuditLog, verifyChain, filterByRange, toCsv, rotateAuditLog, planRotation, listSegments, acknowledgeRedaction, restoreSegment, scrubAuditLog, } from "./audit.js";
+import { readAuditLog, verifyChain, filterByRange, toCsv, rotateAuditLog, planRotation, listSegments, acknowledgeRedaction, restoreSegment, scrubAuditLog, recordVerifyState, acquireVerifyLock, } from "./audit.js";
 import { redactPayload, redactChunk } from "./secret-shapes.js";
 import { loadRepoPolicy, parsePolicy, formatPolicySummary, formatValidationErrors, repoPolicyPath, } from "./policy.js";
 import { buildCostReport } from "./cost-report.js";
@@ -1751,7 +1751,16 @@ safeAppend), visible via 'contextengine audit-verify' and consumed by the
         console.error(`❌ ${refused}`);
         process.exit(1);
     }
-    safeAppend(eventKind, prepareCapturedPayload(payload, eventKind), actor);
+    // [LOCKED] [RECEIVER-SAYS-WHAT-WAS-WRITTEN] - 2026-09-27
+    // [NEVER] report "Appended" or exit 0 for an entry the audit log refused.
+    // WHY: on a stuck log (a record cut short by a full disk) this printed "Appended vscode.tool_call to
+    //      audit log." and exited 0 while nothing landed (E2E_REVIEW_2026-09 B1-1); the VS Code
+    //      extension emits through this command and believed it.
+    // FIX: safeAppend() returns whether it wrote; a refusal exits 1. [LOCK] [A-REFUSED-APPEND-IS-COUNTED-AND-CHAINED]
+    if (!safeAppend(eventKind, prepareCapturedPayload(payload, eventKind), actor)) {
+        console.error(`❌ Not recorded: the audit log refused ${eventKind} (reason above). The refusal is counted and will be noted on the chain.`);
+        process.exit(1);
+    }
     console.log(`✅ Appended ${eventKind} to audit log.`);
 }
 async function cliWatch(args) {
@@ -2129,11 +2138,35 @@ function cliAuditRedactAck(args) {
     console.log(`   audit-verify now: ${after.ok ? "OK" : "FAILED"}, ${(after.redactedIndices ?? []).length} redacted, ${(after.tamperedIndices ?? []).length} altered.`);
 }
 async function cliAuditVerify() {
+    // [LOCK] [HEALTH-SEES-THE-CHAIN]: every full check leaves its result for fleet health. The
+    // daily one (--scheduled, started by the indexing server) runs one at a time and prints nothing.
+    const scheduled = process.argv.includes("--scheduled");
+    let releaseVerifyLock = null;
+    if (scheduled) {
+        releaseVerifyLock = acquireVerifyLock();
+        if (!releaseVerifyLock)
+            return; // another check is running
+    }
+    const t0 = Date.now();
     const report = verifyChain();
+    recordVerifyState(report, Date.now() - t0, scheduled ? "scheduled" : "cli");
+    if (scheduled) {
+        releaseVerifyLock?.();
+        return;
+    }
     const forks = report.forkIndices ?? [];
     const redacted = report.redactedIndices ?? [];
+    const dups = report.duplicateIndices ?? [];
+    // [LOCK] [VERIFY-FORK-IS-NOT-TAMPER]: a second copy of a record is counted once and named as a copy.
+    const copiesNote = () => {
+        if (dups.length === 0)
+            return;
+        console.log(`\n⚠️  ${dups.length} record(s) appear twice (a second copy of a record already in the log).`);
+        console.log(`   Counted once. Content intact, nothing missing. Usually a log trim that was interrupted or`);
+        console.log(`   ran while entries arrived. At: ${dups.slice(0, 8).join(", ")}${dups.length > 8 ? `, … (+${dups.length - 8} more)` : ""}`);
+    };
     if (report.ok) {
-        console.log(`✅ Audit chain verified — ${report.total} record(s).`);
+        console.log(`✅ Audit chain verified — ${report.total - dups.length} record(s).`);
         console.log(redacted.length === 0
             ? `   No record was altered, and no history is missing.`
             : `   No history is missing. ${redacted.length} record(s) redacted and acknowledged on the chain (indices ${redacted.slice(0, 8).join(", ")}${redacted.length > 8 ? ", …" : ""}), 0 altered.`);
@@ -2146,6 +2179,7 @@ async function cliAuditVerify() {
             console.log(`   property holds. Do NOT rewrite the log to linearise it — that would destroy`);
             console.log(`   the evidence it exists to provide.`);
         }
+        copiesNote();
         return;
     }
     console.error(`❌ Audit chain FAILED — ${report.total} record(s) checked.`);
@@ -2155,12 +2189,24 @@ async function cliAuditVerify() {
         console.error(`\n   Altered records (content does not match its own hash):`);
         console.error(`     ${t.slice(0, 10).join(", ")}${t.length > 10 ? `, … (+${t.length - 10} more)` : ""}`);
         console.error(`   This is tampering: the record's bytes were changed after it was written.`);
-        console.error(`   If this was a deliberate redaction of a secret, acknowledge it on the chain:`);
-        console.error(`     contextengine audit-redact-ack --index ${t.slice(0, 3).join(",")} --reason "<what was removed and why>"`);
+        console.error(`   If this was a deliberate redaction of a secret, acknowledge it on the chain`);
+        console.error(`   (every altered index is listed, so the command can be pasted as it is):`);
+        console.error(`     contextengine audit-redact-ack --index ${t.join(",")} --reason "<what was removed and why>"`);
     }
     if (redacted.length > 0) {
         console.error(`\n   Also ${redacted.length} redacted record(s), acknowledged on the chain, not counted above.`);
     }
+    // [LOCK] [VERIFY-READS-PAST-AN-UNREADABLE-LINE]: say where, and that the rest was checked.
+    const unreadable = report.unreadable ?? [];
+    if (unreadable.length > 0) {
+        console.error(`\n   Lines that are not records (every other record was checked):`);
+        for (const u of unreadable.slice(0, 10))
+            console.error(`     ${u.file} line ${u.line}`);
+        if (unreadable.length > 10)
+            console.error(`     … (+${unreadable.length - 10} more)`);
+        console.error(`   A last record cut short by a full disk is set aside by the next append on its own;`);
+        console.error(`   a line like these is damage: keep a copy of the file before touching it.`);
+    }
     if ((report.orphanIndices ?? []).length > 0) {
         const o = report.orphanIndices;
         console.error(`\n   Orphaned records (parent hash absent from the log):`);
@@ -2172,6 +2218,9 @@ async function cliAuditVerify() {
     if (forks.length > 0) {
         console.error(`\n   (Also ${forks.length} concurrent-append fork(s) — benign, see docs.)`);
     }
+    if (dups.length > 0) {
+        console.error(`\n   (Also ${dups.length} second copies of records, counted once, benign.)`);
+    }
     console.error(`\nFor compliance-graded evidence, treat the affected records as unverified.`);
     process.exit(2);
 }

package/dist/fleet-health.d.ts

@@ -45,6 +45,27 @@ export interface FleetHealth {
             detail: string;
         }>;
     };
+    /** The last full check of the audit chain (`audit-verify`, run by hand or daily by the indexing
+     *  server), or null when it never ran here. [LOCK] [HEALTH-SEES-THE-CHAIN] */
+    chain: {
+        checkedAt: string;
+        ageHours: number;
+        ok: boolean;
+        unique: number;
+        altered: number;
+        orphans: number;
+        unreadable: number;
+        duplicates: number;
+        reason: string | null;
+    } | null;
+    /** Entries the audit log refused today (chained as audit.append_failed, or still pending), and
+     *  records cut short today (audit.torn_tail). */
+    auditLog: {
+        refusedToday: number;
+        lastRefusal: string | null;
+        tornToday: number;
+        lastTornKept: string | null;
+    };
     /** The newest release for which verify-release passed on this machine, or null. */
     lastVerifiedRelease: string | null;
     /** Measured problems only. Empty means green. */
@@ -56,6 +77,8 @@ export declare const REINDEX_PER_HOUR_WARN = 30;
 export declare const DOUBLED_HOOK_EVENTS_WARN_PCT = 5;
 export declare const DOUBLED_MIN_EVENTS = 10;
 export declare const DOUBLED_WINDOW_MS = 2000;
+/** A full check older than this is reported: the indexing server runs one a day. */
+export declare const CHAIN_CHECK_STALE_HOURS = 48;
 export declare function fleetHealthPath(): string;
 /** The highest version with a verify-release marker; version order, not file time (ties). */
 export declare function lastVerifiedRelease(dir?: string): string | null;

package/dist/fleet-health.js

@@ -13,6 +13,7 @@ import { closeSync, existsSync, fstatSync, mkdirSync, openSync, readSync, readdi
 import { join } from "path";
 import { homedir } from "os";
 import { listServers } from "./server-registry.js";
+import { readVerifyState, pendingRefusals } from "./audit.js";
 import { claudeHookRegistrations } from "./install-claude-hook.js";
 export const REINDEX_PER_HOUR_WARN = 30;
 /** Doubled hook events above this share of the day's hook events raise a warning, once the day
@@ -20,6 +21,8 @@ export const REINDEX_PER_HOUR_WARN = 30;
 export const DOUBLED_HOOK_EVENTS_WARN_PCT = 5;
 export const DOUBLED_MIN_EVENTS = 10;
 export const DOUBLED_WINDOW_MS = 2000;
+/** A full check older than this is reported: the indexing server runs one a day. */
+export const CHAIN_CHECK_STALE_HOURS = 48;
 const TAIL_BYTES = 8 * 1024 * 1024;
 function ceHome() {
     return process.env.CONTEXTENGINE_HOME || join(homedir(), ".contextengine");
@@ -109,6 +112,8 @@ export function computeFleetHealth(opts = {}) {
     let lastHourWrites = 0, blocks = 0, refusals = 0, learningsSaved = 0, hookEvents = 0, doubledHookEvents = 0;
     const lastBlocks = [];
     let prevHook = null;
+    let refusedToday = 0, tornToday = 0;
+    let lastRefusal = null, lastTornKept = null;
     for (const r of records) {
         const t = Date.parse(r.ts);
         if (Number.isNaN(t))
@@ -127,6 +132,16 @@ export function computeFleetHealth(opts = {}) {
         }
         if (t < midnight)
             continue;
+        if (r.event === "audit.append_failed") {
+            refusedToday += Number(r.payload?.count ?? 0) || 0;
+            const errs = r.payload?.errors;
+            if (errs && Object.keys(errs).length > 0)
+                lastRefusal = Object.keys(errs)[0];
+        }
+        if (r.event === "audit.torn_tail") {
+            tornToday++;
+            lastTornKept = String(r.payload?.kept ?? "");
+        }
         if (r.event === "hook.block") {
             blocks++;
             lastBlocks.push({ ts: r.ts, kind: "pre-commit", detail: blockDetail(r.payload) });
@@ -161,6 +176,42 @@ export function computeFleetHealth(opts = {}) {
         warnings.push(`${lastHourWrites} shared-index writes in the last hour (ceiling ${REINDEX_PER_HOUR_WARN}): something saves in a loop`);
     if (refusals > 0)
         warnings.push(`${refusals} learnings-store refusal(s) today: a write looked like a wipe or a runaway import`);
+    // [LOCKED] [HEALTH-SEES-THE-CHAIN] - 2026-09-27
+    // [NEVER] report green while the audit chain failed its last check, or while the log refuses entries.
+    // WHY: fleet health read the audit log for counts only. On three broken logs (a stuck log whose
+    //      appends were all refused, missing history, 100 altered records) the verifier said FAILED
+    //      and health said 0 warnings (E2E_REVIEW_2026-09 B6-1). The chain is the product's claim.
+    // FIX: health never runs the check (26 s and 3.5 GB on 4.9M records, measured): it reads the
+    //      result every `audit-verify` leaves, which the indexing server refreshes daily in a separate
+    //      low-priority process. A failed check, a check older than CHAIN_CHECK_STALE_HOURS, refused
+    //      entries (chained as audit.append_failed or still pending) and records cut short today are
+    //      each a warning. [LOCK] [A-REFUSED-APPEND-IS-COUNTED-AND-CHAINED] [LOCK] [TORN-TAIL-IS-KEPT-AND-CHAINED]
+    const vs = readVerifyState();
+    const chain = vs
+        ? {
+            checkedAt: vs.checkedAt,
+            ageHours: Math.max(0, Math.round((now.getTime() - Date.parse(vs.checkedAt)) / 3_600_000)),
+            ok: vs.ok,
+            unique: vs.unique,
+            altered: vs.altered,
+            orphans: vs.orphans,
+            unreadable: vs.unreadable,
+            duplicates: vs.duplicates,
+            reason: vs.reason,
+        }
+        : null;
+    if (chain && !chain.ok)
+        warnings.push(`the audit chain did not verify at its last check (${chain.checkedAt.slice(0, 16).replace("T", " ")}Z): ${chain.reason ?? "see contextengine audit-verify"}`);
+    else if (chain && chain.ageHours > CHAIN_CHECK_STALE_HOURS)
+        warnings.push(`the audit chain was last checked ${chain.ageHours} h ago: run contextengine audit-verify`);
+    const pending = pendingRefusals();
+    if (pending.count > 0 && pending.error)
+        lastRefusal = pending.error; // the newest refusal wins
+    const refusedTotal = refusedToday + pending.count;
+    if (refusedTotal > 0)
+        warnings.push(`the audit log refused ${refusedTotal} entr${refusedTotal === 1 ? "y" : "ies"} today${lastRefusal ? ` (${lastRefusal})` : ""}: they are not in the log, and the gap is noted on the chain`);
+    if (tornToday > 0)
+        warnings.push(`${tornToday} audit record(s) were cut short today (a full disk?); the bytes are kept in ${lastTornKept}`);
     for (const w of report.warnings)
         if (/index on their own/.test(w))
             warnings.push(w);
@@ -172,6 +223,8 @@ export function computeFleetHealth(opts = {}) {
         reindex: { lastHourWrites, perCorpus, threshold: REINDEX_PER_HOUR_WARN },
         claudeHooks,
         today: { hookEvents, doubledHookEvents, blocks, refusals, learningsSaved, lastBlocks: lastBlocks.slice(-3) },
+        chain,
+        auditLog: { refusedToday: refusedTotal, lastRefusal, tornToday, lastTornKept },
         lastVerifiedRelease: lastVerifiedRelease(),
         warnings,
     };
@@ -191,6 +244,9 @@ export function formatFleetHealth(h) {
     lines.push(`  servers ${h.servers.total}: ${h.servers.indexers} indexing, ${h.servers.readers} reading, ${h.servers.stale.length} on an old build`);
     lines.push(`  shared-index writes last hour: ${h.reindex.lastHourWrites} (ceiling ${h.reindex.threshold})`);
     lines.push(`  today: ${h.today.blocks} block(s) prevented, ${h.today.refusals} store refusal(s), ${h.today.learningsSaved} learning(s) saved`);
+    lines.push(h.chain
+        ? `  audit chain: ${h.chain.ok ? "verified" : "FAILED"} ${h.chain.ageHours} h ago, ${h.chain.unique} record(s)${h.chain.duplicates ? `, ${h.chain.duplicates} copies counted once` : ""}; ${h.auditLog?.refusedToday ?? 0} entr(ies) refused today`
+        : `  audit chain: not checked on this machine yet (the indexing server runs a full check daily; or run contextengine audit-verify)`);
     lines.push(`  claude code: ${h.today.hookEvents} hook event(s) today, ${h.today.doubledHookEvents} doubled; registrations ${h.claudeHooks ? Object.entries(h.claudeHooks).map(([ev, n]) => `${ev}=${n}`).join(" ") : "no settings.json"}`);
     for (const b of h.today.lastBlocks)
         lines.push(`    ${b.ts.slice(11, 19)}Z ${b.kind}: ${b.detail}`);

package/dist/http-server.js

@@ -266,13 +266,23 @@ function handleEvents(req, res) {
             return;
         }
         // All valid — write them to audit log via safeAppend.
+        // [LOCK] [RECEIVER-SAYS-WHAT-WAS-WRITTEN] (src/cli.ts emit-event): count what the log took, and
+        // answer 503 when it refused any. On 2026-09-27 a stuck log answered {"ok":true,"written":25}
+        // with 0 of 25 recorded (E2E_REVIEW_2026-09 B1-1).
         let written = 0;
+        let failed = 0;
         for (const ev of batch.events) {
             const actor = typeof ev.actor === "string" ? ev.actor : "browser-ext";
             // event/payload were validated above — cast is safe.
             // [LOCK] [CAPTURE-IS-REDACTED-AT-THE-DOOR]: redact before the append, never after.
-            safeAppend(ev.event, prepareCapturedPayload(ev.payload, ev.event), actor);
-            written++;
+            if (safeAppend(ev.event, prepareCapturedPayload(ev.payload, ev.event), actor))
+                written++;
+            else
+                failed++;
+        }
+        if (failed > 0) {
+            sendJson(req, res, 503, { ok: false, error: "audit_append_failed", written, failed });
+            return;
         }
         sendJson(req, res, 200, { ok: true, written });
     });

package/dist/index.js

@@ -13,7 +13,7 @@ import { loadEmbeddingStore, compactEmbeddingStore } from "./embedding-store.js"
 import { sharedIndexEnabled, corpusId, electIndexer, writeSharedIndex, readSharedIndex, sharedIndexMtime, } from "./shared-index.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, autoRotateAuditLog, safeAppend } from "./audit.js";
+import { verifyChain, readAuditLog, filterByRange, autoRotateAuditLog, safeAppend, readVerifyState } from "./audit.js";
 import { registerServer, listServers, formatServers, liveDaemonPid } from "./server-registry.js";
 import { secureCeHome } from "./ce-home.js";
 import { QUOTED_TEXT_NOTE } from "./framing.js";
@@ -26,7 +26,8 @@ import { communityRulesToChunks, mergeWithDedup, loadCommunityStore, } from "./c
 import { readFileSync, existsSync, watch, statSync, writeFileSync, mkdirSync } from "fs";
 import { basename, join, dirname } from "path";
 import { homedir } from "os";
-import { execSync } from "child_process";
+import { execSync, spawn } from "child_process";
+import { setPriority } from "os";
 import { scanCodeDir } from "./code-chunker.js";
 import { fileURLToPath } from "url";
 import { TOOL_COUNT, FREE_TOOL_COUNT, PREMIUM_TOOL_NAMES } from "./tools-manifest.js";
@@ -460,6 +461,42 @@ function evaluateRole(reason) {
 }
 let healthTick = 0;
 let lastStaleCount = -1;
+const SERVER_STARTED_AT = Date.now();
+let lastChainCheckSpawn = 0;
+/**
+ * The indexing server starts the daily full check of the audit chain, in its own process.
+ * [LOCK] [HEALTH-SEES-THE-CHAIN] (src/fleet-health.ts): the check costs 26 s and 3.5 GB on 4.9M
+ * records (measured 2026-09-27), so it never runs in this long-lived process, whose event loop
+ * serves the receiver and the tools. A separate low-priority `audit-verify --scheduled`, at most
+ * one attempt an hour, never in the first 10 minutes after a start, one at a time across processes
+ * (its own lock). CONTEXTENGINE_CHAIN_CHECK=0 turns it off.
+ */
+function maybeScheduleChainCheck() {
+    if (role !== "indexer" || process.env.CONTEXTENGINE_CHAIN_CHECK === "0")
+        return;
+    const now = Date.now();
+    if (now - SERVER_STARTED_AT < 10 * 60_000 || now - lastChainCheckSpawn < 60 * 60_000)
+        return;
+    const state = readVerifyState();
+    if (state && now - Date.parse(state.checkedAt) < 24 * 3_600_000)
+        return;
+    lastChainCheckSpawn = now;
+    try {
+        const cli = join(dirname(fileURLToPath(import.meta.url)), "cli.js");
+        const child = spawn(process.execPath, [cli, "audit-verify", "--scheduled"], { stdio: "ignore", detached: true, env: process.env });
+        if (child.pid) {
+            try {
+                setPriority(child.pid, 10);
+            }
+            catch { /* the check still runs, at normal priority */ }
+        }
+        child.unref();
+        console.error(`[ContextEngine] 🔎 daily audit chain check started (pid ${child.pid ?? "?"})`);
+    }
+    catch (err) {
+        console.error(`[ContextEngine] ⚠ could not start the daily audit chain check: ${err.message}`);
+    }
+}
 /**
  * The indexer writes ~/.contextengine/fleet-health.json once a minute: version drift, reindex
  * rate, today's blocks and refusals, the last verified release. Every surface reads that file.
@@ -475,6 +512,7 @@ function publishHealth() {
         }
         if (role === "indexer")
             writeFleetHealth(h);
+        maybeScheduleChainCheck();
     }
     catch (err) {
         console.error(`[ContextEngine] ⚠ fleet health failed: ${err.message}`);
@@ -1423,7 +1461,7 @@ async function main() {
     const runAutoRotate = () => {
         try {
             const o = autoRotateAuditLog();
-            if (o.action === "rotated" || o.action === "refused" || o.action === "error" || o.action === "in_progress") {
+            if (o.action === "rotated" || o.action === "refused" || o.action === "error" || o.action === "in_progress" || o.action === "finished") {
                 console.error(`[ContextEngine] 📦 audit auto-rotate (${o.action}): ${o.detail}`);
             }
         }

package/dist/secret-shapes.js

@@ -50,13 +50,16 @@ export const SECRET_SHAPES = [
     { id: "api_key_header", re: /(\bx-api-key:\s*)[^\s'"]{8,}/gi, keepPrefix: true },
     // name = value, the long tail. Skips variables, env lookups, paths, placeholders already
     // redacted, type names and function calls.
-    // A name that is PASS alone or ends in a separator plus PASS (SMTP_PASS, DB_PASS, db.pass) counts
-    // too: a real mail password sat in the shared index under SMTP_PASS (E2E_REVIEW_2026-09 A6-3).
-    // The separator keeps bypass and compass out.
+    // A name that ends in a separator plus PASS (SMTP_PASS, DB_PASS, db.pass) counts too: a real mail
+    // password sat in the shared index under SMTP_PASS (E2E_REVIEW_2026-09 A6-3). The separator keeps
+    // bypass and compass out. A bare `pass` counts only before an equals sign, or before a quoted value
+    // after a colon (nodemailer's auth block): as first shipped in 2.10.0 it also took prose (a README's
+    // "PII pass" list) and code (a count of passing checks in agents.ts), which the public-release scan
+    // refused.
     {
         id: "credential_assignment",
         // A backtick opens a value too: "password: `...`" in Markdown, found in the real log.
-        re: /(\b(?:[\w.-]*(?:password|passwd|pwd|secret|token|api[_-]?key|apikey|access[_-]?key|private[_-]?key|client[_-]?secret)|(?:[\w.-]*[_.-])?pass)["'`]?\s*[:=]\s*["'`]?)(?![$<{*/~.[]|process\.env|os\.environ|getenv)[^\s'"`,;)}\]]{6,}/gi,
+        re: /(\b(?:[\w.-]*(?:password|passwd|pwd|secret|token|api[_-]?key|apikey|access[_-]?key|private[_-]?key|client[_-]?secret)|[\w.-]*[_.-]pass|pass(?=["'`]?\s*=|["'`]?\s*:\s*["'`]))["'`]?\s*[:=]\s*["'`]?)(?![$<{*/~.[]|process\.env|os\.environ|getenv)[^\s'"`,;)}\]]{6,}/gi,
         keepPrefix: true,
         skip: (value, after) => after.startsWith("(") ||
             (/^[A-Za-z_$][\w$.]*\(/.test(value) && after.startsWith(")")) || // getToken(user), not a value

package/package.json

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