mergen-server 1.4.0

package/dist/intelligence/corpus-to-policy.js

@@ -0,0 +1,140 @@
+import { createHash } from "crypto";
+import { compactCorpus } from "./override-corpus.js";
+import { loadEnterprisePolicy, saveEnterprisePolicy } from "./enterprise-policy-engine.js";
+import { stageProposal } from "./policy-proposals.js";
+import logger from "../sensor/logger.js";
+const MIN_OCCURRENCES = 3;
+function _actionForReason(reason) {
+  switch (reason) {
+    case "batch-window":
+    case "maintenance-window":
+    case "compliance-hold":
+      return "block";
+    case "wrong-fix":
+    case "wrong-diagnosis":
+    case "cost-constraint":
+    case "on-call-discretion":
+    case "prefer-read-replica":
+    case "other":
+      return "warn";
+  }
+}
+function _humanReason(reason) {
+  const labels = {
+    "batch-window": "batch settlement window",
+    "maintenance-window": "maintenance window",
+    "compliance-hold": "compliance hold",
+    "wrong-fix": "incorrect fix applied previously",
+    "wrong-diagnosis": "incorrect root cause diagnosis",
+    "cost-constraint": "cost ceiling constraint",
+    "on-call-discretion": "on-call discretion override",
+    "prefer-read-replica": "read-replica preferred",
+    "other": "team override"
+  };
+  return labels[reason] ?? reason;
+}
+function _ruleHash(rule) {
+  const key = JSON.stringify({
+    tag: rule.incidentTag,
+    svc: rule.service,
+    reason: rule.overrideReason,
+    day: rule.dayOfWeek,
+    hour: rule.hourWindow
+  });
+  return createHash("sha256").update(key).digest("hex").slice(0, 16);
+}
+function _isAlreadyCovered(hash) {
+  const policy = loadEnterprisePolicy();
+  return policy.rules.some((r) => r.id === `corpus_auto_${hash}`);
+}
+function synthesizeRulesFromCorpus(scope) {
+  const compacted = compactCorpus().filter(
+    (cr) => !scope || cr.incidentTag === scope.incidentTag && cr.service === scope.service
+  );
+  const results = [];
+  for (const cr of compacted) {
+    if (cr.occurrences < MIN_OCCURRENCES) continue;
+    if (cr.commandSignatures.length === 0) {
+      logger.warn(
+        { incidentTag: cr.incidentTag, service: cr.service },
+        "corpus-to-policy: skipping synthesis \u2014 no command signatures could be extracted from this bucket"
+      );
+      continue;
+    }
+    const hash = _ruleHash(cr);
+    if (_isAlreadyCovered(hash)) continue;
+    const action = _actionForReason(cr.overrideReason);
+    const humanLabel = _humanReason(cr.overrideReason);
+    const conditions = {
+      commands: cr.commandSignatures
+    };
+    if (cr.dayOfWeek !== null) {
+      conditions.daysOfWeek = [cr.dayOfWeek];
+    }
+    if (cr.hourWindow !== null) {
+      conditions.hourWindow = cr.hourWindow;
+    }
+    conditions.actorType = "ai";
+    const dayLabel = cr.dayOfWeek !== null ? ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"][cr.dayOfWeek] : null;
+    const hourLabel = cr.hourWindow ? `${String(cr.hourWindow[0]).padStart(2, "0")}:00\u2013${String(cr.hourWindow[1]).padStart(2, "0")}:00 UTC` : null;
+    const timeDesc = [dayLabel, hourLabel].filter(Boolean).join(" ");
+    const commandsDesc = cr.commandSignatures.map((s) => `"${s}"`).join(", ");
+    const rule = {
+      id: `corpus_auto_${hash}`,
+      name: `[Auto] ${cr.service !== "unknown" ? cr.service + ": " : ""}${humanLabel}${timeDesc ? " (" + timeDesc + ")" : ""}`,
+      description: `Auto-synthesized from ${cr.occurrences} override events. Tag: ${cr.incidentTag}. Reason: ${humanLabel}. Scoped to commands: ${commandsDesc}.`,
+      action,
+      reason: `Corpus-derived policy: this action was overridden ${cr.occurrences} time(s) due to ${humanLabel}${timeDesc ? " during " + timeDesc : ""}.`,
+      conditions
+    };
+    results.push({ rule, sourceOccurrences: cr.occurrences, compactedRule: cr });
+    logger.info(
+      { ruleId: rule.id, occurrences: cr.occurrences, action },
+      "corpus-to-policy: synthesized new policy rule from override corpus"
+    );
+  }
+  return results;
+}
+function _activateRule(rule) {
+  const policy = loadEnterprisePolicy();
+  if (policy.rules.some((r) => r.id === rule.id)) return;
+  saveEnterprisePolicy({ ...policy, rules: [...policy.rules, rule] });
+}
+function autoActivateReviewedRules(incidentTag, service) {
+  const staged = synthesizeRulesFromCorpus({ incidentTag, service });
+  for (const { rule } of staged) {
+    _activateRule(rule);
+    logger.info(
+      { ruleId: rule.id, incidentTag, service },
+      "corpus-to-policy: auto-activated rule into live policy after operator review"
+    );
+  }
+  return staged;
+}
+function autoCorpusProposeEnabled() {
+  return process.env.MERGEN_AUTO_CORPUS_PROPOSE !== "false";
+}
+function proposeRulesFromCorpus(scope) {
+  if (!autoCorpusProposeEnabled()) return [];
+  const synthesized = synthesizeRulesFromCorpus(scope);
+  const proposals = [];
+  for (const { rule, sourceOccurrences } of synthesized) {
+    const holdRule = { ...rule, action: "warn" };
+    const staged = stageProposal(rule.id, holdRule, sourceOccurrences);
+    if (staged) proposals.push(staged);
+  }
+  if (proposals.length > 0) {
+    logger.info({ count: proposals.length }, "corpus-to-policy: staged HOLD-only policy proposals");
+  }
+  return proposals;
+}
+function activateProposedRule(rule) {
+  _activateRule(rule);
+}
+export {
+  activateProposedRule,
+  autoActivateReviewedRules,
+  autoCorpusProposeEnabled,
+  proposeRulesFromCorpus,
+  synthesizeRulesFromCorpus
+};

