pushary 1.9.103 → 1.9.104

package/dist/{chunk-YETNUPV5.js → chunk-2MRLDEQY.js}

@@ -1,12 +1,12 @@
 import {
   findNativeClaudeInstall
-} from "./chunk-LURFSDCL.js";
+} from "./chunk-VUFHYMSP.js";
 import {
   parseVersion
-} from "./chunk-BQHZRH6S.js";
+} from "./chunk-VAZCGOLS.js";
 import {
   isRecord
-} from "./chunk-4FAJQPFY.js";
+} from "./chunk-5YVBVJOH.js";
 
 // src/setup/agent-probe.ts
 import { execSync } from "child_process";

package/dist/{chunk-KOUB4ZLX.js → chunk-3A7REECH.js}

@@ -1,6 +1,6 @@
 import {
   NPX_LATEST_COMMAND
-} from "./chunk-PWGD5EP6.js";
+} from "./chunk-YDT6TVGN.js";
 
 // src/config.ts
 import { readFileSync } from "fs";

package/dist/{chunk-O5ZKMUTP.js → chunk-3KEY3453.js}

@@ -1,19 +1,19 @@
 import {
   APPROVAL_RULES_PATH,
   canChangeApprovalSettings
-} from "./chunk-WYJ6QM7K.js";
+} from "./chunk-4JBCPRWZ.js";
 import {
   callMcpTool
-} from "./chunk-V5DV7XZN.js";
+} from "./chunk-PK6LBL3Z.js";
 import {
   absoluteUrl
-} from "./chunk-7BIVBOD5.js";
+} from "./chunk-NGY2WS3X.js";
 import {
   getBaseUrl
-} from "./chunk-KOUB4ZLX.js";
+} from "./chunk-3A7REECH.js";
 import {
   NPX_LATEST_COMMAND
-} from "./chunk-PWGD5EP6.js";
+} from "./chunk-YDT6TVGN.js";
 import {
   AGENT_STOP_DEFAULT_SECONDS,
   APPROVAL_MODE_META,
@@ -21,7 +21,7 @@ import {
   classifyConfirmResponse,
   isAnswerSource,
   roundTripAsk
-} from "./chunk-4FAJQPFY.js";
+} from "./chunk-5YVBVJOH.js";
 
 // src/reach.ts
 var reachVerdict = (channels) => {

package/dist/{chunk-JVE4P54I.js → chunk-4HBWXZPI.js}

@@ -1,12 +1,14 @@
 import {
   autoUpdateLock
-} from "./chunk-O7ITTNDD.js";
+} from "./chunk-AYWX6M7J.js";
 import {
   installPackageGlobally,
   npmErrorMessage,
-  npmExitedOnPermissionDenied,
+  npmExitedOnPermissionDenied
+} from "./chunk-VAZCGOLS.js";
+import {
   writeJsonAtomic
-} from "./chunk-BQHZRH6S.js";
+} from "./chunk-QENTGE75.js";
 
 // src/upgrade-lock.ts
 import { fork } from "child_process";

package/dist/{chunk-WYJ6QM7K.js → chunk-4JBCPRWZ.js}

@@ -1,9 +1,9 @@
 import {
   absoluteUrl
-} from "./chunk-7BIVBOD5.js";
+} from "./chunk-NGY2WS3X.js";
 import {
   KEY_SCOPE
-} from "./chunk-4FAJQPFY.js";
+} from "./chunk-5YVBVJOH.js";
 
 // src/cli/approval-settings-pages.ts
 var API_KEYS_PATH = "/dashboard/agent/settings";

package/dist/{chunk-J6SSLXSU.js → chunk-4OLWSYX5.js}

@@ -1,9 +1,9 @@
 import {
   realpath
-} from "./chunk-YETNUPV5.js";
+} from "./chunk-2MRLDEQY.js";
 import {
   findNativeClaudeInstall
-} from "./chunk-LURFSDCL.js";
+} from "./chunk-VUFHYMSP.js";
 import {
   readGlobalPrefixAsync,
   resolveGlobalBinary,
@@ -13,10 +13,10 @@ import {
   resolvePackageVersionFromBinary,
   resolvePathBinary,
   resolvePathBinaryAsync
-} from "./chunk-BQHZRH6S.js";
+} from "./chunk-VAZCGOLS.js";
 import {
   MANAGED_PROVIDERS
-} from "./chunk-4FAJQPFY.js";
+} from "./chunk-5YVBVJOH.js";
 
 // src/live-capabilities.ts
 import { homedir } from "os";

