pushary 1.9.103 → 1.9.105

package/dist/{chunk-4FAJQPFY.js → chunk-O5TB2LMQ.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;
@@ -3187,6 +3508,11 @@ var MIN_SAFE_CLI_VERSION = formatReleaseVersion(MIN_SAFE_RELEASE);
 var AUTO_UPDATE_RESULTS = ["updated", "current", "needs_manual", "failed", "finish_pending", "finish_blocked"];
 var isAutoUpdateResult = (value) => typeof value === "string" && AUTO_UPDATE_RESULTS.includes(value);
 
+// ../contracts/src/hook-wiring-report.ts
+var HOOK_WIRING_REPORT_VERSION = 1;
+var HOOK_WIRING_PROFILE_LENGTH = 16;
+var HOOK_WIRING_PROFILE_PATTERN = new RegExp(`^[0-9a-f]{${HOOK_WIRING_PROFILE_LENGTH}}$`);
+
 // ../contracts/src/answer-drafts.ts
 var ANSWER_DRAFT_TTL_MS = 24 * 60 * 60 * 1e3;
 
@@ -8204,6 +8530,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,
@@ -8282,6 +8617,7 @@ export {
   CURSOR_GATE_COVERAGE,
   isCursorHookPayload,
   NO_CURSOR_GATE,
+  matcherMatchesEveryCall,
   toolsCoveredByGateEntry,
   cursorGateOwnsToolCall,
   claudeTurnEndOutput,
@@ -8313,6 +8649,8 @@ export {
   withDeclinedAgent,
   withoutDeclinedAgent,
   isAutoUpdateResult,
+  HOOK_WIRING_REPORT_VERSION,
+  HOOK_WIRING_PROFILE_LENGTH,
   SESSION_HISTORY_BACKFILL_LIMIT_BYTES,
   PERSONAL_QUESTION_CAPABILITY,
   isQuestionOwner,

package/dist/{chunk-AVXG5QB2.js → chunk-OBZQPBUI.js}

@@ -1,20 +1,20 @@
 import {
   openCodeConfigDirFrom
-} from "./chunk-PM34Z5WX.js";
+} from "./chunk-IHQRLJEP.js";
 import {
   nativeClaudeInstallPath
-} from "./chunk-LURFSDCL.js";
+} from "./chunk-ROVLRXBI.js";
 import {
   grokHome
-} from "./chunk-UOE26LPT.js";
+} from "./chunk-JLJJRBTD.js";
 import {
   claudeConfigDir,
   clineDataDirectory,
   codexHomeFrom
-} from "./chunk-O7ITTNDD.js";
+} from "./chunk-JCSJEMTA.js";
 import {
   HOOK_COMPATIBLE_PROFILES
-} from "./chunk-4FAJQPFY.js";
+} from "./chunk-O5TB2LMQ.js";
 
 // src/vscode-config.ts
 import { homedir } from "os";

package/dist/chunk-OINGJICB.js