package/dist/intelligence/credential-broker.js

@@ -0,0 +1,112 @@
+import fs from "fs";
+import path from "path";
+import { STSClient, AssumeRoleCommand } from "@aws-sdk/client-sts";
+import { DATA_DIR } from "../sensor/paths.js";
+import { getStores } from "../storage/store-registry.js";
+import { getTraceId } from "./trace-context.js";
+import logger from "../sensor/logger.js";
+import { requestGcpCredential } from "./gcp-broker.js";
+import { requestAzureCredential } from "./azure-broker.js";
+const CREDENTIAL_SCOPES_FILE = path.join(DATA_DIR, "credential-scopes.json");
+function loadScopes() {
+  try {
+    const raw = JSON.parse(fs.readFileSync(CREDENTIAL_SCOPES_FILE, "utf8"));
+    return raw.scopes ?? {};
+  } catch {
+    return {};
+  }
+}
+function providerOf(scopeConfig) {
+  return scopeConfig.provider ?? "aws";
+}
+const STS_MIN_DURATION_SECONDS = 900;
+const STS_MAX_DURATION_SECONDS = 43200;
+function sessionNameFor(agentId, taskId) {
+  const raw = `mergen-${agentId}-${taskId}`.replace(/[^\w+=,.@-]/g, "_");
+  return raw.slice(0, 64);
+}
+async function requestAwsCredential(request, scopeConfig) {
+  const requested = request.durationSeconds ?? scopeConfig.maxDurationSeconds;
+  const durationSeconds = Math.min(
+    Math.max(requested, STS_MIN_DURATION_SECONDS),
+    Math.min(scopeConfig.maxDurationSeconds, STS_MAX_DURATION_SECONDS)
+  );
+  const client = new STSClient({ region: scopeConfig.region });
+  const response = await client.send(new AssumeRoleCommand({
+    RoleArn: scopeConfig.roleArn,
+    RoleSessionName: sessionNameFor(request.agentId, request.taskId),
+    DurationSeconds: durationSeconds
+  }));
+  const creds = response.Credentials;
+  if (!creds?.AccessKeyId || !creds.SecretAccessKey || !creds.SessionToken || !creds.Expiration) {
+    throw new Error("credential-broker: AssumeRole succeeded but returned incomplete credentials");
+  }
+  return {
+    provider: "aws",
+    accessKeyId: creds.AccessKeyId,
+    secretAccessKey: creds.SecretAccessKey,
+    sessionToken: creds.SessionToken,
+    expiration: creds.Expiration,
+    roleArn: scopeConfig.roleArn,
+    scope: request.scope,
+    durationEnforced: true
+  };
+}
+async function requestEphemeralCredential(request) {
+  const scopes = loadScopes();
+  const scopeConfig = scopes[request.scope];
+  if (!scopeConfig || scopeConfig.mergenTenantId !== void 0 && scopeConfig.mergenTenantId !== request.callerTenantId) {
+    throw new Error(
+      `credential-broker: unknown scope "${request.scope}" \u2014 configure it in ${CREDENTIAL_SCOPES_FILE} first`
+    );
+  }
+  const provider = providerOf(scopeConfig);
+  let cred;
+  if (provider === "gcp") {
+    cred = await requestGcpCredential(request.agentId, request.scope, scopeConfig, request.durationSeconds);
+  } else if (provider === "azure") {
+    cred = await requestAzureCredential(request.agentId, request.scope, scopeConfig, request.durationSeconds);
+  } else {
+    cred = await requestAwsCredential(request, scopeConfig);
+  }
+  await getStores().blunders.record({
+    blunderType: "credential_issued",
+    command: `credential:${request.scope}`,
+    blockReason: `Ephemeral ${provider} credential issued, expires ${cred.expiration.toISOString()}`,
+    service: "credential-broker",
+    tag: "credential_broker",
+    actor: "agent",
+    pid: null,
+    confidenceScore: null,
+    triggeredRules: null,
+    agentId: request.agentId,
+    traceId: getTraceId()
+  });
+  logger.info(
+    { agentId: request.agentId, scope: request.scope, provider, expiresAt: cred.expiration },
+    "credential-broker: ephemeral credential issued"
+  );
+  try {
+    void getStores().actionLedger.append({
+      agentId: request.agentId,
+      tool: "request_credential",
+      command: `credential:${request.scope}`,
+      resource: request.scope,
+      verdict: "pass",
+      reason: `Ephemeral ${provider} credential issued`,
+      credentialIssued: true,
+      credentialScope: request.scope,
+      environment: process.env.MERGEN_ENVIRONMENT ?? null,
+      traceId: getTraceId()
+    }, request.callerTenantId);
+  } catch {
+  }
+  return cred;
+}
+function listConfiguredScopes(callerTenantId) {
+  return Object.entries(loadScopes()).filter(([, cfg]) => cfg.mergenTenantId === void 0 || cfg.mergenTenantId === callerTenantId).map(([name]) => name);
+}
+export {
+  listConfiguredScopes,
+  requestEphemeralCredential
+};