package/dist/{chunk-JECH4NJL.js → chunk-4QI6SBNR.js}

@@ -1,15 +1,17 @@
 import {
   NpmInstallError,
   NpmMissingError,
-  NpmPermissionError,
+  NpmPermissionError
+} from "./chunk-VAZCGOLS.js";
+import {
   writeFileAtomic
-} from "./chunk-BQHZRH6S.js";
+} from "./chunk-QENTGE75.js";
 import {
   NPX_LATEST_COMMAND
-} from "./chunk-PWGD5EP6.js";
+} from "./chunk-YDT6TVGN.js";
 import {
   readSetupAgentFailures
-} from "./chunk-4FAJQPFY.js";
+} from "./chunk-5YVBVJOH.js";
 
 // src/setup/config-write.ts
 var AgentConfigWriteError = class extends Error {

package/dist/{chunk-UOE26LPT.js → chunk-5BX57BGT.js}

@@ -1,13 +1,13 @@
+import {
+  CLAUDE_CODE_AGENT
+} from "./chunk-UUYLBSAU.js";
 import {
   addGeminiMcpServer,
   removeGeminiMcpServer
-} from "./chunk-VD6CAELE.js";
-import {
-  CLAUDE_CODE_AGENT
-} from "./chunk-Z2TX7DVU.js";
+} from "./chunk-RYUIXLZ5.js";
 import {
   compatibleToolLookup
-} from "./chunk-MP3SEXXJ.js";
+} from "./chunk-OFRQNTJD.js";
 import {
   CLAUDE_HOOK_EVENTS,
   PUSHARY_MCP_URL,
@@ -19,7 +19,7 @@ import {
   isPusharyHook,
   registerHookEntry,
   removeClaudeMcpServers
-} from "./chunk-O7ITTNDD.js";
+} from "./chunk-AYWX6M7J.js";
 import {
   HOOK_COMPATIBLE_PROFILES,
   PHONE_ANSWERED_TOOLS,
@@ -30,7 +30,7 @@ import {
   pusharyMissingReason,
   refusalOutput,
   withHookHoldBudget
-} from "./chunk-4FAJQPFY.js";
+} from "./chunk-5YVBVJOH.js";
 
 // src/config-document.ts
 import { parse, stringify } from "smol-toml";

package/dist/{chunk-4FAJQPFY.js → chunk-5YVBVJOH.js}

