tamperward 2.39.24 → 2.40.0

package/dist/cli/index.js

@@ -12546,6 +12546,16 @@ function sessionHash(sessionId) {
   if (!sessionId) return void 0;
   return "sha256:" + createHash6("sha256").update(sessionId).digest("hex").slice(0, 24);
 }
+function sanitizedMetrics(metrics) {
+  const out3 = {};
+  if (!metrics) return out3;
+  for (const field2 of AUDIT_DURATION_FIELDS) {
+    const v = metrics[field2];
+    if (typeof v === "number" && Number.isFinite(v)) out3[field2] = Math.max(0, Math.round(v));
+  }
+  if (typeof metrics.oob_signoff === "boolean") out3.oob_signoff = metrics.oob_signoff;
+  return out3;
+}
 function eventId() {
   return "sha256:" + createHash6("sha256").update(randomBytes2(32)).digest("hex").slice(0, 32);
 }
@@ -12570,6 +12580,7 @@ function recordAuditFindings(findings, context) {
     mkdirSync5(dirname4(path), { recursive: true });
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const session = sessionHash(context.sessionId);
+    const metrics = sanitizedMetrics(context.metrics);
     const lines = findings.map((finding) => {
       const severity = finding.severity === "block" ? "block" : "warn";
       const event = {
@@ -12581,7 +12592,8 @@ function recordAuditFindings(findings, context) {
         rule: finding.rule,
         severity,
         decision: severity === "block" ? "deny" : "warn",
-        ...session ? { session } : {}
+        ...session ? { session } : {},
+        ...metrics
       };
       return JSON.stringify(event);
     });
@@ -12638,6 +12650,15 @@ function parseAuditEvent(value, line = 0) {
   if (value.session !== void 0 && (typeof value.session !== "string" || !/^sha256:[0-9a-f]{24}$/.test(value.session))) {
     throw new Error(`${where} has an invalid session`);
   }
+  for (const field2 of AUDIT_DURATION_FIELDS) {
+    const v = value[field2];
+    if (v !== void 0 && (typeof v !== "number" || !Number.isInteger(v) || v < 0)) {
+      throw new Error(`${where} has an invalid ${field2}`);
+    }
+  }
+  if (value.oob_signoff !== void 0 && typeof value.oob_signoff !== "boolean") {
+    throw new Error(`${where} has an invalid oob_signoff`);
+  }
   return {
     schema_version: AUDIT_SCHEMA_VERSION,
     id: value.id,
@@ -12647,9 +12668,19 @@ function parseAuditEvent(value, line = 0) {
     rule: value.rule,
     severity: value.severity,
     decision: value.decision,
-    ...typeof value.session === "string" ? { session: value.session } : {}
+    ...typeof value.session === "string" ? { session: value.session } : {},
+    ...durationsOf(value),
+    ...typeof value.oob_signoff === "boolean" ? { oob_signoff: value.oob_signoff } : {}
   };
 }
+function durationsOf(value) {
+  const out3 = {};
+  for (const field2 of AUDIT_DURATION_FIELDS) {
+    const v = value[field2];
+    if (typeof v === "number") out3[field2] = v;
+  }
+  return out3;
+}
 function parseAuditLine(line, lineNumber) {
   let value;
   try {
@@ -12724,6 +12755,12 @@ function createAuditAggregator() {
   const rules = /* @__PURE__ */ new Map();
   const surfaces = /* @__PURE__ */ new Map();
   const sessions = /* @__PURE__ */ new Set();
+  const durations = {
+    hook_latency_ms: /* @__PURE__ */ new Map(),
+    verify_wall_clock_ms: /* @__PURE__ */ new Map(),
+    bare_suite_wall_clock_ms: /* @__PURE__ */ new Map()
+  };
+  let oobSignoffs = 0;
   const bounds = { first: null, last: null };
   return {
     add(event) {
@@ -12737,6 +12774,11 @@ function createAuditAggregator() {
       rules.set(event.rule, bucket);
       surfaces.set(event.surface, (surfaces.get(event.surface) ?? 0) + 1);
       if (event.session) sessions.add(event.session);
+      for (const field2 of AUDIT_DURATION_FIELDS) {
+        const v = event[field2];
+        if (typeof v === "number") durations[field2].set(v, (durations[field2].get(v) ?? 0) + 1);
+      }
+      if (event.oob_signoff === true) oobSignoffs++;
       const ms = Date.parse(event.timestamp);
       const { first, last } = bounds;
       if (first === null || ms < first.ms || ms === first.ms && event.id.localeCompare(first.id) < 0) {
@@ -12759,11 +12801,32 @@ function createAuditAggregator() {
         last_event: bounds.last === null ? null : bounds.last.timestamp,
         by_rule,
         by_surface,
+        latency: {
+          hook_latency_ms: percentiles(durations.hook_latency_ms),
+          verify_wall_clock_ms: percentiles(durations.verify_wall_clock_ms),
+          bare_suite_wall_clock_ms: percentiles(durations.bare_suite_wall_clock_ms)
+        },
+        oob_signoffs: oobSignoffs,
         interpretation: "finding-is-not-proof-of-intent"
       };
     }
   };
 }
+function percentiles(counts) {
+  const values = [...counts.keys()].sort((a, b) => a - b);
+  if (values.length === 0) return null;
+  const samples = [...counts.values()].reduce((a, b) => a + b, 0);
+  const at = (q) => {
+    const rank = Math.max(1, Math.ceil(q * samples));
+    let seen = 0;
+    for (const v of values) {
+      seen += counts.get(v) ?? 0;
+      if (seen >= rank) return v;
+    }
+    return values[values.length - 1];
+  };
+  return { samples, p50: at(0.5), p95: at(0.95), max: values[values.length - 1] };
+}
 function renderAuditStats(summary) {
   const out3 = [
     "TamperWard audit stats",
@@ -12786,6 +12849,23 @@ function renderAuditStats(summary) {
     const width = Math.max(...summary.by_surface.map((row) => row.surface.length));
     for (const row of summary.by_surface) out3.push(`  ${row.surface.padEnd(width)}  ${row.events}`);
   }
+  const measures = [
+    ["hook_latency_ms", "Hook latency"],
+    ["verify_wall_clock_ms", "verify wall-clock"],
+    ["bare_suite_wall_clock_ms", "Bare-suite wall-clock"]
+  ];
+  const measured = [];
+  for (const [field2, label] of measures) {
+    const p = summary.latency[field2];
+    if (p !== null) measured.push([label, p]);
+  }
+  if (measured.length || summary.oob_signoffs > 0) {
+    out3.push("", "Measures");
+    for (const [label, p] of measured) {
+      out3.push(`  ${label.padEnd(22)}  p50 ${p.p50} ms  p95 ${p.p95} ms  max ${p.max} ms  (${p.samples} samples)`);
+    }
+    if (summary.oob_signoffs > 0) out3.push(`  ${"Out-of-band sign-offs".padEnd(22)}  ${summary.oob_signoffs}`);
+  }
   out3.push("", "Note: an integrity finding is a signal, not proof of agent intent; legitimate refactors can trigger findings.");
   return out3.join("\n") + "\n";
 }
@@ -12807,7 +12887,7 @@ function runStats(opts = {}) {
   process.stdout.write(opts.json ? JSON.stringify(summary) + "\n" : renderAuditStats(summary));
   return 0;
 }
-var AUDIT_SCHEMA_VERSION, AUDIT_LOG_ENV, MAX_AUDIT_LINE_BYTES, ALLOWED_KEYS, STATS_READ_REFUSED;
+var AUDIT_SCHEMA_VERSION, AUDIT_LOG_ENV, MAX_AUDIT_LINE_BYTES, AUDIT_DURATION_FIELDS, ALLOWED_KEYS, STATS_READ_REFUSED;
 var init_audit = __esm({
   "src/cli/audit.ts"() {
     "use strict";
@@ -12816,6 +12896,7 @@ var init_audit = __esm({
     AUDIT_SCHEMA_VERSION = 1;
     AUDIT_LOG_ENV = "TAMPERWARD_AUDIT_LOG";
     MAX_AUDIT_LINE_BYTES = 16 * 1024;
+    AUDIT_DURATION_FIELDS = ["hook_latency_ms", "verify_wall_clock_ms", "bare_suite_wall_clock_ms"];
     ALLOWED_KEYS = /* @__PURE__ */ new Set([
       "schema_version",
       "id",
@@ -12825,7 +12906,9 @@ var init_audit = __esm({
       "rule",
       "severity",
       "decision",
-      "session"
+      "session",
+      ...AUDIT_DURATION_FIELDS,
+      "oob_signoff"
     ]);
     STATS_READ_REFUSED = "; stats reads the audit log only as a regular file \u2014 remove what stands there so the log can be read";
   }
@@ -12903,7 +12986,8 @@ function verdict(blocks2, kind, audit) {
     recordAuditFindings(blocks2, {
       cwd: audit.cwd,
       surface: kind === "PreToolUse" ? "pretooluse" : "stop",
-      sessionId: audit.sessionId
+      sessionId: audit.sessionId,
+      ...audit.startedAt !== void 0 ? { metrics: { hook_latency_ms: performance.now() - audit.startedAt } } : {}
     });
   }
   const reason = formatDenial(blocks2);
@@ -13086,6 +13170,7 @@ function sanctionPredictedWrites(cwd, sessionId, policy, changes) {
   if (dirty) savePtree(cwd, sessionId, tree);
 }
 function preToolUseVerdict(input, defaultCwd, trustedRoot) {
+  const startedAt = performance.now();
   const sessionCwd = input.cwd ?? defaultCwd ?? process.cwd();
   try {
     if (trustedRoot !== void 0) {
@@ -13096,11 +13181,11 @@ function preToolUseVerdict(input, defaultCwd, trustedRoot) {
     turnBaseline(cwd, input.session_id);
     const policy = loadPolicy(cwd);
     const driftBlocks = effectDriftBlocks(cwd, input.session_id, policy);
-    if (driftBlocks) return verdict(driftBlocks, "PreToolUse", { cwd, sessionId: input.session_id });
+    if (driftBlocks) return verdict(driftBlocks, "PreToolUse", { cwd, sessionId: input.session_id, startedAt });
     const changes = changesFromClaudeHook(input, cwd, sessionCwd);
     const blocks2 = evaluate(changes, policy, void 0, "tool-call", { cwd }).filter((f) => f.severity === "block");
     if (blocks2.length === 0) sanctionPredictedWrites(cwd, input.session_id, policy, changes);
-    return verdict(blocks2, "PreToolUse", { cwd, sessionId: input.session_id });
+    return verdict(blocks2, "PreToolUse", { cwd, sessionId: input.session_id, startedAt });
   } catch (e) {
     return failClosed("PreToolUse", errText2(e), { cwd: sessionCwd, sessionId: input.session_id });
   }
@@ -13206,6 +13291,7 @@ function recordObserverHealth(cwd, sessionId, state, reason) {
 }
 function stopVerdict(input, defaultCwd, trustedRoot) {
   if (input.stop_hook_active) return { exitCode: 0, stdout: "" };
+  const startedAt = performance.now();
   const sessionCwd = input.cwd ?? defaultCwd ?? process.cwd();
   if (trustedRoot !== void 0) {
     const v = validateClaimAgainstRoot(input.cwd, trustedRoot, defaultCwd ?? process.cwd());
@@ -13247,7 +13333,7 @@ function stopVerdict(input, defaultCwd, trustedRoot) {
     advanceTurnBaseline(cwd, input.session_id);
     commitCursor();
   }
-  return verdict(blocks2, "Stop", { cwd, sessionId: input.session_id });
+  return verdict(blocks2, "Stop", { cwd, sessionId: input.session_id, startedAt });
 }
 function emit(r) {
   if (r.stdout) process.stdout.write(r.stdout);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tamperward",
-  "version": "2.39.24",
+  "version": "2.40.0",
   "description": "The deterministic agent-integrity gate. One ruleset, evaluated on the actual diff/commands as a verdict, enforced everywhere a change can be made.",
   "license": "Apache-2.0",
   "author": "hexrift",

package/schemas/audit-v1.schema.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://raw.githubusercontent.com/hexrift/tamperward/v2.38.0/schemas/audit-v1.schema.json",
+  "$id": "https://raw.githubusercontent.com/hexrift/tamperward/v2.40.0/schemas/audit-v1.schema.json",
   "title": "TamperWard audit event v1",
   "type": "object",
   "additionalProperties": false,
@@ -55,6 +55,25 @@
     "session": {
       "type": "string",
       "pattern": "^sha256:[0-9a-f]{24}$"
+    },
+    "hook_latency_ms": {
+      "type": "integer",
+      "minimum": 0,
+      "description": "Wall-clock milliseconds from the hook reading its input to the deny being written. Present only on events the hook itself records."
+    },
+    "verify_wall_clock_ms": {
+      "type": "integer",
+      "minimum": 0,
+      "description": "Wall-clock milliseconds of a `tamperward verify` run, where a producer records it."
+    },
+    "bare_suite_wall_clock_ms": {
+      "type": "integer",
+      "minimum": 0,
+      "description": "Wall-clock milliseconds of the same suite run without TamperWard, the comparison for verify_wall_clock_ms."
+    },
+    "oob_signoff": {
+      "type": "boolean",
+      "description": "True when an out-of-band sign-off (a CI label or local allow) was needed to clear this finding."
     }
   },
   "allOf": [
@@ -108,6 +127,19 @@
       "severity": "block",
       "decision": "deny",
       "session": "sha256:bbbbbbbbbbbbbbbbbbbbbbbb"
+    },
+    {
+      "schema_version": 1,
+      "id": "sha256:cccccccccccccccccccccccccccccccc",
+      "timestamp": "2026-09-23T14:00:00.000Z",
+      "surface": "pretooluse",
+      "agent": "claude-code",
+      "rule": "test-deletion",
+      "severity": "block",
+      "decision": "deny",
+      "session": "sha256:bbbbbbbbbbbbbbbbbbbbbbbb",
+      "hook_latency_ms": 42,
+      "oob_signoff": false
     }
   ]
 }

package/schemas/stats-v1.schema.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://raw.githubusercontent.com/hexrift/tamperward/v2.38.0/schemas/stats-v1.schema.json",
+  "$id": "https://raw.githubusercontent.com/hexrift/tamperward/v2.40.0/schemas/stats-v1.schema.json",
   "title": "TamperWard audit stats v1",
   "type": "object",
   "additionalProperties": false,
@@ -14,6 +14,8 @@
     "last_event",
     "by_rule",
     "by_surface",
+    "latency",
+    "oob_signoffs",
     "interpretation"
   ],
   "properties": {
@@ -112,6 +114,128 @@
         }
       }
     },
+    "latency": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "hook_latency_ms",
+        "verify_wall_clock_ms",
+        "bare_suite_wall_clock_ms"
+      ],
+      "properties": {
+        "hook_latency_ms": {
+          "anyOf": [
+            {
+              "type": "null"
+            },
+            {
+              "type": "object",
+              "additionalProperties": false,
+              "required": [
+                "samples",
+                "p50",
+                "p95",
+                "max"
+              ],
+              "properties": {
+                "samples": {
+                  "type": "integer",
+                  "minimum": 1
+                },
+                "p50": {
+                  "type": "integer",
+                  "minimum": 0
+                },
+                "p95": {
+                  "type": "integer",
+                  "minimum": 0
+                },
+                "max": {
+                  "type": "integer",
+                  "minimum": 0
+                }
+              }
+            }
+          ]
+        },
+        "verify_wall_clock_ms": {
+          "anyOf": [
+            {
+              "type": "null"
+            },
+            {
+              "type": "object",
+              "additionalProperties": false,
+              "required": [
+                "samples",
+                "p50",
+                "p95",
+                "max"
+              ],
+              "properties": {
+                "samples": {
+                  "type": "integer",
+                  "minimum": 1
+                },
+                "p50": {
+                  "type": "integer",
+                  "minimum": 0
+                },
+                "p95": {
+                  "type": "integer",
+                  "minimum": 0
+                },
+                "max": {
+                  "type": "integer",
+                  "minimum": 0
+                }
+              }
+            }
+          ]
+        },
+        "bare_suite_wall_clock_ms": {
+          "anyOf": [
+            {
+              "type": "null"
+            },
+            {
+              "type": "object",
+              "additionalProperties": false,
+              "required": [
+                "samples",
+                "p50",
+                "p95",
+                "max"
+              ],
+              "properties": {
+                "samples": {
+                  "type": "integer",
+                  "minimum": 1
+                },
+                "p50": {
+                  "type": "integer",
+                  "minimum": 0
+                },
+                "p95": {
+                  "type": "integer",
+                  "minimum": 0
+                },
+                "max": {
+                  "type": "integer",
+                  "minimum": 0
+                }
+              }
+            }
+          ]
+        }
+      },
+      "description": "Nearest-rank percentiles over the events that carry each duration; null when none did."
+    },
+    "oob_signoffs": {
+      "type": "integer",
+      "minimum": 0,
+      "description": "Events that recorded an out-of-band sign-off."
+    },
     "interpretation": {
       "const": "finding-is-not-proof-of-intent"
     }
@@ -127,6 +251,47 @@
       "last_event": null,
       "by_rule": [],
       "by_surface": [],
+      "latency": {
+        "hook_latency_ms": null,
+        "verify_wall_clock_ms": null,
+        "bare_suite_wall_clock_ms": null
+      },
+      "oob_signoffs": 0,
+      "interpretation": "finding-is-not-proof-of-intent"
+    },
+    {
+      "schema_version": 1,
+      "events": 2,
+      "blocked": 2,
+      "warnings": 0,
+      "sessions": 1,
+      "first_event": "2026-09-23T14:00:00.000Z",
+      "last_event": "2026-09-23T14:05:00.000Z",
+      "by_rule": [
+        {
+          "rule": "test-deletion",
+          "events": 2,
+          "blocked": 2,
+          "warnings": 0
+        }
+      ],
+      "by_surface": [
+        {
+          "surface": "pretooluse",
+          "events": 2
+        }
+      ],
+      "latency": {
+        "hook_latency_ms": {
+          "samples": 2,
+          "p50": 40,
+          "p95": 55,
+          "max": 55
+        },
+        "verify_wall_clock_ms": null,
+        "bare_suite_wall_clock_ms": null
+      },
+      "oob_signoffs": 1,
       "interpretation": "finding-is-not-proof-of-intent"
     }
   ]