mergen-server 1.4.0

package/dist/intelligence/agent-identity.js

@@ -0,0 +1,115 @@
+import { createHmac, timingSafeEqual, randomBytes } from "crypto";
+import fs from "fs";
+import path from "path";
+import { DATA_DIR } from "../sensor/paths.js";
+import logger from "../sensor/logger.js";
+const TOKEN_RECORD_DIR = path.join(DATA_DIR, "agent-tokens");
+const DEFAULT_TTL_MS = 365 * 24 * 60 * 60 * 1e3;
+let _tokenSecret = "";
+function setAgentTokenSecret(secret) {
+  _tokenSecret = secret;
+}
+function sign(payload) {
+  const body = JSON.stringify(payload);
+  const sig = createHmac("sha256", _tokenSecret).update(body).digest("hex");
+  return Buffer.from(JSON.stringify({ payload, sig }), "utf8").toString("base64url");
+}
+function issueToken(agentId, ttlMs = DEFAULT_TTL_MS, parentAgentId, userId) {
+  if (!_tokenSecret) {
+    throw new Error("agent-identity: token secret not initialized \u2014 setAgentTokenSecret must run before issueToken");
+  }
+  const payload = {
+    agentId,
+    issuedAt: Date.now(),
+    expiresAt: Date.now() + ttlMs,
+    nonce: randomBytes(8).toString("hex"),
+    ...parentAgentId ? { parentAgentId } : {},
+    ...userId ? { userId } : {}
+  };
+  const token = sign(payload);
+  _recordIssuedToken(agentId, payload.issuedAt, payload.expiresAt, parentAgentId, userId);
+  return token;
+}
+function verifyToken(token) {
+  if (!_tokenSecret) return null;
+  let decoded;
+  try {
+    decoded = JSON.parse(Buffer.from(token, "base64url").toString("utf8"));
+  } catch {
+    return null;
+  }
+  if (!decoded.payload?.agentId || !decoded.sig) return null;
+  const body = JSON.stringify(decoded.payload);
+  const expected = createHmac("sha256", _tokenSecret).update(body).digest("hex");
+  const expectedBuf = Buffer.from(expected, "hex");
+  let actualBuf;
+  try {
+    actualBuf = Buffer.from(decoded.sig, "hex");
+  } catch {
+    return null;
+  }
+  if (expectedBuf.length !== actualBuf.length) return null;
+  if (!timingSafeEqual(expectedBuf, actualBuf)) return null;
+  if (Date.now() > decoded.payload.expiresAt) return null;
+  return { agentId: decoded.payload.agentId, parentAgentId: decoded.payload.parentAgentId, userId: decoded.payload.userId };
+}
+let _warnedUnauthenticated = false;
+let _warnedNoSecretWithToken = false;
+function resolveAgentIdentity() {
+  const token = process.env.MERGEN_AGENT_TOKEN;
+  if (token) {
+    const verified = verifyToken(token);
+    if (verified) return { agentId: verified.agentId, verified: true, parentAgentId: verified.parentAgentId, userId: verified.userId };
+    if (!_tokenSecret && !_warnedNoSecretWithToken) {
+      logger.warn("agent-identity: MERGEN_AGENT_TOKEN is set but no signing secret is configured on this server \u2014 cannot verify, treating as unverified");
+      _warnedNoSecretWithToken = true;
+    } else {
+      logger.warn("agent-identity: MERGEN_AGENT_TOKEN is set but invalid or expired \u2014 ignoring");
+    }
+  }
+  const raw = process.env.MERGEN_AGENT_ID;
+  if (raw && !_warnedUnauthenticated) {
+    logger.warn(
+      "agent-identity: MERGEN_AGENT_ID is set but unauthenticated (no valid MERGEN_AGENT_TOKEN) \u2014 it will be used for reputation/session labeling only, not for agent-profile permissions or policy conditions.agentIds matching. Run `mergen-server agent-register <profile-id>` to issue a verified token."
+    );
+    _warnedUnauthenticated = true;
+  }
+  return { agentId: raw, verified: false };
+}
+function _recordIssuedToken(agentId, issuedAt, expiresAt, parentAgentId, userId) {
+  try {
+    fs.mkdirSync(TOKEN_RECORD_DIR, { recursive: true, mode: 448 });
+    const file = path.join(TOKEN_RECORD_DIR, `${agentId}.json`);
+    const record = { agentId, issuedAt, expiresAt, ...parentAgentId ? { parentAgentId } : {}, ...userId ? { userId } : {} };
+    fs.writeFileSync(file, JSON.stringify(record, null, 2), { encoding: "utf8", mode: 384 });
+  } catch (err) {
+    logger.warn({ err, agentId }, "agent-identity: failed to persist issued-token record (non-fatal \u2014 token is still valid)");
+  }
+}
+function listIssuedTokenRecords() {
+  try {
+    if (!fs.existsSync(TOKEN_RECORD_DIR)) return [];
+    return fs.readdirSync(TOKEN_RECORD_DIR).filter((f) => f.endsWith(".json")).map((f) => {
+      try {
+        return JSON.parse(fs.readFileSync(path.join(TOKEN_RECORD_DIR, f), "utf8"));
+      } catch {
+        return null;
+      }
+    }).filter((r) => r !== null).sort((a, b) => b.issuedAt - a.issuedAt);
+  } catch {
+    return [];
+  }
+}
+function _resetAgentIdentityForTesting() {
+  _tokenSecret = "";
+  _warnedUnauthenticated = false;
+  _warnedNoSecretWithToken = false;
+}
+export {
+  _resetAgentIdentityForTesting,
+  issueToken,
+  listIssuedTokenRecords,
+  resolveAgentIdentity,
+  setAgentTokenSecret,
+  verifyToken
+};