@@ -1041,6 +1041,327 @@ var toolsCoveredByGateEntry = (coverage, matcher) => {
 var toolMatches = (match, toolName) => match.kind === "named" ? match.tools.includes(toolName) : toolName.startsWith(match.prefix);
 var cursorGateOwnsToolCall = (registration, toolName) => typeof toolName === "string" && registration.some((match) => toolMatches(match, toolName));
 
+// ../contracts/src/audit-chain.ts
+var AUDIT_CHAIN_FORMAT = "pushary-audit-chain-v1";
+var AUDIT_CHAIN_GENESIS_HASH = "0".repeat(64);
+var AUDIT_CHAIN_EVENTS = ["asked", "decision"];
+var AUDIT_PAYLOAD_STATUSES = ["included", "aged_out", "superseded", "changed_since_recorded"];
+var AUDIT_CHAIN_EXPORT_MAX_ENTRIES = 1e4;
+var AUDIT_CHECKPOINT_KEY_ID_LENGTH = 16;
+var AUDIT_CHECKPOINT_PINNED_KEY_IDS = ["6a4173b664d4d7a7"];
+var AUDIT_CHECKPOINT_INTERVAL_MS = 60 * 60 * 1e3;
+var AUDIT_CHECKPOINT_SWEEP_MS = 10 * 60 * 1e3;
+var AUDIT_CHAIN_PASS_INTERVAL_MS = 60 * 1e3;
+var AUDIT_CHECKPOINT_MAX_AGE_MS = AUDIT_CHECKPOINT_INTERVAL_MS + 2 * AUDIT_CHECKPOINT_SWEEP_MS;
+var AUDIT_CHAIN_FINDING_SEVERITY = {
+  entry_altered: "tampered",
+  entry_changed: "tampered",
+  unrecorded_change: "unverified",
+  invalid_status: "tampered",
+  decision_rewritten: "tampered",
+  asked_twice: "tampered",
+  row_missing: "unverified",
+  broken_link: "tampered",
+  sequence_gap: "tampered",
+  genesis_mismatch: "tampered",
+  checkpoint_mismatch: "tampered",
+  checkpoint_outside_export: "unverified",
+  bad_signature: "tampered",
+  wrong_key_id: "tampered",
+  unpinned_key: "unverified",
+  history_rewritten: "tampered",
+  conflicting_checkpoint: "tampered",
+  rolled_back: "tampered",
+  older_page: "unverified",
+  unsigned: "unverified",
+  stale_signature: "unverified",
+  older_export: "unverified"
+};
+var canonicalAuditPayload = (payload) => `{${Object.keys(payload).sort().map((key) => `${JSON.stringify(key)}:${JSON.stringify(payload[key] ?? null)}`).join(",")}}`;
+var isFinalAuditDecision = (decision) => decision.response !== null || decision.answeredAt !== null;
+var auditPayloadHash = (payload, sha256Hex) => sha256Hex(canonicalAuditPayload(payload));
+var auditEntryMessage = (header) => JSON.stringify([
+  AUDIT_CHAIN_FORMAT,
+  header.prevHash,
+  header.seq,
+  header.event,
+  header.interactionId,
+  header.interactionCreatedAt,
+  header.decisionFinal,
+  header.payloadHash
+]);
+var auditCheckpointMessage = (checkpoint) => `${AUDIT_CHAIN_FORMAT}:checkpoint
+${checkpoint.siteId}
+${checkpoint.seq}
+${checkpoint.headHash}
+${checkpoint.signedAt}`;
+var auditKeyIdOf = (publicKey, sha256Hex) => sha256Hex(publicKey).slice(0, AUDIT_CHECKPOINT_KEY_ID_LENGTH);
+var HASH_PATTERN = /^[0-9a-f]{64}$/;
+var AUDIT_TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{6}Z$/;
+var EXPORT_TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+var isCalendarInstant = (isoMilliseconds) => {
+  const time = Date.parse(isoMilliseconds);
+  return Number.isFinite(time) && new Date(time).toISOString() === isoMilliseconds;
+};
+var isAuditTimestamp = (value) => typeof value === "string" && AUDIT_TIMESTAMP_PATTERN.test(value) && isCalendarInstant(`${value.slice(0, 23)}Z`);
+var isNullableAuditTimestamp = (value) => value === null || isAuditTimestamp(value);
+var isExportTimestamp = (value) => typeof value === "string" && EXPORT_TIMESTAMP_PATTERN.test(value) && isCalendarInstant(value);
+var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isHash = (value) => typeof value === "string" && HASH_PATTERN.test(value);
+var isText = (value) => typeof value === "string";
+var isNullableText = (value) => value === null || typeof value === "string";
+var isNullableNumber = (value) => value === null || typeof value === "number" && Number.isFinite(value);
+var isSeq = (value) => typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+var isNullableSeq = (value) => value === null || isSeq(value);
+var isAuditChainEvent = (value) => typeof value === "string" && AUDIT_CHAIN_EVENTS.includes(value);
+var isAuditPayloadStatus = (value) => typeof value === "string" && AUDIT_PAYLOAD_STATUSES.includes(value);
+var readText = (value, field) => {
+  const fieldValue = value[field];
+  return isText(fieldValue) ? fieldValue : void 0;
+};
+var readNullableText = (value, field) => {
+  const fieldValue = value[field];
+  return isNullableText(fieldValue) ? fieldValue : void 0;
+};
+var ASKED_TEXT_FIELDS = ["id", "siteId", "type", "content", "createdAt"];
+var ASKED_NULLABLE_FIELDS = ["questionType", "context", "contextPayloadSha256", "correlationId", "externalId", "sessionId", "agentType", "agentName", "machineId", "toolName", "toolTarget", "requestedByUserId"];
+var DECISION_NULLABLE_FIELDS = ["response", "responseSource", "note", "decisionOutcome", "decisionOrigin", "decidedByUserId", "decidedByActor", "riskClass", "answeredAt"];
+var isComplete = (record4, fields) => fields.every((field) => field in record4);
+var readFields = (value, fields, read) => {
+  const result = {};
+  for (const field of fields) {
+    const fieldValue = read(value, field);
+    if (fieldValue === void 0) return null;
+    result[field] = fieldValue;
+  }
+  return isComplete(result, fields) ? result : null;
+};
+var ASKED_PAYLOAD_KEYS = /* @__PURE__ */ new Set(["event", ...ASKED_TEXT_FIELDS, ...ASKED_NULLABLE_FIELDS]);
+var DECISION_PAYLOAD_KEYS = /* @__PURE__ */ new Set(["event", "id", "autoResolved", "decisionLatencyMs", ...DECISION_NULLABLE_FIELDS]);
+var hasOnlyKeys = (value, keys2) => Object.keys(value).every((key) => keys2.has(key));
+var parseAskedPayload = (value) => {
+  const text3 = readFields(value, ASKED_TEXT_FIELDS, readText);
+  const nullable = readFields(value, ASKED_NULLABLE_FIELDS, readNullableText);
+  if (!text3 || !nullable || !hasOnlyKeys(value, ASKED_PAYLOAD_KEYS)) return null;
+  if (nullable.contextPayloadSha256 !== null && !isHash(nullable.contextPayloadSha256)) return null;
+  return { event: "asked", ...text3, ...nullable };
+};
+var parseDecisionPayload = (value) => {
+  const id = readText(value, "id");
+  const nullable = readFields(value, DECISION_NULLABLE_FIELDS, readNullableText);
+  const { autoResolved, decisionLatencyMs } = value;
+  if (id === void 0 || !nullable || typeof autoResolved !== "boolean" || !isNullableNumber(decisionLatencyMs)) return null;
+  if (!hasOnlyKeys(value, DECISION_PAYLOAD_KEYS)) return null;
+  return { event: "decision", id, ...nullable, autoResolved, decisionLatencyMs };
+};
+var parsePayload = (event, status, value) => {
+  if (status !== "included") return value === null ? null : void 0;
+  if (!isPlainObject(value) || value.event !== event) return void 0;
+  return (event === "asked" ? parseAskedPayload(value) : parseDecisionPayload(value)) ?? void 0;
+};
+var parseEntry = (value) => {
+  if (!isPlainObject(value)) return null;
+  const { seq, event, interactionId, interactionCreatedAt, decisionFinal, payloadHash, prevHash, entryHash, recordedAt, payloadStatus } = value;
+  if (!isSeq(seq) || !isAuditChainEvent(event) || !isText(interactionId) || !isAuditTimestamp(interactionCreatedAt) || typeof decisionFinal !== "boolean" || !isHash(payloadHash) || !isHash(prevHash) || !isHash(entryHash) || !isText(recordedAt) || !isAuditPayloadStatus(payloadStatus)) return null;
+  const payload = parsePayload(event, payloadStatus, value.payload);
+  if (payload === void 0) return null;
+  return { seq, event, interactionId, interactionCreatedAt, decisionFinal, payloadHash, prevHash, entryHash, recordedAt, payloadStatus, payload };
+};
+var parseAuditChainCheckpoint = (value) => {
+  if (!isPlainObject(value)) return null;
+  const { siteId, seq, headHash, signedAt, keyId, publicKey, signature } = value;
+  if (!isText(siteId) || !isSeq(seq) || !isHash(headHash) || !isAuditTimestamp(signedAt) || !isText(keyId) || !isText(publicKey) || !isText(signature)) return null;
+  return { siteId, seq, headHash, signedAt, keyId, publicKey, signature };
+};
+var parseAllOrNothing = (values, parse) => {
+  if (!Array.isArray(values)) return null;
+  const parsed = [];
+  for (const value of values) {
+    const item = parse(value);
+    if (item === null) return null;
+    parsed.push(item);
+  }
+  return parsed;
+};
+var entriesFitPage = (entries, beforeSeq) => beforeSeq === null || entries.every((entry) => entry.seq < beforeSeq);
+var parseSite = (value) => {
+  if (!isPlainObject(value)) return null;
+  const { siteId, siteName, beforeSeq, retentionFloor } = value;
+  if (!isText(siteId) || !isText(siteName) || !isNullableSeq(beforeSeq) || !isNullableAuditTimestamp(retentionFloor)) return null;
+  const entries = parseAllOrNothing(value.entries, parseEntry);
+  const checkpoints = parseAllOrNothing(value.checkpoints, parseAuditChainCheckpoint);
+  if (!entries || !checkpoints || !entriesFitPage(entries, beforeSeq)) return null;
+  return { siteId, siteName, beforeSeq, retentionFloor, entries, checkpoints };
+};
+var parseAuditChainExport = (value) => {
+  if (!isPlainObject(value) || value.format !== AUDIT_CHAIN_FORMAT || !isExportTimestamp(value.exportedAt)) return null;
+  const sites = parseAllOrNothing(value.sites, parseSite);
+  return sites && sites.length > 0 ? { format: AUDIT_CHAIN_FORMAT, exportedAt: value.exportedAt, sites } : null;
+};
+var boundaryGapFindings = (entries, beforeSeq) => {
+  const findings = beforeSeq === null ? [] : [{ kind: "older_page", beforeSeq }];
+  const first = entries[0];
+  if (first && first.seq > 1 && entries.length < AUDIT_CHAIN_EXPORT_MAX_ENTRIES) findings.push({ kind: "sequence_gap", afterSeq: 0, seq: first.seq });
+  const lastSeq = entries[entries.length - 1]?.seq ?? 0;
+  if (beforeSeq !== null && lastSeq < beforeSeq - 1) findings.push({ kind: "sequence_gap", afterSeq: lastSeq, seq: beforeSeq });
+  return findings;
+};
+var linkFindings = (entries) => {
+  const findings = [];
+  entries.forEach((entry, index) => {
+    const previous = entries[index - 1];
+    if (!previous) {
+      if (entry.seq === 1 && entry.prevHash !== AUDIT_CHAIN_GENESIS_HASH) findings.push({ kind: "genesis_mismatch", seq: entry.seq });
+      return;
+    }
+    if (entry.seq !== previous.seq + 1) findings.push({ kind: "sequence_gap", afterSeq: previous.seq, seq: entry.seq });
+    if (entry.prevHash !== previous.entryHash) findings.push({ kind: "broken_link", seq: entry.seq });
+  });
+  return findings;
+};
+var entryHashFindings = (entries, crypto) => entries.flatMap((entry) => crypto.sha256Hex(auditEntryMessage(entry)) === entry.entryHash ? [] : [{ kind: "entry_altered", seq: entry.seq }]);
+var payloadMatchesEntry = (payload, entry, siteId, crypto) => {
+  if (payload.id !== entry.interactionId || auditPayloadHash(payload, crypto.sha256Hex) !== entry.payloadHash) return false;
+  return payload.event === "asked" ? payload.siteId === siteId && payload.createdAt === entry.interactionCreatedAt : isFinalAuditDecision(payload) === entry.decisionFinal;
+};
+var lastDecisionSeqByInteraction = (entries) => {
+  const lastSeq = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.event === "decision") lastSeq.set(entry.interactionId, Math.max(entry.seq, lastSeq.get(entry.interactionId) ?? 0));
+  }
+  return lastSeq;
+};
+var goneBeforeRetentionEnded = (entry, retentionFloor) => retentionFloor === null || entry.interactionCreatedAt >= retentionFloor;
+var payloadFindings = (site, entries, crypto) => {
+  const lastDecisionSeq = lastDecisionSeqByInteraction(entries);
+  return entries.flatMap((entry) => {
+    const invalid = { kind: "invalid_status", seq: entry.seq, status: entry.payloadStatus };
+    const hasLaterDecision = entry.event === "decision" && (lastDecisionSeq.get(entry.interactionId) ?? 0) > entry.seq;
+    switch (entry.payloadStatus) {
+      case "included":
+        if (hasLaterDecision) return [invalid];
+        return entry.payload && payloadMatchesEntry(entry.payload, entry, site.siteId, crypto) ? [] : [{ kind: "entry_changed", seq: entry.seq }];
+      case "changed_since_recorded":
+        if (entry.event === "asked" || hasLaterDecision) return [invalid];
+        return [{ kind: entry.decisionFinal ? "entry_changed" : "unrecorded_change", seq: entry.seq }];
+      case "superseded":
+        return entry.event === "asked" || entry.decisionFinal || !hasLaterDecision && site.beforeSeq === null ? [invalid] : [];
+      case "aged_out":
+        return goneBeforeRetentionEnded(entry, site.retentionFloor) ? [{ kind: "row_missing", seq: entry.seq }] : [];
+    }
+  });
+};
+var decisionSequenceFindings = (entries) => {
+  const asked = /* @__PURE__ */ new Set();
+  const decidedFinally = /* @__PURE__ */ new Set();
+  return entries.flatMap((entry) => {
+    if (entry.event === "asked") {
+      const repeated = asked.has(entry.interactionId);
+      asked.add(entry.interactionId);
+      return repeated ? [{ kind: "asked_twice", seq: entry.seq }] : [];
+    }
+    const afterFinal = decidedFinally.has(entry.interactionId);
+    if (entry.decisionFinal) decidedFinally.add(entry.interactionId);
+    return afterFinal ? [{ kind: "decision_rewritten", seq: entry.seq }] : [];
+  });
+};
+var payloadCountsOf = (entries) => ({
+  included: entries.filter((entry) => entry.payloadStatus === "included").length,
+  aged_out: entries.filter((entry) => entry.payloadStatus === "aged_out").length,
+  superseded: entries.filter((entry) => entry.payloadStatus === "superseded").length,
+  changed_since_recorded: entries.filter((entry) => entry.payloadStatus === "changed_since_recorded").length
+});
+var findingsForCheckpoint = (checkpoint, siteId, hashBySeq, crypto, pinnedKeyIds) => {
+  const findings = [];
+  const entryHash = hashBySeq.get(checkpoint.seq);
+  if (entryHash === void 0) findings.push({ kind: "checkpoint_outside_export", seq: checkpoint.seq });
+  else if (entryHash !== checkpoint.headHash) findings.push({ kind: "checkpoint_mismatch", seq: checkpoint.seq });
+  if (checkpoint.siteId !== siteId || !crypto.verifyEd25519(auditCheckpointMessage(checkpoint), checkpoint.signature, checkpoint.publicKey)) {
+    findings.push({ kind: "bad_signature", seq: checkpoint.seq });
+  }
+  if (auditKeyIdOf(checkpoint.publicKey, crypto.sha256Hex) !== checkpoint.keyId) findings.push({ kind: "wrong_key_id", seq: checkpoint.seq });
+  else if (!pinnedKeyIds.includes(checkpoint.keyId)) findings.push({ kind: "unpinned_key", seq: checkpoint.seq, keyId: checkpoint.keyId });
+  return findings;
+};
+var checkpointWorthRemembering = (findings, pinnedKeyIds) => findings.every((finding) => finding.kind === "unpinned_key" && pinnedKeyIds.length === 0);
+var freshCheckpointCutoffFor = (exportedAt) => auditTimestampFromDate(new Date(Date.parse(exportedAt) - AUDIT_CHECKPOINT_MAX_AGE_MS));
+var signatureFindings = (site, lastSeq, exportedAt) => {
+  if (lastSeq === null) return [];
+  const newest = [...site.checkpoints].sort((left, right) => right.seq - left.seq)[0];
+  if (!newest) return [{ kind: "unsigned" }];
+  const unsignedTail = site.beforeSeq === null && lastSeq > newest.seq && newest.signedAt < freshCheckpointCutoffFor(exportedAt);
+  return unsignedTail ? [{ kind: "stale_signature", seq: newest.seq, signedAt: newest.signedAt }] : [];
+};
+var newestHeadOf = (heads) => [...heads].sort((left, right) => right.seq - left.seq)[0];
+var tailFindings = (site, lastSeq, exportedAt, knownForSite) => {
+  if (site.beforeSeq !== null) return [];
+  const beyond = knownForSite.filter((head) => head.seq > lastSeq);
+  const rolledBack = newestHeadOf(beyond.filter((head) => head.exportedAt < exportedAt));
+  if (rolledBack) return [{ kind: "rolled_back", seq: rolledBack.seq }];
+  const seenInLaterExport = newestHeadOf(beyond);
+  return seenInLaterExport ? [{ kind: "older_export", seq: seenInLaterExport.seq, exportedAt: seenInLaterExport.exportedAt }] : [];
+};
+var knownHeadFindings = (site, hashBySeq, lastSeq, exportedAt, known) => {
+  const exported = new Map(site.checkpoints.map((checkpoint) => [checkpoint.seq, checkpoint.headHash]));
+  const knownForSite = known.filter((checkpoint) => checkpoint.siteId === site.siteId);
+  const findings = knownForSite.flatMap((checkpoint) => {
+    const found = [];
+    const entryHash = hashBySeq.get(checkpoint.seq);
+    if (entryHash !== void 0 && entryHash !== checkpoint.headHash) found.push({ kind: "history_rewritten", seq: checkpoint.seq });
+    const exportedHash = exported.get(checkpoint.seq);
+    if (exportedHash !== void 0 && exportedHash !== checkpoint.headHash) found.push({ kind: "conflicting_checkpoint", seq: checkpoint.seq });
+    return found;
+  });
+  return [...findings, ...tailFindings(site, lastSeq, exportedAt, knownForSite)];
+};
+var verifyAuditChainSite = (site, crypto, options) => {
+  const entries = [...site.entries].sort((left, right) => left.seq - right.seq);
+  const hashBySeq = new Map(entries.map((entry) => [entry.seq, entry.entryHash]));
+  const firstSeq = entries[0]?.seq ?? null;
+  const lastSeq = entries[entries.length - 1]?.seq ?? null;
+  const checkpointResults = site.checkpoints.map((checkpoint) => ({
+    checkpoint,
+    findings: findingsForCheckpoint(checkpoint, site.siteId, hashBySeq, crypto, options.pinnedKeyIds)
+  }));
+  return {
+    siteId: site.siteId,
+    siteName: site.siteName,
+    exportedAt: options.exportedAt,
+    entryCount: entries.length,
+    firstSeq,
+    lastSeq,
+    lastEntryHash: entries[entries.length - 1]?.entryHash ?? null,
+    payloadCounts: payloadCountsOf(entries),
+    signedCheckpoints: site.checkpoints.length,
+    truncated: firstSeq !== null && firstSeq > 1,
+    retentionFloor: site.retentionFloor,
+    findings: [
+      ...boundaryGapFindings(entries, site.beforeSeq),
+      ...linkFindings(entries),
+      ...entryHashFindings(entries, crypto),
+      ...payloadFindings(site, entries, crypto),
+      ...decisionSequenceFindings(entries),
+      ...signatureFindings(site, lastSeq, options.exportedAt),
+      ...checkpointResults.flatMap((result) => result.findings),
+      ...knownHeadFindings(site, hashBySeq, lastSeq ?? 0, options.exportedAt, options.knownHeads)
+    ],
+    verifiedCheckpoints: checkpointResults.filter((result) => checkpointWorthRemembering(result.findings, options.pinnedKeyIds)).map((result) => result.checkpoint)
+  };
+};
+var auditChainVerdictTampered = (verdict) => verdict.findings.some((finding) => AUDIT_CHAIN_FINDING_SEVERITY[finding.kind] === "tampered");
+var auditHeadsToRemember = (verdict) => {
+  if (auditChainVerdictTampered(verdict)) return [];
+  const headOf = (seq, headHash) => ({ siteId: verdict.siteId, seq, headHash, exportedAt: verdict.exportedAt });
+  const newestEntry = verdict.lastSeq !== null && verdict.lastEntryHash !== null ? [headOf(verdict.lastSeq, verdict.lastEntryHash)] : [];
+  return [...verdict.verifiedCheckpoints.map((checkpoint) => headOf(checkpoint.seq, checkpoint.headHash)), ...newestEntry];
+};
+var parseAuditKnownHead = (value) => {
+  if (!isPlainObject(value)) return null;
+  const { siteId, seq, headHash, exportedAt } = value;
+  return isText(siteId) && isSeq(seq) && isHash(headHash) && isExportTimestamp(exportedAt) ? { siteId, seq, headHash, exportedAt } : null;
+};
+var auditTimestampFromDate = (date) => date.toISOString().replace(/Z$/, "000Z");
+
 // ../contracts/src/receipt-evidence.ts
 var RECEIPT_TARGET_MAX_LENGTH = 256;
 var GIT_BRANCH_MAX_LENGTH = 256;