package/dist/intelligence/credential-misuse.js

@@ -0,0 +1,39 @@
+import { getStores } from "../storage/store-registry.js";
+const DEFAULT_WINDOW_MS = 30 * 24 * 60 * 60 * 1e3;
+async function detectCredentialMisuse(opts = {}) {
+  const windowMs = opts.windowMs ?? DEFAULT_WINDOW_MS;
+  const from = Date.now() - windowMs;
+  const rows = await getStores().actionLedger.queryCredentialUsage({ agentId: opts.agentId, from }, opts.tenantId);
+  const groups = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const scope = r.credentialScope ?? "unknown";
+    const env = r.environment ?? "unknown";
+    const key = `${r.agentId ?? ""}\0${scope}`;
+    let g = groups.get(key);
+    if (!g) {
+      g = { agentId: r.agentId, scope, envs: /* @__PURE__ */ new Set(), count: 0, firstTs: r.ts, lastTs: r.ts };
+      groups.set(key, g);
+    }
+    g.envs.add(env);
+    g.count++;
+    if (r.ts < g.firstTs) g.firstTs = r.ts;
+    if (r.ts > g.lastTs) g.lastTs = r.ts;
+  }
+  const findings = [];
+  for (const g of groups.values()) {
+    if (g.envs.size >= 2) {
+      findings.push({
+        agentId: g.agentId,
+        scope: g.scope,
+        environments: [...g.envs].sort(),
+        issuances: g.count,
+        firstTs: g.firstTs,
+        lastTs: g.lastTs
+      });
+    }
+  }
+  return findings.sort((a, b) => b.lastTs - a.lastTs);
+}
+export {
+  detectCredentialMisuse
+};

package/dist/intelligence/debug-sessions.js