package/dist/intelligence/agent-pipeline.js

@@ -0,0 +1,329 @@
+import { fixActionToCommand } from "./causal.js";
+import { extractCommand } from "./autonomy.js";
+import { computeBlastRadius } from "./blast-radius.js";
+import { deriveRollback } from "./rollback.js";
+import { getStatsForTag } from "./calibration.js";
+import { hasRecentOverride, dominantOverrideReason } from "./override-corpus.js";
+import { getAutopilotLevel, autopilotLevelPermits, classifyCommandRisk, analyzeSemanticRisk } from "./action-risk.js";
+import { postmortemStore } from "./postmortem-store.js";
+import logger from "../sensor/logger.js";
+function validateHypothesis(hyp, chain) {
+  const contradictions = [];
+  let coverageScore = 0;
+  const errorTexts = chain.errors.map((e) => e.message.toLowerCase());
+  const tagParts = hyp.tag.replace(/^infra_/, "").split("_");
+  const tagMatches = tagParts.filter(
+    (part) => part.length >= 4 && errorTexts.some((msg) => msg.includes(part))
+  );
+  coverageScore += tagMatches.length > 0 ? 0.3 : 0;
+  const evidenceMatched = hyp.evidence.filter((ev) => {
+    const evLower = ev.toLowerCase();
+    return chain.errors.some((e) => e.message.toLowerCase().includes(evLower.slice(0, 20))) || chain.correlatedNetwork.some(
+      (n) => n.url.toLowerCase().includes(evLower.slice(0, 20)) || (n.error ?? "").toLowerCase().includes(evLower.slice(0, 20))
+    );
+  });
+  coverageScore += Math.min(0.4, evidenceMatched.length * 0.1);
+  coverageScore += hyp.causalPath.length >= 2 ? 0.3 : 0;
+  const isNetworkHyp = /network|dns|timeout|latency|503|502|429|rate_limit/i.test(hyp.tag);
+  if (isNetworkHyp && chain.correlatedNetwork.length === 0 && chain.errors.length > 0) {
+    contradictions.push("Network hypothesis but no network events observed in window");
+    coverageScore -= 0.2;
+  }
+  const isOomHyp = /oom|memory|heap|killed/i.test(hyp.tag);
+  if (isOomHyp && chain.correlatedBackend.length === 0 && chain.errors.length > 0) {
+    const oomInErrors = chain.errors.some(
+      (e) => /oom|memory|heap|killed|enomem/i.test(e.message)
+    );
+    if (!oomInErrors) {
+      contradictions.push("OOM hypothesis but no OOM-related signals in error messages");
+      coverageScore -= 0.15;
+    }
+  }
+  if (chain.errors.length > 0 && hyp.evidence.length === 0) {
+    contradictions.push("Hypothesis has no explicit evidence \u2014 may be a weak signal match");
+  }
+  const corpusStats = postmortemStore.tagStats().find((s) => s.tag === hyp.tag);
+  const precedentCount = corpusStats?.count ?? 0;
+  const avgMttrMs = corpusStats?.avgMttrMs ?? null;
+  if (precedentCount > 0) {
+    coverageScore += Math.min(0.2, precedentCount * 0.05);
+  }
+  return {
+    score: Math.max(0, Math.min(1, coverageScore)),
+    contradictions,
+    corpusPrecedent: precedentCount > 0,
+    precedentCount,
+    avgMttrMs
+  };
+}
+function buildExecutionPlan(hyp, chain) {
+  const command = hyp.fixAction ? fixActionToCommand(hyp.fixAction) : hyp.fixHint ? extractCommand(hyp.fixHint) : null;
+  if (!command) return null;
+  const rollback = deriveRollback(command, "");
+  const rollbackCommand = rollback.type === "command" ? rollback.command : null;
+  const risk = classifyCommandRisk(command);
+  const estimatedRisk = risk === "restart" ? "low" : risk === "full" ? "high" : "medium";
+  const reversible = rollbackCommand !== null || /restart|rollout|deploy/i.test(command);
+  const steps = [
+    { order: 1, action: "Confirm current error state", command: "triage_incident (diagnosis only)" },
+    { order: 2, action: `Execute fix: ${hyp.fixHint?.split("\n")[0] ?? command}`, command }
+  ];
+  if (rollbackCommand) {
+    steps.push({ order: 3, action: "Validate resolution", command: "validate_fix" });
+    steps.push({ order: 4, action: "Rollback if REGRESSED", command: rollbackCommand });
+  } else {
+    steps.push({ order: 3, action: "Validate resolution (manual rollback required if REGRESSED)", command: "validate_fix" });
+  }
+  const requiresApproval = estimatedRisk === "high" || !reversible;
+  return {
+    command,
+    rollbackCommand,
+    steps,
+    estimatedRisk,
+    requiresApproval,
+    reversible
+  };
+}
+function critiqueExecutionPlan(plan, hyp, validation, service, opts) {
+  const concerns = [];
+  let verdict = "proceed";
+  const blastRadius = computeBlastRadius(plan.command);
+  const dtLabel = blastRadius.estimatedDowntimeMs != null ? `~${Math.round(blastRadius.estimatedDowntimeMs / 1e3)}s downtime` : "unknown downtime";
+  const blastSummary = `${blastRadius.scope} scope \xB7 ${dtLabel} \xB7 ${blastRadius.reversible ? "reversible" : "IRREVERSIBLE"}`;
+  if (!blastRadius.reversible) {
+    const rollbackNote = blastRadius.rollbackCommand ?? "no rollback path";
+    concerns.push(`Command is IRREVERSIBLE: ${rollbackNote}`);
+    verdict = "block";
+  }
+  if (blastRadius.dataAtRisk) {
+    concerns.push("Data mutation detected \u2014 command may modify persistent state");
+    verdict = verdict === "proceed" ? "review" : verdict;
+  }
+  if (plan.estimatedRisk === "high") {
+    concerns.push(`High-risk command tier: ${classifyCommandRisk(plan.command)}`);
+    verdict = verdict === "proceed" ? "review" : verdict;
+  }
+  const semantic = analyzeSemanticRisk(plan.command, {
+    service,
+    service_time: opts.service_time
+  });
+  if (semantic.blocked) {
+    concerns.push(semantic.reason ?? "Semantic safety block");
+    verdict = "block";
+  } else if (semantic.risk === "high") {
+    concerns.push(semantic.reason ?? "High semantic risk detected");
+    verdict = verdict === "proceed" ? "review" : verdict;
+  }
+  if (validation.contradictions.length > 0) {
+    concerns.push(...validation.contradictions.map((c) => `Validation: ${c}`));
+    if (validation.score < 0.3) {
+      verdict = "block";
+    } else if (validation.score < 0.6) {
+      verdict = verdict === "proceed" ? "review" : verdict;
+    }
+  }
+  const now = opts.service_time ?? {
+    dayOfWeek: (/* @__PURE__ */ new Date()).getUTCDay(),
+    hourOfDay: (/* @__PURE__ */ new Date()).getUTCHours()
+  };
+  const corpusConflict = hasRecentOverride(hyp.tag, service, now.dayOfWeek, now.hourOfDay);
+  if (corpusConflict) {
+    const reason = dominantOverrideReason(hyp.tag, service) ?? "override corpus conflict";
+    concerns.push(`Override corpus: ${reason}`);
+    verdict = verdict === "proceed" ? "review" : verdict;
+  }
+  const autopilotLevel = getAutopilotLevel();
+  const levelConflict = !autopilotLevelPermits(plan.command, autopilotLevel);
+  if (levelConflict) {
+    concerns.push(`MERGEN_AUTOPILOT_LEVEL=${autopilotLevel} does not permit ${classifyCommandRisk(plan.command)}-tier commands`);
+    verdict = "block";
+  }
+  if (validation.score < 0.2 && validation.contradictions.length === 0) {
+    concerns.push("Low validation score \u2014 hypothesis may not explain all observed signals");
+    verdict = verdict === "proceed" ? "review" : verdict;
+  }
+  return {
+    verdict,
+    concerns,
+    blastRadiusSummary: blastSummary,
+    corpusConflict,
+    levelConflict
+  };
+}
+function guardedAction(hyp, plan, critique, threshold) {
+  const execConfidence = hyp.remediationConfidence ?? hyp.confidenceScore ?? 0;
+  if (critique.verdict === "block") {
+    return {
+      verdict: "block",
+      blockReason: critique.concerns[0] ?? "Critic stage blocked execution"
+    };
+  }
+  if (execConfidence < threshold) {
+    return {
+      verdict: "block",
+      blockReason: `Remediation confidence ${Math.round(execConfidence * 100)}% is below ${Math.round(threshold * 100)}% threshold`
+    };
+  }
+  if (critique.verdict === "review" || plan.requiresApproval) {
+    return { verdict: "review", blockReason: null };
+  }
+  return { verdict: "proceed", blockReason: null };
+}
+function runAgentPipeline(chain, opts = {}) {
+  const threshold = opts.executionThreshold ?? 0.85;
+  const service = opts.service ?? "unknown";
+  const stages = [];
+  const errorCount = chain.errors.length;
+  const netCount = chain.correlatedNetwork.filter((n) => n.status >= 400).length;
+  stages.push({
+    name: "detector",
+    status: "pass",
+    summary: `${errorCount} console error${errorCount !== 1 ? "s" : ""}, ${netCount} network failure${netCount !== 1 ? "s" : ""}`,
+    detail: chain.chain.length > 0 ? `${chain.chain.length} causal events in timeline` : void 0
+  });
+  const topHyp = chain.hypotheses[0] ?? null;
+  if (!topHyp) {
+    stages.push({
+      name: "hypothesis",
+      status: "block",
+      summary: "No hypothesis generated \u2014 insufficient signals for root cause identification"
+    });
+    return { stages, topHypothesis: null, validation: null, plan: null, critique: null, verdict: "block", blockReason: "No hypothesis generated" };
+  }
+  const calStats = getStatsForTag(topHyp.tag);
+  const calLabel = calStats?.isEmpirical ? `calibrated (${calStats.verdicts} verdicts)` : "prior estimate";
+  const pct = Math.round((topHyp.confidenceScore ?? 0) * 100);
+  stages.push({
+    name: "hypothesis",
+    status: "pass",
+    summary: `${topHyp.confidence} (${pct}%) \u2014 ${topHyp.summary.slice(0, 80)}`,
+    detail: `[${calLabel}]  ${chain.hypotheses.length} total hypotheses, ${chain.suppressedHypotheses.length} suppressed`
+  });
+  const validation = validateHypothesis(topHyp, chain);
+  const validStatus = validation.score >= 0.6 ? "pass" : validation.score >= 0.3 ? "warn" : "block";
+  stages.push({
+    name: "validator",
+    status: validStatus,
+    summary: `Coverage score ${Math.round(validation.score * 100)}%` + (validation.corpusPrecedent ? ` \xB7 ${validation.precedentCount} corpus match${validation.precedentCount !== 1 ? "es" : ""}` : " \xB7 no corpus precedent") + (validation.avgMttrMs != null ? ` \xB7 avg MTTR ${Math.round(validation.avgMttrMs / 6e4)}m` : ""),
+    detail: validation.contradictions.length > 0 ? validation.contradictions.join("; ") : void 0
+  });
+  const plan = buildExecutionPlan(topHyp, chain);
+  if (!plan) {
+    stages.push({
+      name: "planner",
+      status: "warn",
+      summary: "No executable command \u2014 fix requires manual intervention"
+    });
+    return {
+      stages,
+      topHypothesis: topHyp,
+      validation,
+      plan: null,
+      critique: null,
+      verdict: "review",
+      blockReason: "No executable command in fix hint"
+    };
+  }
+  stages.push({
+    name: "planner",
+    status: plan.estimatedRisk === "high" ? "warn" : "pass",
+    summary: `\`${plan.command}\` \xB7 risk: ${plan.estimatedRisk} \xB7 ${plan.reversible ? "reversible" : "IRREVERSIBLE"}`,
+    detail: plan.rollbackCommand ? `rollback: \`${plan.rollbackCommand}\`` : "no rollback path"
+  });
+  const critique = critiqueExecutionPlan(plan, topHyp, validation, service, opts);
+  stages.push({
+    name: "critic",
+    status: critique.verdict === "proceed" ? "pass" : critique.verdict === "review" ? "warn" : "block",
+    summary: `${critique.blastRadiusSummary} \xB7 ${critique.concerns.length === 0 ? "no concerns" : `${critique.concerns.length} concern${critique.concerns.length !== 1 ? "s" : ""}`}`,
+    detail: critique.concerns.length > 0 ? critique.concerns.slice(0, 3).join("; ") : void 0
+  });
+  const guard = guardedAction(topHyp, plan, critique, threshold);
+  stages.push({
+    name: "guard",
+    status: guard.verdict === "proceed" ? "pass" : guard.verdict === "review" ? "warn" : "block",
+    summary: guard.verdict.toUpperCase() + (guard.blockReason ? ` \u2014 ${guard.blockReason}` : "") + (guard.verdict === "proceed" ? ` (remediation confidence ${Math.round((topHyp.remediationConfidence ?? topHyp.confidenceScore ?? 0) * 100)}% \u2265 ${Math.round(threshold * 100)}%)` : "")
+  });
+  logger.debug({
+    service,
+    tag: topHyp.tag,
+    validationScore: Math.round(validation.score * 100),
+    pipelineVerdict: guard.verdict,
+    stages: stages.map((s) => `${s.name}:${s.status}`).join(",")
+  }, "agent-pipeline: complete");
+  return {
+    stages,
+    topHypothesis: topHyp,
+    validation,
+    plan,
+    critique,
+    verdict: guard.verdict,
+    blockReason: guard.blockReason
+  };
+}
+function renderPipelineStages(stages) {
+  const icon = (s) => s === "pass" ? "\u2705" : s === "warn" ? "\u26A0\uFE0F" : "\u{1F6AB}";
+  const lines = ["### Pipeline", ""];
+  for (const stage of stages) {
+    lines.push(`${icon(stage.status)} **${stage.name}**: ${stage.summary}`);
+    if (stage.detail) lines.push(`   _${stage.detail}_`);
+  }
+  return lines.join("\n");
+}
+const _hooks = [];
+function registerGovernanceHook(hook) {
+  _hooks.push(hook);
+}
+function clearGovernanceHooks() {
+  _hooks.length = 0;
+}
+async function runAgentPipelineAsync(chain, opts = {}) {
+  const result = runAgentPipeline(chain, opts);
+  if (result.verdict === "block" || !result.topHypothesis || !result.plan) {
+    return result;
+  }
+  const ctx = {
+    chain,
+    hypothesis: result.topHypothesis,
+    plan: result.plan,
+    opts
+  };
+  for (let i = 0; i < _hooks.length; i++) {
+    const hook = _hooks[i];
+    try {
+      const hookRes = await hook(ctx);
+      const status = hookRes.verdict === "proceed" ? "pass" : hookRes.verdict === "review" ? "warn" : "block";
+      result.stages.push({
+        name: `pre-execution-hook-${i + 1}`,
+        status,
+        summary: hookRes.reason ?? `Hook ${i + 1} returned ${hookRes.verdict}`
+      });
+      if (hookRes.verdict === "block") {
+        result.verdict = "block";
+        result.blockReason = hookRes.reason ?? `Blocked by pre-execution hook ${i + 1}`;
+        break;
+      } else if (hookRes.verdict === "review") {
+        if (result.verdict === "proceed") {
+          result.verdict = "review";
+        }
+      }
+    } catch (err) {
+      logger.error({ err, hookIndex: i }, "agent-pipeline: async pre-execution hook failed");
+      result.stages.push({
+        name: `pre-execution-hook-${i + 1}`,
+        status: "warn",
+        summary: `Hook failed with error: ${err.message || err}`
+      });
+      if (result.verdict === "proceed") {
+        result.verdict = "review";
+      }
+    }
+  }
+  return result;
+}
+export {
+  clearGovernanceHooks,
+  registerGovernanceHook,
+  renderPipelineStages,
+  runAgentPipeline,
+  runAgentPipelineAsync
+};