@@ -8204,6 +8525,15 @@ var hookActivationResult = (report) => {
 };
 
 export {
+  AUDIT_CHECKPOINT_PINNED_KEY_IDS,
+  AUDIT_CHECKPOINT_MAX_AGE_MS,
+  AUDIT_CHAIN_FINDING_SEVERITY,
+  parseAllOrNothing,
+  parseAuditChainExport,
+  verifyAuditChainSite,
+  auditChainVerdictTampered,
+  auditHeadsToRemember,
+  parseAuditKnownHead,
   redactSecrets,
   redactSecretsFromContent,
   redactSecretsDeep,

package/dist/{chunk-4TVLPGJV.js → chunk-6B4R7HUV.js}

@@ -1,6 +1,6 @@
 import {
   isSafeReadOnlyCommand
-} from "./chunk-4FAJQPFY.js";
+} from "./chunk-5YVBVJOH.js";
 
 // src/ledger.ts
 import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync } from "fs";

package/dist/{chunk-JKOAAIJD.js → chunk-7RHEZVAE.js}

@@ -1,19 +1,19 @@
 import {
   macAppBridgeAvailable
-} from "./chunk-PM34Z5WX.js";
+} from "./chunk-RDUY7MKN.js";
 import {
   keyPrefix
-} from "./chunk-HYAQIKYB.js";
+} from "./chunk-NKA2PEQQ.js";
 import {
   bridgeAgentKey
-} from "./chunk-O7ITTNDD.js";
+} from "./chunk-AYWX6M7J.js";
 import {
   readJsonSafe
-} from "./chunk-BQHZRH6S.js";
+} from "./chunk-QENTGE75.js";
 import {
   isRecord,
   isValidApiKey
-} from "./chunk-4FAJQPFY.js";
+} from "./chunk-5YVBVJOH.js";
 
 // src/shared-mcp-key.ts
 var asRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;