@@ -0,0 +1,108 @@
+import { randomUUID } from "crypto";
+function fingerprintConsole(e) {
+  const msg = e.args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ").trim().slice(0, 120);
+  return `${e.level}::${msg}`;
+}
+function fingerprintNetwork(n) {
+  const url = n.url.split("?")[0];
+  return `${n.method}::${url}::${n.status}`;
+}
+const sessions = /* @__PURE__ */ new Map();
+function captureSnapshot(errors, warnings, networkFailures) {
+  return {
+    capturedAt: Date.now(),
+    errors: errors.map((e) => ({
+      fingerprint: fingerprintConsole(e),
+      message: e.args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ").slice(0, 200),
+      level: e.level,
+      timestamp: e.timestamp
+    })),
+    warnings: warnings.map((e) => ({
+      fingerprint: fingerprintConsole(e),
+      message: e.args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ").slice(0, 200),
+      level: e.level,
+      timestamp: e.timestamp
+    })),
+    networkFailures: networkFailures.map((n) => ({
+      fingerprint: fingerprintNetwork(n),
+      summary: `${n.method} ${n.url.split("?")[0]} \u2192 ${n.status || "NET_ERR"}`,
+      status: n.status,
+      timestamp: n.timestamp
+    }))
+  };
+}
+function diffSnapshots(baseline, current) {
+  const baseErrFPs = new Set(baseline.errors.map((e) => e.fingerprint));
+  const baseNetFPs = new Set(baseline.networkFailures.map((n) => n.fingerprint));
+  const curErrFPs = new Set(current.errors.map((e) => e.fingerprint));
+  const curNetFPs = new Set(current.networkFailures.map((n) => n.fingerprint));
+  const resolved = baseline.errors.filter((e) => !curErrFPs.has(e.fingerprint));
+  const persisted = baseline.errors.filter((e) => curErrFPs.has(e.fingerprint));
+  const newErrors = current.errors.filter((e) => !baseErrFPs.has(e.fingerprint));
+  const resolvedNetworkFailures = baseline.networkFailures.filter((n) => !curNetFPs.has(n.fingerprint));
+  const newNetworkFailures = current.networkFailures.filter((n) => !baseNetFPs.has(n.fingerprint));
+  return {
+    resolved,
+    persisted,
+    newErrors,
+    resolvedNetworkFailures,
+    newNetworkFailures,
+    isFixed: persisted.length === 0 && newErrors.length === 0 && baseline.errors.length > 0
+  };
+}
+function startDebugSession(description, baseline, targetComponent) {
+  const session = {
+    id: randomUUID(),
+    description,
+    targetComponent,
+    baseline,
+    iterations: [],
+    startedAt: Date.now(),
+    resolved: false
+  };
+  sessions.set(session.id, session);
+  return session;
+}
+function checkpointSession(sessionId, current, note) {
+  const session = sessions.get(sessionId);
+  if (!session) return null;
+  const diff = diffSnapshots(session.baseline, current);
+  session.iterations.push({
+    index: session.iterations.length + 1,
+    note,
+    timestamp: Date.now(),
+    diff
+  });
+  if (diff.isFixed) session.resolved = true;
+  return { session, diff };
+}
+function endDebugSession(sessionId, current) {
+  const session = sessions.get(sessionId);
+  if (!session) return null;
+  const diff = diffSnapshots(session.baseline, current);
+  session.endedAt = Date.now();
+  session.resolved = diff.isFixed;
+  sessions.delete(sessionId);
+  return { session, diff };
+}
+function getSession(sessionId) {
+  return sessions.get(sessionId);
+}
+function listActiveSessions() {
+  return Array.from(sessions.values());
+}
+function clearAllSessions() {
+  const count = sessions.size;
+  sessions.clear();
+  return count;
+}
+export {
+  captureSnapshot,
+  checkpointSession,
+  clearAllSessions,
+  diffSnapshots,
+  endDebugSession,
+  getSession,
+  listActiveSessions,
+  startDebugSession
+};

package/dist/intelligence/decision-escalation.js