package/dist/intelligence/agent-profiles.js

@@ -0,0 +1,81 @@
+import fs from "fs";
+import path from "path";
+import { DATA_DIR, zeroRetentionMode } from "../sensor/paths.js";
+import logger from "../sensor/logger.js";
+const PROFILES_FILE = path.join(DATA_DIR, "agent-profiles.json");
+let _profiles = [];
+let _loaded = false;
+function load(force = false) {
+  if (_loaded && !force) return;
+  _loaded = true;
+  if (!fs.existsSync(PROFILES_FILE)) {
+    _profiles = [];
+    return;
+  }
+  try {
+    const raw = JSON.parse(fs.readFileSync(PROFILES_FILE, "utf8"));
+    _profiles = raw?.version === 1 && Array.isArray(raw.profiles) ? raw.profiles : [];
+  } catch {
+    _profiles = [];
+  }
+}
+function persist() {
+  if (zeroRetentionMode()) return;
+  try {
+    fs.mkdirSync(DATA_DIR, { recursive: true });
+    const tmp = `${PROFILES_FILE}.tmp.${process.pid}`;
+    fs.writeFileSync(tmp, JSON.stringify({ version: 1, profiles: _profiles }), "utf8");
+    fs.renameSync(tmp, PROFILES_FILE);
+  } catch (err) {
+    logger.warn({ err }, "agent-profiles: persist failed");
+  }
+}
+function listProfiles() {
+  load();
+  return [..._profiles];
+}
+function getProfile(id) {
+  load();
+  return _profiles.find((p) => p.id === id) ?? null;
+}
+function saveProfile(profile) {
+  load(true);
+  const idx = _profiles.findIndex((p) => p.id === profile.id);
+  if (idx >= 0) _profiles[idx] = profile;
+  else _profiles.push(profile);
+  persist();
+}
+function deleteProfile(id) {
+  load(true);
+  const before = _profiles.length;
+  _profiles = _profiles.filter((p) => p.id !== id);
+  if (_profiles.length < before) {
+    persist();
+    return true;
+  }
+  return false;
+}
+function checkAgentProfile(toolName, service, verifiedAgentId) {
+  const agentId = verifiedAgentId;
+  if (!agentId) return null;
+  load();
+  const profile = _profiles.find((p) => p.id === agentId);
+  if (!profile) return null;
+  if (profile.blockedTools.includes(toolName)) {
+    return `Agent profile "${profile.name}" (${agentId}) is not permitted to call ${toolName}`;
+  }
+  if (profile.allowedTools.length > 0 && !profile.allowedTools.includes(toolName)) {
+    return `Agent profile "${profile.name}" (${agentId}) is restricted to: ${profile.allowedTools.join(", ")}`;
+  }
+  if (service && profile.allowedServices.length > 0 && !profile.allowedServices.includes(service)) {
+    return `Agent profile "${profile.name}" (${agentId}) is not permitted to target service: ${service}`;
+  }
+  return null;
+}
+export {
+  checkAgentProfile,
+  deleteProfile,
+  getProfile,
+  listProfiles,
+  saveProfile
+};

