chron-mcp 0.1.29 → 0.1.31

package/dist/cli/index.js

@@ -6162,7 +6162,7 @@ var require_websocket = __commonJS({
     var http = require("http");
     var net = require("net");
     var tls = require("tls");
-    var { randomBytes, createHash: createHash6 } = require("crypto");
+    var { randomBytes, createHash: createHash7 } = require("crypto");
     var { Duplex, Readable } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -6842,7 +6842,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash6("sha1").update(key + GUID).digest("base64");
+        const digest = createHash7("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -7229,7 +7229,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = require("events");
     var http = require("http");
     var { Duplex } = require("stream");
-    var { createHash: createHash6 } = require("crypto");
+    var { createHash: createHash7 } = require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -7538,7 +7538,7 @@ var require_websocket_server = __commonJS({
         }
         if (this._state > RUNNING)
           return abortHandshake(socket, 503);
-        const digest = createHash6("sha1").update(key + GUID).digest("base64");
+        const digest = createHash7("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -16526,10 +16526,11 @@ var init_libsql = __esm({
 var schema_exports = {};
 __export(schema_exports, {
   messages: () => messages,
+  review_findings: () => review_findings,
   secrets_detected: () => secrets_detected,
   sessions: () => sessions
 });
-var sessions, messages, secrets_detected;
+var sessions, messages, secrets_detected, review_findings;
 var init_schema = __esm({
   "src/db/schema.ts"() {
     "use strict";
@@ -16565,6 +16566,16 @@ var init_schema = __esm({
       masked_value: text("masked_value").notNull(),
       detected_at: text("detected_at").notNull()
     });
+    review_findings = sqliteTable("review_findings", {
+      id: text("id").primaryKey(),
+      rule_id: text("rule_id").notNull(),
+      session_id: text("session_id").notNull().references(() => sessions.id),
+      status: text("status", { enum: ["open", "accepted", "dismissed", "resolved"] }).notNull(),
+      note: text("note"),
+      reviewed_at: text("reviewed_at"),
+      created_at: text("created_at").notNull(),
+      updated_at: text("updated_at").notNull()
+    });
   }
 });
 
@@ -16668,11 +16679,24 @@ var init_db2 = __esm({
     detected_at TEXT NOT NULL,
     FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE,
     FOREIGN KEY (message_id) REFERENCES messages(id) ON DELETE CASCADE
+  )`,
+      `CREATE TABLE IF NOT EXISTS review_findings (
+    id TEXT PRIMARY KEY,
+    rule_id TEXT NOT NULL,
+    session_id TEXT NOT NULL,
+    status TEXT NOT NULL CHECK (status IN ('open', 'accepted', 'dismissed', 'resolved')),
+    note TEXT,
+    reviewed_at TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
   )`,
       `CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_title ON sessions(title)`,
       `CREATE INDEX IF NOT EXISTS idx_messages_session_id ON messages(session_id)`,
       `CREATE INDEX IF NOT EXISTS idx_secrets_detected_session_id ON secrets_detected(session_id)`,
       `CREATE INDEX IF NOT EXISTS idx_secrets_detected_message_id ON secrets_detected(message_id)`,
+      `CREATE INDEX IF NOT EXISTS idx_review_findings_session_id ON review_findings(session_id)`,
+      `CREATE INDEX IF NOT EXISTS idx_review_findings_status ON review_findings(status)`,
       `CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
     content,
     session_id UNINDEXED,
@@ -17486,7 +17510,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "chron-mcp",
-      version: "0.1.29",
+      version: "0.1.31",
       mcpName: "io.github.sirinivask/chron",
       description: "Audit-grade timestamped logs for every AI conversation",
       repository: {
@@ -20010,6 +20034,732 @@ var init_import = __esm({
   }
 });
 
+// src/review/rules.ts
+var SOC2_RULES, FRAMEWORKS;
+var init_rules = __esm({
+  "src/review/rules.ts"() {
+    "use strict";
+    SOC2_RULES = [
+      {
+        id: "soc2.cc6_1.ai_access_control_change",
+        framework: "soc2",
+        controls: ["CC6.1"],
+        severity: "high",
+        description: "AI touched access-control-related code",
+        finding: "AI modified code in an access-control-sensitive path.",
+        not_claiming: "This is not evidence of a security failure or SOC 2 non-compliance.",
+        suggested_evidence: [
+          "PR approval with human reviewer",
+          "Change ticket linked to the work",
+          "Manager or security team sign-off"
+        ],
+        match: {
+          type: "code_change_path",
+          path_contains: ["auth", "iam", "rbac", "permission", "policy", "acl", "role", "login", "jwt", "oauth", "saml", "sso", "mfa", "access_control"]
+        }
+      },
+      {
+        id: "soc2.cc6_1.cc6_6.secret_detected",
+        framework: "soc2",
+        controls: ["CC6.1", "CC6.6"],
+        severity: "high",
+        description: "AI session contained detected sensitive data or credentials",
+        finding: "Sensitive data or a credential was detected in an AI session.",
+        not_claiming: "This is not evidence of a breach or credential compromise. Chron masks detected values at log time \u2014 no plaintext values are stored.",
+        suggested_evidence: [
+          "Confirm no plaintext credential was committed to version control",
+          "Rotate the credential if it was a live secret",
+          "Document the detection and resolution in the change log"
+        ],
+        match: { type: "secret_detected" }
+      },
+      {
+        id: "soc2.cc7_2.cc8_1.ai_infra_change",
+        framework: "soc2",
+        controls: ["CC7.2", "CC8.1"],
+        severity: "high",
+        description: "AI executed or modified deployment or infrastructure files",
+        finding: "AI modified infrastructure or deployment configuration.",
+        not_claiming: "This is not evidence of an unauthorized change.",
+        suggested_evidence: [
+          "Change ticket or approval record",
+          "Pipeline approval gate log",
+          "Human review of the infrastructure diff"
+        ],
+        match: {
+          type: "code_change_path",
+          path_contains: [".tf", "terraform", "dockerfile", "docker-compose", "kubernetes", "k8s", "helm", "ansible", ".github/workflow", "cloudformation", "pipeline", "deploy"]
+        }
+      },
+      {
+        id: "soc2.cc7_2.ai_monitoring_change",
+        framework: "soc2",
+        controls: ["CC7.2"],
+        severity: "high",
+        description: "AI changed logging, monitoring, alerting, or security tooling",
+        finding: "AI modified logging, monitoring, or security alerting code or configuration.",
+        not_claiming: "This is not evidence that monitoring was disabled or circumvented.",
+        suggested_evidence: [
+          "Confirm monitoring coverage was not reduced",
+          "Human review of the change",
+          "Change ticket"
+        ],
+        match: {
+          type: "code_change_path",
+          path_contains: ["logging", "monitoring", "alerting", "splunk", "datadog", "prometheus", "grafana", "cloudwatch", "sentry", "pagerduty", "audit_log", "audit-log", "logger"]
+        }
+      },
+      {
+        id: "soc2.cc6_1.cc6_7.ai_data_handling_change",
+        framework: "soc2",
+        controls: ["CC6.1", "CC6.7"],
+        severity: "medium",
+        description: "AI changed data retention, deletion, export, or encryption logic",
+        finding: "AI modified data handling, retention, or privacy-related code.",
+        not_claiming: "This is not evidence of a data handling violation.",
+        suggested_evidence: [
+          "Privacy or data officer review",
+          "Change ticket documenting the business reason",
+          "Confirm compliance with data retention policy"
+        ],
+        match: {
+          type: "code_change_path",
+          path_contains: ["retention", "encrypt", "decrypt", "gdpr", "privacy", "anonymize", "redact", "purge", "archive", "backup"]
+        }
+      }
+    ];
+    FRAMEWORKS = {
+      soc2: SOC2_RULES
+    };
+  }
+});
+
+// src/review/workflow.ts
+function findingId(ruleId, sessionId) {
+  return (0, import_crypto7.createHash)("sha256").update(`${ruleId}:${sessionId}`).digest("hex");
+}
+async function hydrateFindingStatuses(db, findings) {
+  if (findings.length === 0)
+    return findings;
+  const client = db.$client;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const finding of findings) {
+    await client.execute({
+      sql: `INSERT INTO review_findings (id, rule_id, session_id, status, created_at, updated_at)
+            VALUES (?, ?, ?, 'open', ?, ?)
+            ON CONFLICT(id) DO NOTHING`,
+      args: [finding.id, finding.rule_id, finding.session_id, now, now]
+    });
+  }
+  const rows = await loadFindingStates(client, findings.map((f) => f.id));
+  const byId = new Map(rows.map((row) => [row.id, row]));
+  return findings.map((finding) => {
+    const state = byId.get(finding.id);
+    return {
+      ...finding,
+      status: state?.status ?? "open",
+      note: state?.note ?? null,
+      reviewed_at: state?.reviewed_at ?? null
+    };
+  });
+}
+async function updateFindingStatus(db, idOrPrefix, status, note) {
+  const client = db.$client;
+  const id = await resolveFindingId(client, idOrPrefix);
+  const reviewedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await client.execute({
+    sql: `UPDATE review_findings
+          SET status = ?, note = ?, reviewed_at = ?, updated_at = ?
+          WHERE id = ?`,
+    args: [status, note ?? null, reviewedAt, reviewedAt, id]
+  });
+  const rows = await loadFindingStates(client, [id]);
+  return rows[0];
+}
+async function resolveFindingId(client, idOrPrefix) {
+  const prefix = idOrPrefix.trim();
+  if (!prefix)
+    throw new Error("Finding id is required");
+  const result = await client.execute({
+    sql: `SELECT id FROM review_findings WHERE id LIKE ? ORDER BY id LIMIT 2`,
+    args: [`${prefix}%`]
+  });
+  if (result.rows.length === 0) {
+    throw new Error(`Finding not found: ${prefix}. Run "chron review --framework=soc2" first to register current findings.`);
+  }
+  if (result.rows.length > 1) {
+    throw new Error(`Finding id prefix is ambiguous: ${prefix}. Use more characters.`);
+  }
+  return String(result.rows[0].id);
+}
+async function loadFindingStates(client, ids) {
+  if (ids.length === 0)
+    return [];
+  const placeholders = ids.map(() => "?").join(", ");
+  const result = await client.execute({
+    sql: `SELECT id, rule_id, session_id, status, note, reviewed_at
+          FROM review_findings
+          WHERE id IN (${placeholders})`,
+    args: ids
+  });
+  return result.rows.map((row) => ({
+    id: String(row.id),
+    rule_id: String(row.rule_id),
+    session_id: String(row.session_id),
+    status: String(row.status),
+    note: row.note == null ? null : String(row.note),
+    reviewed_at: row.reviewed_at == null ? null : String(row.reviewed_at)
+  }));
+}
+var import_crypto7;
+var init_workflow = __esm({
+  "src/review/workflow.ts"() {
+    "use strict";
+    import_crypto7 = require("crypto");
+  }
+});
+
+// src/review/engine.ts
+async function runReview(db, rules, since) {
+  const client = db.$client;
+  const map = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    if (rule.match.type === "code_change_path") {
+      await matchCodeChanges(client, rule, map, since);
+    } else if (rule.match.type === "secret_detected") {
+      await matchSecrets(client, rule, map, since);
+    }
+  }
+  const findings = Array.from(map.values());
+  findings.sort(
+    (a, b) => (SEVERITY_ORDER[a.severity] ?? 99) - (SEVERITY_ORDER[b.severity] ?? 99) || a.last_occurred_at.localeCompare(b.last_occurred_at)
+  );
+  return findings;
+}
+function higherSeverity(a, b) {
+  return (SEVERITY_ORDER[a] ?? 99) <= (SEVERITY_ORDER[b] ?? 99) ? a : b;
+}
+function suggestedEvidenceForSecret(type, rule) {
+  const severity = SECRET_SEVERITY[type] ?? rule.severity;
+  if (severity === "medium") {
+    return [
+      "Confirm the personal or contact data was necessary for the AI session",
+      "Verify no unnecessary personal data was committed to version control",
+      "Document handling or remediation if the data was not required"
+    ];
+  }
+  if (severity === "low") {
+    return [
+      "Review whether the detected value contains secret material",
+      "Confirm no plaintext credential was committed to version control",
+      "Document why the value is acceptable or remediate it"
+    ];
+  }
+  return rule.suggested_evidence;
+}
+async function matchCodeChanges(client, rule, map, since) {
+  if (rule.match.type !== "code_change_path")
+    return;
+  const keywords = rule.match.path_contains;
+  const result = await client.execute(
+    since ? {
+      sql: `SELECT m.id, m.session_id, m.content, m.created_at, s.title, s.ai_tool
+              FROM messages m JOIN sessions s ON s.id = m.session_id
+              WHERE m.event_type = 'code_change' AND m.created_at >= ?
+              ORDER BY m.created_at`,
+      args: [since]
+    } : `SELECT m.id, m.session_id, m.content, m.created_at, s.title, s.ai_tool
+       FROM messages m JOIN sessions s ON s.id = m.session_id
+       WHERE m.event_type = 'code_change'
+       ORDER BY m.created_at`
+  );
+  for (const row of result.rows) {
+    const content = String(row.content ?? "");
+    let filePath = "";
+    try {
+      const parsed = JSON.parse(content);
+      filePath = (parsed.file_path ?? parsed.path ?? "").toLowerCase();
+    } catch {
+      filePath = content.toLowerCase();
+    }
+    if (!keywords.some((kw) => filePath.includes(kw.toLowerCase())))
+      continue;
+    const sessionId = String(row.session_id ?? "");
+    const mapKey = `${rule.id}::${sessionId}`;
+    const occurredAt = String(row.created_at ?? "");
+    const evidenceItem = `code_change: ${filePath || "unknown path"}`;
+    if (!map.has(mapKey)) {
+      map.set(mapKey, {
+        id: findingId(rule.id, sessionId),
+        rule_id: rule.id,
+        framework: rule.framework,
+        controls: rule.controls,
+        severity: rule.severity,
+        status: "open",
+        note: null,
+        reviewed_at: null,
+        session_id: sessionId,
+        session_prefix: sessionId.slice(0, 8),
+        session_title: String(row.title ?? ""),
+        ai_tool: row.ai_tool != null ? String(row.ai_tool) : null,
+        evidence_items: [],
+        first_occurred_at: occurredAt,
+        last_occurred_at: occurredAt,
+        finding: rule.finding,
+        not_claiming: rule.not_claiming,
+        suggested_evidence: rule.suggested_evidence
+      });
+    }
+    const finding = map.get(mapKey);
+    if (!finding.evidence_items.includes(evidenceItem)) {
+      finding.evidence_items.push(evidenceItem);
+    }
+    if (occurredAt > finding.last_occurred_at)
+      finding.last_occurred_at = occurredAt;
+  }
+}
+async function matchSecrets(client, rule, map, since) {
+  const result = await client.execute(
+    since ? {
+      sql: `SELECT sd.session_id, sd.type, sd.masked_value, sd.detected_at, s.title, s.ai_tool
+              FROM secrets_detected sd JOIN sessions s ON s.id = sd.session_id
+              WHERE sd.detected_at >= ?
+              ORDER BY sd.detected_at`,
+      args: [since]
+    } : `SELECT sd.session_id, sd.type, sd.masked_value, sd.detected_at, s.title, s.ai_tool
+       FROM secrets_detected sd JOIN sessions s ON s.id = sd.session_id
+       ORDER BY sd.detected_at`
+  );
+  for (const row of result.rows) {
+    const sessionId = String(row.session_id ?? "");
+    const mapKey = `${rule.id}::${sessionId}`;
+    const occurredAt = String(row.detected_at ?? "");
+    const type = String(row.type ?? "");
+    const severity = SECRET_SEVERITY[type] ?? rule.severity;
+    const suggestedEvidence = suggestedEvidenceForSecret(type, rule);
+    const evidenceItem = `secret_detected: ${type} (${row.masked_value})`;
+    if (!map.has(mapKey)) {
+      map.set(mapKey, {
+        id: findingId(rule.id, sessionId),
+        rule_id: rule.id,
+        framework: rule.framework,
+        controls: rule.controls,
+        severity,
+        status: "open",
+        note: null,
+        reviewed_at: null,
+        session_id: sessionId,
+        session_prefix: sessionId.slice(0, 8),
+        session_title: String(row.title ?? ""),
+        ai_tool: row.ai_tool != null ? String(row.ai_tool) : null,
+        evidence_items: [],
+        first_occurred_at: occurredAt,
+        last_occurred_at: occurredAt,
+        finding: rule.finding,
+        not_claiming: rule.not_claiming,
+        suggested_evidence: suggestedEvidence
+      });
+    }
+    const finding = map.get(mapKey);
+    const previousSeverity = finding.severity;
+    finding.severity = higherSeverity(finding.severity, severity);
+    if (finding.severity !== previousSeverity || finding.suggested_evidence.length === 0) {
+      finding.suggested_evidence = suggestedEvidence;
+    }
+    if (!finding.evidence_items.includes(evidenceItem)) {
+      finding.evidence_items.push(evidenceItem);
+    }
+    if (occurredAt > finding.last_occurred_at)
+      finding.last_occurred_at = occurredAt;
+  }
+}
+var SEVERITY_ORDER, SECRET_SEVERITY;
+var init_engine = __esm({
+  "src/review/engine.ts"() {
+    "use strict";
+    init_workflow();
+    SEVERITY_ORDER = { critical: 0, high: 1, medium: 2, low: 3 };
+    SECRET_SEVERITY = {
+      private_key: "critical",
+      credit_card: "critical",
+      ssn: "critical",
+      iban: "critical",
+      aws_access_key: "high",
+      anthropic_api_key: "high",
+      openai_api_key: "high",
+      google_api_key: "high",
+      github_token: "high",
+      slack_token: "high",
+      stripe_key: "high",
+      sendgrid_key: "high",
+      huggingface_token: "high",
+      jwt: "high",
+      url_credentials: "high",
+      password: "high",
+      credential_pair: "high",
+      passport: "high",
+      dob: "high",
+      email: "medium",
+      phone_us: "medium",
+      phone_e164: "medium",
+      internal_ip: "low",
+      env_value: "low"
+    };
+  }
+});
+
+// src/cli/review.ts
+var review_exports = {};
+__export(review_exports, {
+  runReview: () => runReview2
+});
+function printFindings(findings, framework, sessionCount, showAll) {
+  const controlsHit = new Set(findings.flatMap((f) => f.controls));
+  process.stdout.write(
+    `
+${BOLD10}Chron Review${RESET10}  ${CYAN8}${framework.toUpperCase()}${RESET10}  ${DIM9}${sessionCount} session(s) reviewed${showAll ? " \xB7 all statuses" : " \xB7 open findings"}${RESET10}
+
+`
+  );
+  if (findings.length === 0) {
+    process.stdout.write(
+      showAll ? `${DIM9}No findings. No sessions matched any control review criteria.${RESET10}
+
+` : `${DIM9}No open findings. Use --all to include accepted, dismissed, and resolved findings.${RESET10}
+
+`
+    );
+    return;
+  }
+  process.stdout.write(
+    `${BOLD10}${findings.length}${RESET10} finding${findings.length === 1 ? "" : "s"}  across  ${BOLD10}${controlsHit.size}${RESET10} control${controlsHit.size === 1 ? "" : "s"}
+
+`
+  );
+  process.stdout.write(
+    `${DIM9}This report identifies AI-session evidence that may require control-owner review.
+It is not a certification of compliance or evidence of any violation.${RESET10}
+
+`
+  );
+  for (const f of findings) {
+    const sevColor = SEV_COLOR[f.severity] ?? DIM9;
+    const statusColor = STATUS_COLOR[f.status] ?? DIM9;
+    const controls = f.controls.join(", ");
+    const sev = f.severity.toUpperCase().padEnd(8);
+    const status = f.status.toUpperCase().padEnd(9);
+    process.stdout.write(
+      `  ${sevColor}${BOLD10}${sev}${RESET10}  ${statusColor}${status}${RESET10}  ${MAGENTA2}${controls.padEnd(16)}${RESET10}  ${CYAN8}${f.session_prefix}${RESET10}  ${f.session_title}
+`
+    );
+    process.stdout.write(`    ${DIM9}id: ${f.id.slice(0, 16)}${RESET10}
+`);
+    process.stdout.write(`    ${f.finding}
+`);
+    for (const item of f.evidence_items.slice(0, 5)) {
+      process.stdout.write(`    ${DIM9}\u2022 ${item}${RESET10}
+`);
+    }
+    if (f.evidence_items.length > 5) {
+      process.stdout.write(`    ${DIM9}  \u2026 ${f.evidence_items.length - 5} more event(s)${RESET10}
+`);
+    }
+    process.stdout.write(`    ${DIM9}Suggested: ${f.suggested_evidence[0]}${RESET10}
+`);
+    if (f.note)
+      process.stdout.write(`    ${DIM9}Note: ${f.note}${RESET10}
+`);
+    process.stdout.write("\n");
+  }
+}
+function esc2(s) {
+  return (s ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function badgeHtml(severity) {
+  return `<span class="badge badge-${esc2(severity)}">${esc2(severity.toUpperCase())}</span>`;
+}
+function statusBadgeHtml(status) {
+  return `<span class="status-badge status-${esc2(status)}">${esc2(status.toUpperCase())}</span>`;
+}
+function buildReviewHtml(params) {
+  const { framework, host, generatedAt, sessionCount, findings } = params;
+  const controlsHit = new Set(findings.flatMap((f) => f.controls));
+  const bySeverity = { critical: 0, high: 0, medium: 0, low: 0 };
+  for (const f of findings)
+    bySeverity[f.severity] = (bySeverity[f.severity] ?? 0) + 1;
+  const findingCards = findings.length === 0 ? '<p style="color:#6b7280">No findings matched this report scope.</p>' : findings.map((f) => `
+<div class="finding-card">
+  <div class="finding-header">
+    ${badgeHtml(f.severity)}
+    ${statusBadgeHtml(f.status)}
+    <span class="finding-controls">${esc2(f.controls.join(", "))}</span>
+    <span style="flex:1"></span>
+    <span class="finding-session">${esc2(f.session_prefix)}</span>
+    <span style="font-size:12px;color:#374151">${esc2(f.session_title)}</span>
+  </div>
+  <div class="finding-body">
+    <div style="font-family:monospace;font-size:11px;color:#6b7280;margin-bottom:5px">Finding ID: ${esc2(f.id)}</div>
+    <div class="finding-text">${esc2(f.finding)}</div>
+    <div class="finding-disclaimer">${esc2(f.not_claiming)}</div>
+    ${f.note ? `<div style="font-size:11px;color:#374151;margin-bottom:8px"><strong>Reviewer note:</strong> ${esc2(f.note)}</div>` : ""}
+    ${f.reviewed_at ? `<div style="font-size:11px;color:#6b7280;margin-bottom:8px">Reviewed: ${esc2(f.reviewed_at)}</div>` : ""}
+    <strong style="font-size:11px;color:#374151">Evidence in session:</strong>
+    <ul class="evidence-list">
+      ${f.evidence_items.map((e) => `<li>${esc2(e)}</li>`).join("")}
+    </ul>
+    <strong style="font-size:11px;color:#374151">Suggested review actions:</strong>
+    <ul class="suggested-list">
+      ${f.suggested_evidence.map((s) => `<li>${esc2(s)}</li>`).join("")}
+    </ul>
+  </div>
+</div>`).join("");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Chron Review \u2014 ${esc2(framework.toUpperCase())} Controls</title>
+<style>${REPORT_CSS}</style>
+</head>
+<body>
+<div class="page">
+
+<div style="min-height:50vh;display:flex;flex-direction:column;justify-content:center">
+  <div class="cover-badge">${esc2(framework.toUpperCase())} Control Review</div>
+  <h1>Chron Review Report</h1>
+  <p class="meta">Generated by <strong>chron review</strong> &nbsp;|&nbsp; Host: <strong>${esc2(host)}</strong></p>
+  <table style="width:auto;margin-bottom:0">
+    <tr><th>Framework</th><td>${esc2(framework.toUpperCase())} Trust Services Criteria</td></tr>
+    <tr><th>Generated</th><td>${esc2(generatedAt)}</td></tr>
+    <tr><th>Sessions Reviewed</th><td>${sessionCount}</td></tr>
+    <tr><th>Findings</th><td>${findings.length}</td></tr>
+    <tr><th>Controls Flagged</th><td>${controlsHit.size > 0 ? Array.from(controlsHit).sort().join(", ") : "None"}</td></tr>
+  </table>
+</div>
+
+<div class="disclaimer">
+  <strong>Important:</strong> This report identifies AI-session evidence that may require control-owner review.
+  It is not a certification of compliance, a SOC 2 opinion, or evidence of any control failure.
+  Each finding is a potential review item \u2014 not a violation. A licensed CPA conducting a SOC 2 examination
+  must evaluate whether your controls were suitably designed and operated effectively over the audit period.
+</div>
+
+<h2>Summary</h2>
+<div class="stat-grid">
+  <div class="stat"><div class="stat-value">${sessionCount}</div><div class="stat-label">Sessions Reviewed</div></div>
+  <div class="stat"><div class="stat-value">${findings.length}</div><div class="stat-label">Findings</div></div>
+  <div class="stat"><div class="stat-value">${controlsHit.size}</div><div class="stat-label">Controls Flagged</div></div>
+</div>
+${bySeverity.critical > 0 ? `<p><span class="badge badge-critical">CRITICAL</span> &nbsp;${bySeverity.critical} finding(s) require immediate attention.</p>` : ""}
+
+<h2>Findings</h2>
+${findingCards}
+
+<h2>Methodology</h2>
+<div class="appendix">
+  <h3>What this report does</h3>
+  <p>Chron Review evaluates AI session logs against a deterministic rule pack aligned to the AICPA Trust Services Criteria.
+  Rules match on structured event types (<code>code_change</code>, <code>secret_detected</code>) recorded by the Chron MCP server
+  during live AI conversations.</p>
+
+  <h3>Rule pack: ${esc2(framework.toUpperCase())} (v1)</h3>
+  <ul>
+    <li><strong>CC6.1</strong> \u2014 AI touched access-control code (auth, IAM, RBAC, permissions, login, JWT, OAuth, SAML, SSO)</li>
+    <li><strong>CC6.1 / CC6.6</strong> \u2014 Sensitive credential detected in AI session (masked at log time, no plaintext stored)</li>
+    <li><strong>CC7.2 / CC8.1</strong> \u2014 AI modified infrastructure or deployment configuration (Terraform, Docker, Kubernetes, pipelines)</li>
+    <li><strong>CC7.2</strong> \u2014 AI modified logging, monitoring, or alerting code</li>
+    <li><strong>CC6.1 / CC6.7</strong> \u2014 AI modified data retention, deletion, export, or encryption logic</li>
+  </ul>
+
+  <h3>What this report does not do</h3>
+  <ul>
+    <li>Does not evaluate whether your controls were suitably designed or operated effectively (that is the auditor's role).</li>
+    <li>Does not access code repositories, CI/CD systems, identity providers, or any environment outside the Chron audit database.</li>
+    <li>Does not make any compliance determination. All findings use the language "potential review item."</li>
+    <li>Does not cover CC1\u2013CC5 (governance, communication, risk assessment) \u2014 these require policy documents, board records, and cannot be evaluated from session logs.</li>
+  </ul>
+
+  <p style="margin-top:12px;font-size:11px;color:#9ca3af">
+    Generated by chron review &nbsp;|&nbsp; ${esc2(generatedAt)} &nbsp;|&nbsp; Host: ${esc2(host)}
+  </p>
+</div>
+
+</div>
+</body>
+</html>`;
+}
+async function countSessions(db, since) {
+  const client = db.$client;
+  const result = await client.execute(
+    since ? {
+      sql: `SELECT COUNT(*) AS n FROM sessions WHERE updated_at >= ?`,
+      args: [since]
+    } : "SELECT COUNT(*) AS n FROM sessions"
+  );
+  return Number(result.rows[0].n ?? 0);
+}
+async function runReview2(args2) {
+  const action = args2[0];
+  if (action === "accept" || action === "dismiss" || action === "resolve") {
+    await runReviewAction(action, args2.slice(1));
+    return;
+  }
+  const frameworkArg = args2.find((a) => a.startsWith("--framework="))?.slice("--framework=".length)?.toLowerCase();
+  const outputArg = args2.find((a) => a.startsWith("--output="))?.slice("--output=".length);
+  const sinceArg = args2.find((a) => a.startsWith("--since="))?.slice("--since=".length);
+  const showAll = args2.includes("--all");
+  if (!frameworkArg) {
+    process.stderr.write("Usage: chron review --framework=soc2 [--since=<range>] [--all] [--output=<file>]\n");
+    process.exit(1);
+  }
+  const rules = FRAMEWORKS[frameworkArg];
+  if (!rules) {
+    process.stderr.write(`Unknown framework: "${frameworkArg}". Available: ${Object.keys(FRAMEWORKS).join(", ")}
+`);
+    process.exit(1);
+  }
+  let since;
+  if (sinceArg) {
+    try {
+      since = parseSince(sinceArg);
+    } catch (err) {
+      process.stderr.write(`${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  }
+  const db = await initDb();
+  const [rawFindings, sessionCount] = await Promise.all([
+    runReview(db, rules, since),
+    countSessions(db, since)
+  ]);
+  const allFindings = await hydrateFindingStatuses(db, rawFindings);
+  const findings = showAll ? allFindings : allFindings.filter((f) => f.status === "open");
+  printFindings(findings, frameworkArg, sessionCount, showAll);
+  if (outputArg) {
+    const generatedAt = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) + " UTC";
+    const html = buildReviewHtml({
+      framework: frameworkArg,
+      host: (0, import_os11.hostname)(),
+      generatedAt,
+      sessionCount,
+      findings
+    });
+    (0, import_fs12.writeFileSync)(outputArg, html, "utf8");
+    process.stdout.write(`Review report written to ${outputArg}
+`);
+  }
+}
+async function runReviewAction(action, args2) {
+  const id = args2.find((a) => !a.startsWith("--"));
+  const note = args2.find((a) => a.startsWith("--note="))?.slice("--note=".length);
+  if (!id) {
+    process.stderr.write(`Usage: chron review ${action} <finding-id> [--note=<text>]
+`);
+    process.exit(1);
+  }
+  const statusByAction = {
+    accept: "accepted",
+    dismiss: "dismissed",
+    resolve: "resolved"
+  };
+  const status = statusByAction[action];
+  const db = await initDb();
+  try {
+    const row = await updateFindingStatus(db, id, status, note);
+    process.stdout.write(
+      `Finding ${row.id.slice(0, 16)} ${status}${note ? ` with note: ${note}` : ""}
+`
+    );
+  } catch (err) {
+    process.stderr.write(`${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  }
+}
+var import_fs12, import_os11, RESET10, BOLD10, DIM9, RED5, YELLOW8, CYAN8, MAGENTA2, SEV_COLOR, STATUS_COLOR, REPORT_CSS;
+var init_review = __esm({
+  "src/cli/review.ts"() {
+    "use strict";
+    import_fs12 = require("fs");
+    import_os11 = require("os");
+    init_db2();
+    init_report();
+    init_rules();
+    init_engine();
+    init_workflow();
+    RESET10 = "\x1B[0m";
+    BOLD10 = "\x1B[1m";
+    DIM9 = "\x1B[2m";
+    RED5 = "\x1B[31m";
+    YELLOW8 = "\x1B[33m";
+    CYAN8 = "\x1B[36m";
+    MAGENTA2 = "\x1B[35m";
+    SEV_COLOR = {
+      critical: RED5,
+      high: YELLOW8,
+      medium: CYAN8,
+      low: DIM9
+    };
+    STATUS_COLOR = {
+      open: YELLOW8,
+      accepted: CYAN8,
+      dismissed: DIM9,
+      resolved: CYAN8
+    };
+    REPORT_CSS = `
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; font-size: 13px; color: #111; background: #fff; line-height: 1.5; }
+.page { max-width: 900px; margin: 0 auto; padding: 40px 48px; }
+h1 { font-size: 28px; font-weight: 700; margin-bottom: 4px; }
+h2 { font-size: 17px; font-weight: 700; margin: 32px 0 10px; padding-bottom: 4px; border-bottom: 2px solid #e5e7eb; color: #1f2937; }
+h3 { font-size: 14px; font-weight: 600; margin: 20px 0 6px; color: #374151; }
+p { margin-bottom: 8px; color: #374151; }
+.meta { color: #6b7280; font-size: 12px; margin-bottom: 32px; }
+.cover-badge { display: inline-block; background: #1d4ed8; color: #fff; padding: 3px 10px; border-radius: 4px; font-size: 12px; font-weight: 600; margin-bottom: 16px; }
+table { width: 100%; border-collapse: collapse; margin-bottom: 16px; font-size: 12px; }
+th { background: #f3f4f6; text-align: left; padding: 6px 10px; font-weight: 600; color: #374151; border: 1px solid #e5e7eb; }
+td { padding: 5px 10px; border: 1px solid #e5e7eb; vertical-align: top; word-break: break-word; }
+tr:nth-child(even) td { background: #fafafa; }
+.stat-grid { display: grid; grid-template-columns: repeat(3, 1fr); gap: 12px; margin-bottom: 20px; }
+.stat { background: #f9fafb; border: 1px solid #e5e7eb; border-radius: 6px; padding: 12px 16px; }
+.stat-value { font-size: 24px; font-weight: 700; color: #1f2937; }
+.stat-label { font-size: 11px; color: #6b7280; margin-top: 2px; }
+.badge { display:inline-block; padding:1px 7px; border-radius:3px; font-size:11px; font-weight:600; color:#fff; }
+.badge-critical { background:#dc2626; }
+.badge-high { background:#d97706; }
+.badge-medium { background:#2563eb; }
+.badge-low { background:#6b7280; }
+.status-badge { display:inline-block; padding:1px 7px; border-radius:3px; font-size:11px; font-weight:600; border:1px solid #d1d5db; color:#374151; background:#fff; }
+.status-open { border-color:#f59e0b; color:#92400e; background:#fffbeb; }
+.status-accepted { border-color:#38bdf8; color:#075985; background:#f0f9ff; }
+.status-dismissed { border-color:#d1d5db; color:#6b7280; background:#f9fafb; }
+.status-resolved { border-color:#34d399; color:#065f46; background:#ecfdf5; }
+.disclaimer { background: #fffbeb; border: 1px solid #fde68a; border-left: 4px solid #f59e0b; border-radius: 4px; padding: 12px 14px; margin: 14px 0 20px; font-size: 12px; color: #374151; }
+.finding-card { border: 1px solid #e5e7eb; border-radius: 6px; margin-bottom: 14px; overflow: hidden; }
+.finding-header { display:flex; align-items:center; gap:10px; padding:10px 14px; background:#f9fafb; border-bottom:1px solid #e5e7eb; }
+.finding-controls { font-size:12px; font-weight:700; color:#1f2937; }
+.finding-session { font-family:monospace; font-size:11px; color:#6b7280; }
+.finding-body { padding:10px 14px; }
+.finding-text { font-size:13px; color:#111; margin-bottom:6px; }
+.finding-disclaimer { font-size:11px; color:#6b7280; margin-bottom:8px; }
+.evidence-list { margin:0 0 8px 16px; }
+.evidence-list li { font-size:11px; font-family:monospace; color:#374151; margin-bottom:2px; }
+.suggested-list { margin:0 0 0 16px; }
+.suggested-list li { font-size:11px; color:#374151; margin-bottom:2px; }
+.appendix { background: #f9fafb; border: 1px solid #e5e7eb; border-radius: 6px; padding: 16px 20px; margin-top: 12px; }
+ul { padding-left: 20px; margin-bottom: 8px; }
+li { margin-bottom: 4px; }
+@media print {
+  body { font-size: 11px; }
+  .page { padding: 20px 24px; max-width: 100%; }
+  h1 { font-size: 22px; }
+  h2 { font-size: 14px; }
+}
+`;
+  }
+});
+
 // src/cli/index.ts
 var [, , command, ...args] = process.argv;
 async function main() {
@@ -20074,6 +20824,11 @@ async function main() {
       await runImport2(args);
       break;
     }
+    case "review": {
+      const { runReview: runReview3 } = await Promise.resolve().then(() => (init_review(), review_exports));
+      await runReview3(args);
+      break;
+    }
     default: {
       const name = command ? `Unknown command: ${command}
 
@@ -20094,6 +20849,7 @@ Commands:
   prune           Delete sessions older than a retention cutoff
   doctor          Check your Chron setup \u2014 Node version, DB, MCP configs, SIEM
   import          Import conversations from external AI tools
+  review          Review AI sessions against compliance control criteria
 
 Options (history):
   --limit=<n>       Max sessions to show (default: 20)
@@ -20127,6 +20883,15 @@ Options (doctor):
 
 Options (import):
   chatgpt <file>     Import from ChatGPT export (.zip or conversations.json)
+
+Options (review):
+  --framework=<name>  Framework to review against: soc2
+  --since=<range>     Limit to sessions since: 7d, 30d, or YYYY-MM-DD
+  --all               Include accepted, dismissed, and resolved findings
+  --output=<file>     Write HTML report to file (printable to PDF from browser)
+  accept <id>         Mark a finding as accepted; supports --note=<text>
+  dismiss <id>        Mark a finding as dismissed; supports --note=<text>
+  resolve <id>        Mark a finding as resolved; supports --note=<text>
 `
       );
       process.exit(command ? 1 : 0);

package/dist/index.js

@@ -22736,10 +22736,11 @@ var init_libsql = __esm({
 var schema_exports = {};
 __export(schema_exports, {
   messages: () => messages,
+  review_findings: () => review_findings,
   secrets_detected: () => secrets_detected,
   sessions: () => sessions
 });
-var sessions, messages, secrets_detected;
+var sessions, messages, secrets_detected, review_findings;
 var init_schema = __esm({
   "src/db/schema.ts"() {
     "use strict";
@@ -22775,6 +22776,16 @@ var init_schema = __esm({
       masked_value: text("masked_value").notNull(),
       detected_at: text("detected_at").notNull()
     });
+    review_findings = sqliteTable("review_findings", {
+      id: text("id").primaryKey(),
+      rule_id: text("rule_id").notNull(),
+      session_id: text("session_id").notNull().references(() => sessions.id),
+      status: text("status", { enum: ["open", "accepted", "dismissed", "resolved"] }).notNull(),
+      note: text("note"),
+      reviewed_at: text("reviewed_at"),
+      created_at: text("created_at").notNull(),
+      updated_at: text("updated_at").notNull()
+    });
   }
 });
 
@@ -22878,11 +22889,24 @@ var init_db2 = __esm({
     detected_at TEXT NOT NULL,
     FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE,
     FOREIGN KEY (message_id) REFERENCES messages(id) ON DELETE CASCADE
+  )`,
+      `CREATE TABLE IF NOT EXISTS review_findings (
+    id TEXT PRIMARY KEY,
+    rule_id TEXT NOT NULL,
+    session_id TEXT NOT NULL,
+    status TEXT NOT NULL CHECK (status IN ('open', 'accepted', 'dismissed', 'resolved')),
+    note TEXT,
+    reviewed_at TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
   )`,
       `CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_title ON sessions(title)`,
       `CREATE INDEX IF NOT EXISTS idx_messages_session_id ON messages(session_id)`,
       `CREATE INDEX IF NOT EXISTS idx_secrets_detected_session_id ON secrets_detected(session_id)`,
       `CREATE INDEX IF NOT EXISTS idx_secrets_detected_message_id ON secrets_detected(message_id)`,
+      `CREATE INDEX IF NOT EXISTS idx_review_findings_session_id ON review_findings(session_id)`,
+      `CREATE INDEX IF NOT EXISTS idx_review_findings_status ON review_findings(status)`,
       `CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
     content,
     session_id UNINDEXED,
@@ -38502,7 +38526,7 @@ var init_time = __esm({
 var version4;
 var init_package = __esm({
   "package.json"() {
-    version4 = "0.1.29";
+    version4 = "0.1.31";
   }
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chron-mcp",
-  "version": "0.1.29",
+  "version": "0.1.31",
   "mcpName": "io.github.sirinivask/chron",
   "description": "Audit-grade timestamped logs for every AI conversation",
   "repository": {