@@ -0,0 +1,36 @@
+const LOW_ACCURACY_THRESHOLD = 0.7;
+function blendEscalation(input) {
+  const { similarity, calibration } = input;
+  const reasons = [];
+  let hold = false;
+  let confidence = 1;
+  if (similarity.recommendation === "hold") {
+    hold = true;
+    confidence -= 0.4;
+    reasons.push(similarity.rationale);
+  }
+  if (calibration && !calibration.trusted) {
+    hold = true;
+    confidence -= 0.3;
+    reasons.push(
+      `Calibration for '${calibration.tag}' is not yet trusted (${calibration.verdicts} verdicts, ${Math.round(calibration.accuracy * 100)}% accuracy).`
+    );
+  } else if (calibration && calibration.accuracy < LOW_ACCURACY_THRESHOLD) {
+    hold = true;
+    confidence -= 0.2;
+    reasons.push(
+      `Calibration accuracy for '${calibration.tag}' is ${Math.round(calibration.accuracy * 100)}%, below the ${Math.round(LOW_ACCURACY_THRESHOLD * 100)}% confidence floor.`
+    );
+  }
+  if (reasons.length === 0) {
+    reasons.push("No similar past actions with negative outcomes, and calibration for this tag is trusted.");
+  }
+  return {
+    recommendation: hold ? "hold" : "none",
+    confidence: Math.max(0, Math.min(1, confidence)),
+    reasons
+  };
+}
+export {
+  blendEscalation
+};

package/dist/intelligence/decision-memory.js

@@ -0,0 +1,47 @@
+function summarizeOverride(e) {
+  return {
+    source: "override",
+    recordedAt: e.recordedAt,
+    service: e.service,
+    summary: `${e.overrideReason}${e.note ? `: ${e.note}` : ""} \u2014 proposed \`${e.proposedCommand.slice(0, 80)}\``,
+    outcome: e.outcome ?? null
+  };
+}
+function summarizeShadow(e) {
+  const cmd = e.command ? `\`${e.command.slice(0, 80)}\`` : "no command";
+  return {
+    source: "shadow",
+    recordedAt: e.recordedAt,
+    service: e.service,
+    summary: `would have run: ${cmd} (${e.skipReason})`,
+    outcome: e.humanVerdict ?? null
+  };
+}
+function buildDecisionMemory(tag, service, overrides, shadowEntries, topRule) {
+  const entries = [
+    ...overrides.map(summarizeOverride),
+    ...shadowEntries.map(summarizeShadow)
+  ].sort((a, b) => b.recordedAt - a.recordedAt);
+  const overrideOutcomes = { resolved: 0, escalated: 0, unresolved: 0, unknown: 0 };
+  for (const e of overrides) {
+    if (e.outcome) overrideOutcomes[e.outcome]++;
+    else overrideOutcomes.unknown++;
+  }
+  const shadowOutcomes = { wouldApprove: 0, wouldOverride: 0, unreviewed: 0 };
+  for (const e of shadowEntries) {
+    if (e.humanVerdict === "would-approve") shadowOutcomes.wouldApprove++;
+    else if (e.humanVerdict === "would-override") shadowOutcomes.wouldOverride++;
+    else shadowOutcomes.unreviewed++;
+  }
+  return {
+    tag,
+    service,
+    totalEntries: entries.length,
+    entries,
+    topRule,
+    outcomeBreakdown: { overrides: overrideOutcomes, shadow: shadowOutcomes }
+  };
+}
+export {
+  buildDecisionMemory
+};

package/dist/intelligence/decision-similarity.js