package/dist/intelligence/ai-commit.js

@@ -0,0 +1,16 @@
+const AI_AUTHOR_RE = /\b(claude|cursor|copilot|windsurf|codeium|tabnine|devin|ghostwriter|codex)\b/i;
+const AI_SUMMARY_RE = /\b(claude|cursor|copilot|windsurf|codeium|tabnine|devin|ghostwriter|codex)\b|co-authored-by:\s*(claude|cursor|copilot|windsurf|codeium|devin)|generated (by|with) (ai|claude|cursor|copilot)|ai[- ]generated|ai[- ]written|auto[- ]generated by/i;
+function detectAiCommit(summary, author) {
+  const text = [summary, author ?? ""].join(" ");
+  const authorMatch = author ? AI_AUTHOR_RE.exec(author) : null;
+  if (authorMatch) return { detected: true, tool: authorMatch[1].toLowerCase() };
+  const summaryMatch = AI_SUMMARY_RE.exec(text);
+  if (summaryMatch) {
+    const tool = (summaryMatch[1] ?? summaryMatch[2] ?? "ai").toLowerCase();
+    return { detected: true, tool };
+  }
+  return { detected: false, tool: null };
+}
+export {
+  detectAiCommit
+};

package/dist/intelligence/approval-analytics.js

@@ -0,0 +1,42 @@
+import { getRuleFirings, getHitlStats } from "./gate-analytics.js";
+import { getStores } from "../storage/store-registry.js";
+const MIN_DECISIONS_FOR_OVERRIDE_RATE = 2;
+const MIN_TRIGGERS_FOR_NOISY = 5;
+const NON_BLOCKING_BLUNDER_TYPES = /* @__PURE__ */ new Set(["credential_issued"]);
+async function computeApprovalAnalytics(topN = 10) {
+  const blunders = await getStores().blunders.list();
+  const commandCounts = /* @__PURE__ */ new Map();
+  for (const b of blunders) {
+    if (NON_BLOCKING_BLUNDER_TYPES.has(b.blunderType)) continue;
+    const key = b.command ?? "(no command recorded)";
+    commandCounts.set(key, (commandCounts.get(key) ?? 0) + 1);
+  }
+  const topBlockedActions = [...commandCounts.entries()].map(([command, count]) => ({ command, count })).sort((a, b) => b.count - a.count).slice(0, topN);
+  const hitlStats = getHitlStats();
+  const overriddenRules = [];
+  const ruleLatency = [];
+  for (const [ruleId, stats] of hitlStats) {
+    const total = stats.approvals + stats.denials;
+    if (total >= MIN_DECISIONS_FOR_OVERRIDE_RATE) {
+      overriddenRules.push({ ruleId, approvals: stats.approvals, denials: stats.denials, overrideRate: Math.round(stats.approvals / total * 1e3) / 1e3 });
+    }
+    ruleLatency.push({
+      ruleId,
+      avgApprovalLatencyMs: stats.approvals > 0 ? Math.round(stats.totalApprovalLatencyMs / stats.approvals) : 0,
+      avgDenialLatencyMs: stats.denials > 0 ? Math.round(stats.totalDenialLatencyMs / stats.denials) : 0
+    });
+  }
+  overriddenRules.sort((a, b) => b.overrideRate - a.overrideRate || b.approvals - a.approvals);
+  const firings = getRuleFirings();
+  const hitlByRule = new Map(overriddenRules.map((r) => [r.ruleId, r.overrideRate]));
+  const noisyRules = [...firings.entries()].filter(([, count]) => count >= MIN_TRIGGERS_FOR_NOISY).map(([ruleId, triggerCount]) => ({ ruleId, triggerCount, overrideRate: hitlByRule.get(ruleId) ?? 0 })).sort((a, b) => b.triggerCount * b.overrideRate - a.triggerCount * a.overrideRate);
+  return {
+    topBlockedActions,
+    mostOverriddenRules: overriddenRules.slice(0, topN),
+    ruleLatency,
+    noisyRules: noisyRules.slice(0, topN)
+  };
+}
+export {
+  computeApprovalAnalytics
+};