@@ -0,0 +1,108 @@
+import {
+  pusharyHookExecutable
+} from "./chunk-MFJHLVIZ.js";
+import {
+  bridgeResolvesToApp,
+  cursorUserHooks,
+  executableFileName,
+  isBridgeLocator,
+  liveBridgeProbe
+} from "./chunk-JCSJEMTA.js";
+import {
+  atLeast,
+  parseVersion
+} from "./chunk-ZCBTCW3T.js";
+import {
+  CURSOR_GATE_COVERAGE,
+  CURSOR_GATE_SCRIPT,
+  HOOK_VERSION_PATTERN,
+  NO_CURSOR_GATE,
+  cursorGateOwnsToolCall,
+  isCursorHookPayload,
+  isRecord,
+  toolsCoveredByGateEntry
+} from "./chunk-O5TB2LMQ.js";
+
+// src/cursor-gate-registration.ts
+import { dirname, isAbsolute, join, resolve } from "path";
+var FIRST_PLUGIN_VERSION_HANDLING = {
+  beforeShellExecution: [0, 1, 0],
+  beforeMCPExecution: [0, 2, 1],
+  preToolUse: [0, 2, 2]
+};
+var COMMAND_HOOK_TYPE = "command";
+var PLUGIN_MANIFEST = join(".cursor-plugin", "plugin.json");
+var isCursorGateScript = (executable) => executableFileName(executable) === CURSOR_GATE_SCRIPT;
+var fromHooksDirectory = (path, environment) => isAbsolute(path) ? path : resolve(dirname(environment.hooksFile), path);
+var pluginManifestBeside = (script) => join(dirname(dirname(script)), PLUGIN_MANIFEST);
+var versionIn = (manifest) => {
+  try {
+    const parsed = JSON.parse(manifest);
+    return isRecord(parsed) && typeof parsed.version === "string" && HOOK_VERSION_PATTERN.test(parsed.version) ? parseVersion(parsed.version) : null;
+  } catch {
+    return null;
+  }
+};
+var pluginVersionOf = (script, probe) => {
+  const manifest = probe.readFile(pluginManifestBeside(script));
+  return manifest === null ? null : versionIn(manifest);
+};
+var gateScriptHandles = (script, event, probe) => {
+  if (!probe.exists(script)) return false;
+  const version = pluginVersionOf(script, probe);
+  return version !== null && atLeast(version, FIRST_PLUGIN_VERSION_HANDLING[event]);
+};
+var isLiveCursorGateCommand = (command, event, environment) => {
+  const executable = pusharyHookExecutable(command);
+  if (executable === null) return false;
+  const target = fromHooksDirectory(executable, environment);
+  if (isCursorGateScript(executable)) return gateScriptHandles(target, event, environment.probe);
+  return isBridgeLocator(executable) && bridgeResolvesToApp(target, environment.probe);
+};
+var isCommandHook = (entry) => entry.type === void 0 || entry.type === COMMAND_HOOK_TYPE;
+var entriesOn = (hooks, event) => {
+  const entries = Object.hasOwn(hooks, event) ? hooks[event] : void 0;
+  return Array.isArray(entries) ? entries.filter(isRecord) : [];
+};
+var runsALiveGate = (entry, event, isLiveGate) => isCommandHook(entry) && typeof entry.command === "string" && isLiveGate(entry.command, event);
+var toolsCoveredOn = (hooks, coverage, isLiveGate) => entriesOn(hooks, coverage.event).filter((entry) => runsALiveGate(entry, coverage.event, isLiveGate)).flatMap((entry) => toolsCoveredByGateEntry(coverage, entry.matcher) ?? []);
+var cursorGateRegistrationOf = (document, isLiveGate) => {
+  if (!isRecord(document) || !isRecord(document.hooks)) return NO_CURSOR_GATE;
+  const hooks = document.hooks;
+  return CURSOR_GATE_COVERAGE.flatMap((coverage) => toolsCoveredOn(hooks, coverage, isLiveGate));
+};
+var coversEveryTool = (covers, covered) => {
+  if (covers.kind === "prefix") return covered.some((match) => match.kind === "prefix" && match.prefix === covers.prefix);
+  return covers.tools.every((tool) => covered.some((match) => match.kind === "named" && match.tools.includes(tool)));
+};
+var NO_LIVE_CURSOR_GATE = { full: [], partial: [] };
+var liveCursorGateCoverage = (document, environment) => {
+  if (!isRecord(document) || !isRecord(document.hooks)) return NO_LIVE_CURSOR_GATE;
+  const hooks = document.hooks;
+  const isLiveGate = (command, event) => isLiveCursorGateCommand(command, event, environment);
+  const coverage = CURSOR_GATE_COVERAGE.map((gate) => {
+    const covered = toolsCoveredOn(hooks, gate, isLiveGate);
+    return { event: gate.event, coversEveryTool: coversEveryTool(gate.covers, covered), coversSomeTool: covered.length > 0 };
+  });
+  return {
+    full: coverage.filter((gate) => gate.coversEveryTool).map((gate) => gate.event),
+    partial: coverage.filter((gate) => gate.coversSomeTool && !gate.coversEveryTool).map((gate) => gate.event)
+  };
+};
+var userCursorGateEnvironment = () => ({ hooksFile: cursorUserHooks(), probe: liveBridgeProbe() });
+var readCursorGateRegistration = (environment = userCursorGateEnvironment()) => {
+  try {
+    const raw = environment.probe.readFile(environment.hooksFile);
+    if (raw === null) return NO_CURSOR_GATE;
+    return cursorGateRegistrationOf(JSON.parse(raw), (command, event) => isLiveCursorGateCommand(command, event, environment));
+  } catch {
+    return NO_CURSOR_GATE;
+  }
+};
+var cursorGateOwnsClaudeCall = (payload, readRegistration) => isCursorHookPayload(payload) && cursorGateOwnsToolCall(readRegistration(), payload.tool_name);
+
+export {
+  liveCursorGateCoverage,
+  readCursorGateRegistration,
+  cursorGateOwnsClaudeCall
+};

package/dist/{chunk-RMFL62HR.js → chunk-P3H6I656.js}