package/dist/{chunk-RVSRPDRF.js → chunk-AE2BQ3XM.js}

@@ -7,10 +7,10 @@ import {
   codexHome,
   codexHooksJsonIn,
   isPusharyCodexCommand
-} from "./chunk-O7ITTNDD.js";
+} from "./chunk-AYWX6M7J.js";
 import {
   resolvePathBinary
-} from "./chunk-BQHZRH6S.js";
+} from "./chunk-VAZCGOLS.js";
 import {
   getPackageVersion
 } from "./chunk-ZVU6WMMU.js";

package/dist/{chunk-SRE6XJ3K.js → chunk-AG7PFGGE.js}

@@ -3,10 +3,10 @@ import {
   forkFinishWithUpgradeLock,
   installWithUpgradeLock,
   releaseAutoUpdateLock
-} from "./chunk-JVE4P54I.js";
+} from "./chunk-4HBWXZPI.js";
 import {
   phoneStartIsRequired
-} from "./chunk-J6SSLXSU.js";
+} from "./chunk-4OLWSYX5.js";
 import {
   describeAutoUpdateCheck,
   globalInstallLocation,
@@ -18,25 +18,25 @@ import {
   readAutoUpdateState,
   updateAutoUpdateState,
   upgradeEntryFor
-} from "./chunk-EOD3DBIN.js";
+} from "./chunk-SJJCCFD5.js";
 import {
   autoUpdateLock,
   autoUpdateLog,
   autoUpdateState
-} from "./chunk-O7ITTNDD.js";
+} from "./chunk-AYWX6M7J.js";
 import {
   execNpm,
   fetchLatestPublishedVersion,
   npmErrorMessage,
   readGlobalCliInstallAt,
   readGlobalPrefix
-} from "./chunk-BQHZRH6S.js";
+} from "./chunk-VAZCGOLS.js";
 import {
   EXIT
-} from "./chunk-KZERVKTD.js";
+} from "./chunk-BG4HHB7E.js";
 import {
   NPX_LATEST_COMMAND
-} from "./chunk-PWGD5EP6.js";
+} from "./chunk-YDT6TVGN.js";
 import {
   commandsPackage,
   globalUpgradeEntry,

package/dist/{chunk-O7ITTNDD.js → chunk-AYWX6M7J.js}

@@ -2,9 +2,11 @@ import {
   atLeast,
   formatVersion,
   quoteIfNeeded,
-  shellDoubleQuoted,
+  shellDoubleQuoted
+} from "./chunk-VAZCGOLS.js";
+import {
   writeFileAtomic
-} from "./chunk-BQHZRH6S.js";
+} from "./chunk-QENTGE75.js";
 import {
   cmdShimScriptOf
 } from "./chunk-ZVU6WMMU.js";
@@ -15,7 +17,7 @@ import {
   HOOK_LOCATOR_BINARY,
   PRETOOLUSE_GATED_TOOLS,
   withHookHoldBudget
-} from "./chunk-4FAJQPFY.js";
+} from "./chunk-5YVBVJOH.js";
 
 // src/setup/paths.ts
 import { createHash as createHash2 } from "crypto";

package/dist/{chunk-JUA7MX2V.js → chunk-BDSI2NEN.js}

@@ -1,17 +1,17 @@
 import {
   compatibleConfigFile,
   hasCompatibleHooks
-} from "./chunk-UOE26LPT.js";
+} from "./chunk-5BX57BGT.js";
 import {
   pusharyHookExecutable
-} from "./chunk-VD6CAELE.js";
+} from "./chunk-RYUIXLZ5.js";
 import {
   isProtectedByScope,
   registerHookEntry
-} from "./chunk-O7ITTNDD.js";
+} from "./chunk-AYWX6M7J.js";
 import {
   isRecord
-} from "./chunk-4FAJQPFY.js";
+} from "./chunk-5YVBVJOH.js";
 
 // src/cursor-config.ts
 var hookCommandOf = (entry) => {