package/dist/intelligence/approval-events.js

@@ -0,0 +1,5 @@
+import { EventEmitter } from "events";
+const approvalEvents = new EventEmitter();
+export {
+  approvalEvents
+};

package/dist/intelligence/arch-boundaries.js

@@ -0,0 +1,94 @@
+import path from "path";
+import { buildGraph, getZone } from "./arch-graph.js";
+const DEFAULT_BOUNDARY_RULES = [
+  {
+    fromZone: "sensor",
+    cannotImport: ["routes", "intelligence"],
+    rationale: "sensor/* is the data ingestion and storage layer. Importing routes would create a circular dependency; importing intelligence would tie storage to business logic."
+  },
+  {
+    fromZone: "intelligence",
+    cannotImport: ["routes"],
+    rationale: "intelligence/* (MCP tools, analysis) must not depend on route handlers. Routes consume intelligence, not the other way around."
+  },
+  {
+    fromZone: "datadog",
+    cannotImport: ["routes", "intelligence"],
+    rationale: "datadog/* is an external integration adapter. It may only depend on the sensor layer (shared data types and storage)."
+  }
+];
+function checkBoundaries(opts) {
+  const { srcDir, rules = DEFAULT_BOUNDARY_RULES, singleFile } = opts;
+  const graph = buildGraph(srcDir);
+  const violations = [];
+  const ruleset = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    ruleset.set(rule.fromZone, new Set(rule.cannotImport));
+  }
+  const filesToCheck = singleFile ? [singleFile] : graph.files;
+  for (const file of filesToCheck) {
+    const fromZone = getZone(file);
+    const forbidden = ruleset.get(fromZone);
+    if (!forbidden) continue;
+    const imports = graph.forward.get(file) ?? /* @__PURE__ */ new Set();
+    for (const imported of imports) {
+      const importedZone = getZone(imported);
+      if (forbidden.has(importedZone)) {
+        const rule = rules.find((r) => r.fromZone === fromZone);
+        violations.push({
+          file,
+          fromZone,
+          importedFile: imported,
+          importedZone,
+          rule,
+          relativeFile: path.relative(srcDir, file),
+          relativeImport: path.relative(srcDir, imported)
+        });
+      }
+    }
+  }
+  const filesWithViolations = new Set(violations.map((v) => v.file));
+  const cleanFiles = filesToCheck.filter((f) => getZone(f) !== "other" && !filesWithViolations.has(f)).length;
+  return {
+    violations,
+    filesChecked: filesToCheck.length,
+    rulesApplied: rules.length,
+    cleanFiles
+  };
+}
+function formatBoundaryReport(result, srcDir) {
+  if (result.violations.length === 0) {
+    return [
+      "## Architectural Boundary Check: PASS \u2705",
+      "",
+      `${result.filesChecked} files checked \xB7 ${result.rulesApplied} rules applied \xB7 0 violations`
+    ].join("\n");
+  }
+  const byFile = /* @__PURE__ */ new Map();
+  for (const v of result.violations) {
+    const arr = byFile.get(v.relativeFile) ?? [];
+    arr.push(v);
+    byFile.set(v.relativeFile, arr);
+  }
+  const lines = [
+    `## Architectural Boundary Check: FAIL \u274C`,
+    "",
+    `${result.violations.length} violation(s) found in ${byFile.size} file(s). ${result.filesChecked} files checked \xB7 ${result.rulesApplied} rules applied.`,
+    ""
+  ];
+  for (const [file, vs] of byFile) {
+    lines.push(`### \`${file}\``);
+    for (const v of vs) {
+      lines.push(`  - \u274C **${v.fromZone}** \u2192 **${v.importedZone}**: imports \`${v.relativeImport}\``);
+      lines.push(`    > ${v.rule.rationale}`);
+    }
+    lines.push("");
+  }
+  lines.push("**Fix:** Refactor so that dependencies only flow in the permitted direction (sensor \u2190 intelligence \u2190 routes).");
+  return lines.join("\n");
+}
+export {
+  DEFAULT_BOUNDARY_RULES,
+  checkBoundaries,
+  formatBoundaryReport
+};