@@ -1,13 +1,13 @@
 import {
   ensureCodexTrustsPusharyHooks
-} from "./chunk-RVSRPDRF.js";
+} from "./chunk-VKTW5WVB.js";
 import {
   hermesReceiptPaths,
   hermesSetupPredatesThePluginFolder,
   installHermesPlugin,
   refreshHermesPluginFiles,
   shippedHermesPlugin
-} from "./chunk-COBOR3ST.js";
+} from "./chunk-NM44KCO6.js";
 import {
   fxIgnoresInstructionsFile,
   fxInstructionsBody,
@@ -16,7 +16,7 @@ import {
   macAppFxBridge,
   refreshClineKey,
   switchFxHttpEntryToBridge
-} from "./chunk-SXAZPWL7.js";
+} from "./chunk-UXIUCMFO.js";
 import {
   OPENCODE_HOOK_BINARY,
   agentHookOwner,
@@ -28,16 +28,16 @@ import {
   openCodePluginDir,
   openCodeWired,
   withOpenCodeAskRules
-} from "./chunk-PM34Z5WX.js";
+} from "./chunk-IHQRLJEP.js";
 import {
   detectClaudeVersion
-} from "./chunk-YETNUPV5.js";
+} from "./chunk-IGO5NDQY.js";
 import {
   addCompatibleHooks,
   compatibleConfigFile,
   compatibleInstructionsFile,
   hasCompatibleHooks
-} from "./chunk-UOE26LPT.js";
+} from "./chunk-JLJJRBTD.js";
 import {
   GEMINI_HOOK_BINARY,
   addGeminiHooks,
@@ -49,7 +49,7 @@ import {
   geminiWired,
   hasGeminiHooks,
   planHooks
-} from "./chunk-VD6CAELE.js";
+} from "./chunk-MFJHLVIZ.js";
 import {
   CLAUDE_HOOK_BINARY,
   CLAUDE_HOOK_EVENTS,
@@ -95,21 +95,23 @@ import {
   renderAgentInstructions,
   supportedClaudeEvents,
   vscodePluginMcp
-} from "./chunk-O7ITTNDD.js";
+} from "./chunk-JCSJEMTA.js";
 import {
   formatVersion,
   hookCommandsUseBareNames,
-  readJsonSafe,
   resolveGlobalBinDir,
-  resolveGlobalBinary,
+  resolveGlobalBinary
+} from "./chunk-ZCBTCW3T.js";
+import {
+  readJsonSafe,
   writeFileAtomic,
   writeJsonAtomic
-} from "./chunk-BQHZRH6S.js";
+} from "./chunk-T5I4PKOQ.js";
 import {
   HOOK_COMPATIBLE_PROFILES,
   isCompatibleAgentType,
   isRecord
-} from "./chunk-4FAJQPFY.js";
+} from "./chunk-O5TB2LMQ.js";
 
 // src/reapply.ts
 import { dirname, join } from "path";

package/dist/{chunk-Y7KRX7U4.js → chunk-P3VVRBBI.js}

@@ -1,7 +1,7 @@
 import {
   readOwnerOnlyJson,
   transcriptReadPositionSchema
-} from "./chunk-G7RMOSRX.js";
+} from "./chunk-HXBQTPKC.js";
 import {
   external_exports
 } from "./chunk-XMSDA5WA.js";

package/dist/{chunk-V5DV7XZN.js → chunk-PFZCLG55.js}

@@ -1,17 +1,17 @@
 import {
   keyCheckFromResponse
-} from "./chunk-7BIVBOD5.js";
+} from "./chunk-EMSRB2KH.js";
 import {
   installNetworkDefaults
-} from "./chunk-KLJ2CTT7.js";
+} from "./chunk-LL7SW4RL.js";
 import {
   getBaseUrl
-} from "./chunk-KOUB4ZLX.js";
+} from "./chunk-GKCDMAUM.js";
 import {
   isRecord,
   isToolErrorResult,
   toolFailureCodeOfResult
-} from "./chunk-4FAJQPFY.js";
+} from "./chunk-O5TB2LMQ.js";
 
 // src/retry.ts
 var isRetryable = (err) => {

package/dist/{chunk-2S5J5YI2.js → chunk-QCFWJZGT.js}

@@ -1,19 +1,19 @@
 import {
   notificationAnswerStep
-} from "./chunk-O5ZKMUTP.js";
+} from "./chunk-X4TZN52V.js";
 import {
   canChangeApprovalSettings
-} from "./chunk-WYJ6QM7K.js";
+} from "./chunk-2HC5ISDW.js";
 import {
   matchMacAccountStep,
   retryAgentCommand
-} from "./chunk-JECH4NJL.js";
+} from "./chunk-FJYUB3ZK.js";
 import {
   EXIT
-} from "./chunk-KZERVKTD.js";
+} from "./chunk-BG4HHB7E.js";
 import {
   NPX_LATEST_COMMAND
-} from "./chunk-PWGD5EP6.js";
+} from "./chunk-YDQ6OJMF.js";
 
 // src/setup/closing.ts
 var ACTIVITY_URL = "pushary.com/dashboard/agent/activity";