@@ -0,0 +1,85 @@
+import { commandSignature } from "./override-corpus.js";
+import { normalizeForMatching } from "./normalize.js";
+const TOP_N = 5;
+const MIN_SIMILARITY = 0.34;
+const MIN_MATCHES_FOR_RECOMMENDATION = 2;
+const NEGATIVE_OUTCOMES = /* @__PURE__ */ new Set(["escalated", "unresolved", "would-override"]);
+function tokenSet(text) {
+  return new Set(normalizeForMatching(text).split(" ").filter(Boolean));
+}
+function jaccard(a, b) {
+  if (a.size === 0 || b.size === 0) return 0;
+  let intersection = 0;
+  for (const t of a) if (b.has(t)) intersection++;
+  const union = a.size + b.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+function scoreCandidate(proposedTokens, proposedSig, candidateCommand, candidateService, service) {
+  const reasons = [];
+  let score = 0;
+  const candidateSig = commandSignature(candidateCommand);
+  if (candidateSig && candidateSig === proposedSig) {
+    score += 0.5;
+    reasons.push("same command signature");
+  }
+  const overlap = jaccard(proposedTokens, tokenSet(candidateCommand));
+  if (overlap > 0) {
+    score += overlap * 0.4;
+    if (overlap >= 0.3) reasons.push(`${Math.round(overlap * 100)}% command text overlap`);
+  }
+  if (service && candidateService === service) {
+    score += 0.1;
+    reasons.push("same service");
+  }
+  return { similarity: Math.min(1, score), matchReasons: reasons };
+}
+function findSimilarDecisions(proposedCommand, service, overrides, shadowEntries) {
+  const proposedTokens = tokenSet(proposedCommand);
+  const proposedSig = commandSignature(proposedCommand);
+  const candidates = [];
+  for (const e of overrides) {
+    const { similarity, matchReasons } = scoreCandidate(proposedTokens, proposedSig, e.proposedCommand, e.service, service);
+    if (similarity < MIN_SIMILARITY) continue;
+    candidates.push({
+      source: "override",
+      recordedAt: e.recordedAt,
+      service: e.service,
+      command: e.proposedCommand,
+      outcome: e.outcome ?? null,
+      similarity,
+      matchReasons
+    });
+  }
+  for (const e of shadowEntries) {
+    if (!e.command) continue;
+    const { similarity, matchReasons } = scoreCandidate(proposedTokens, proposedSig, e.command, e.service, service);
+    if (similarity < MIN_SIMILARITY) continue;
+    candidates.push({
+      source: "shadow",
+      recordedAt: e.recordedAt,
+      service: e.service,
+      command: e.command,
+      outcome: e.humanVerdict ?? null,
+      similarity,
+      matchReasons
+    });
+  }
+  candidates.sort((a, b) => b.similarity - a.similarity || b.recordedAt - a.recordedAt);
+  const matches = candidates.slice(0, TOP_N);
+  const negativeOutcomeCount = matches.filter((m) => m.outcome !== null && NEGATIVE_OUTCOMES.has(m.outcome)).length;
+  const totalConsidered = matches.length;
+  const recommendation = totalConsidered >= MIN_MATCHES_FOR_RECOMMENDATION && negativeOutcomeCount / totalConsidered >= 0.5 ? "hold" : "none";
+  const rationale = totalConsidered === 0 ? "No similar past actions found." : `${negativeOutcomeCount}/${totalConsidered} similar past action${totalConsidered === 1 ? "" : "s"} ${totalConsidered === 1 ? "was" : "were"} overridden, escalated, or left unresolved.`;
+  return {
+    proposedCommand,
+    service,
+    matches,
+    negativeOutcomeCount,
+    totalConsidered,
+    recommendation,
+    rationale
+  };
+}
+export {
+  findSimilarDecisions
+};

package/dist/intelligence/default-safety-tests.js

@@ -0,0 +1,53 @@
+const DEFAULT_SAFETY_TESTS = [
+  {
+    id: "block_rm_rf",
+    description: "Recursive force-delete must be blocked",
+    input: { files: [], commands: ["rm -rf /var/data"], actor: "claude", service: "test" },
+    expectedVerdict: "block"
+  },
+  {
+    id: "block_terraform_destroy",
+    description: "Terraform destroy against prod must be blocked",
+    input: { files: [], commands: ["terraform destroy prod"], actor: "claude", service: "test" },
+    expectedVerdict: "block"
+  },
+  {
+    id: "block_drop_database",
+    description: "DROP DATABASE must be blocked",
+    input: { files: [], commands: ["drop database production"], actor: "claude", service: "test" },
+    expectedVerdict: "block"
+  },
+  {
+    id: "block_drop_table",
+    description: "DROP TABLE must be blocked",
+    input: { files: [], commands: ["drop table users"], actor: "claude", service: "test" },
+    expectedVerdict: "block"
+  },
+  {
+    id: "block_kubectl_delete",
+    description: "kubectl delete namespace must be blocked",
+    input: { files: [], commands: ["kubectl delete namespace production"], actor: "claude", service: "test" },
+    expectedVerdict: "block"
+  },
+  {
+    id: "hold_alter_table",
+    description: "Schema-mutating ALTER TABLE must be held for review, not outright blocked",
+    input: { files: [], commands: ["alter table users add column x boolean"], actor: "claude", service: "test" },
+    expectedVerdict: "warn"
+  },
+  {
+    id: "pass_safe_deploy",
+    description: "Read-only rollout status check must pass",
+    input: { files: [], commands: ["kubectl rollout status deployment/api"], actor: "claude", service: "test" },
+    expectedVerdict: "pass"
+  },
+  {
+    id: "pass_git_commit",
+    description: "Ordinary git commit must pass",
+    input: { files: [], commands: ['git commit -m "fix"'], actor: "claude", service: "test" },
+    expectedVerdict: "pass"
+  }
+];
+export {
+  DEFAULT_SAFETY_TESTS
+};