pushary 1.9.76 → 1.9.78

package/dist/{chunk-7SFP6Y5U.js → chunk-T2MJ5H2V.js}

@@ -3,16 +3,16 @@ import {
   loadPin,
   savePin,
   verifyRecipients
-} from "./chunk-YLB4AGZJ.js";
+} from "./chunk-MPZFQP6O.js";
 import {
   SESSION_HISTORY_RETENTION_DAYS
 } from "./chunk-MHUKYYYR.js";
 import {
   ensureDaemonRunning
-} from "./chunk-DB3NOEDW.js";
+} from "./chunk-7KMI2G24.js";
 import {
   hookOwnerOf
-} from "./chunk-KGWLDNNT.js";
+} from "./chunk-3XH4YLCN.js";
 import {
   buildTranscriptRecords,
   decodePublicKey,
@@ -23,39 +23,42 @@ import {
   recordSealerFor,
   uploadTranscriptRecords,
   wrapSessionKey
-} from "./chunk-ITLWEGLE.js";
+} from "./chunk-Z5VZWDGL.js";
 import {
   external_exports
 } from "./chunk-XMSDA5WA.js";
 import {
   transcriptEnvironmentPreference,
   transcriptsEnabled
-} from "./chunk-5M5F4IWR.js";
+} from "./chunk-IVY6LYTO.js";
 import {
   readTranscriptPreference
-} from "./chunk-7LLC4R66.js";
+} from "./chunk-NH7C6QBI.js";
 import {
   claudeConfigDir,
   codexHome,
   pusharyDir
-} from "./chunk-7KYQ24FI.js";
+} from "./chunk-TQYSBYYZ.js";
 import {
-  writeJsonAtomic
-} from "./chunk-T2EJ3H6Y.js";
+  writeJsonAtomic,
+  writeJsonAtomicDurable
+} from "./chunk-Y4I5YX3L.js";
 import {
   getApiKey,
   getBaseUrl
-} from "./chunk-M7JFGDGP.js";
+} from "./chunk-Q53QJQLY.js";
 import {
   PENDING_COMMAND_PREFIX,
   SESSION_HISTORY_BACKFILL_LIMIT_BYTES,
+  canonicalJsonText,
+  isRecord,
   redactSecretsFromContent
-} from "./chunk-Y4OBAK4I.js";
+} from "./chunk-OFJUHEEG.js";
 
 // src/transcript-registration.ts
-import { createHash } from "crypto";
-import { readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync3, unlinkSync as unlinkSync2 } from "fs";
-import { basename, isAbsolute, join as join4, resolve as resolve2, sep } from "path";
+import { createHash as createHash4 } from "crypto";
+import { readFileSync as readFileSync6, readdirSync as readdirSync2, realpathSync, statSync as statSync3, unlinkSync as unlinkSync2 } from "fs";
+import { basename, dirname as dirname2, isAbsolute, join as join5, relative, resolve as resolve2, sep } from "path";
 
 // src/claude-display-draft.ts
 import { closeSync, fstatSync, lstatSync, openSync, readFileSync, readSync, unlinkSync } from "fs";
@@ -202,18 +205,17 @@ var readDisplayDraft = (sessionId, runtime) => {
 };
 
 // src/transcript-session-key.ts
-import { existsSync, mkdirSync, readFileSync as readFileSync2, readdirSync, rmSync, statSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync as readFileSync2, readdirSync, rmSync, statSync } from "fs";
 import { homedir } from "os";
 import { join as join2 } from "path";
 var sessionKeyDirectory = () => process.env.PUSHARY_SESSION_KEY_DIR?.trim() || join2(homedir(), ".pushary", "sessions");
-var SESSION_KEY_TTL_MS = 48 * 60 * 60 * 1e3;
+var SESSION_DISPLAY_TTL_MS = 48 * 60 * 60 * 1e3;
 var SAFE_SESSION_ID = /^[A-Za-z0-9._-]{1,128}$/;
 var fileFor2 = (sessionId, directory) => SAFE_SESSION_ID.test(sessionId) ? join2(directory, `${sessionId}.json`) : null;
 var loadSessionKey = (sessionId, directory = sessionKeyDirectory()) => {
   const path = fileFor2(sessionId, directory);
   if (!path || !existsSync(path)) return null;
   try {
-    if (Date.now() - statSync(path).mtimeMs > SESSION_KEY_TTL_MS) return null;
     const raw = JSON.parse(readFileSync2(path, "utf-8"));
     const key = typeof raw.sessionKey === "string" ? Buffer.from(raw.sessionKey, "base64") : null;
     if (!key || key.length !== 32) return null;
@@ -231,33 +233,31 @@ var loadSessionKey = (sessionId, directory = sessionKeyDirectory()) => {
 };
 var saveSessionKey = (sessionId, value, directory = sessionKeyDirectory()) => {
   const path = fileFor2(sessionId, directory);
-  if (!path) return;
+  if (!path) return false;
   try {
     mkdirSync(directory, { recursive: true, mode: 448 });
-    writeFileSync(
-      path,
-      JSON.stringify({
-        sessionKey: Buffer.from(value.sessionKey).toString("base64"),
-        wrappedKey: value.wrappedKey,
-        providerWrappedKey: value.providerWrappedKey,
-        providerKeyId: value.providerKeyId,
-        compressRecords: value.compressRecords,
-        keyUploaded: value.keyUploaded
-      }),
-      { mode: 384 }
-    );
+    writeJsonAtomicDurable(path, {
+      sessionKey: Buffer.from(value.sessionKey).toString("base64"),
+      wrappedKey: value.wrappedKey,
+      providerWrappedKey: value.providerWrappedKey,
+      providerKeyId: value.providerKeyId,
+      compressRecords: value.compressRecords,
+      keyUploaded: value.keyUploaded
+    }, 384);
+    return true;
   } catch {
+    return false;
   }
 };
-var sweepStaleSessionKeys = (now = Date.now(), dir = sessionKeyDirectory()) => {
+var sweepStaleSessionDisplays = (now = Date.now(), dir = sessionKeyDirectory()) => {
   if (!existsSync(dir)) return 0;
   let removed = 0;
   try {
     for (const name of readdirSync(dir)) {
-      if (!name.endsWith(".json") && !name.endsWith(".display")) continue;
+      if (!name.endsWith(".display")) continue;
       const path = join2(dir, name);
       try {
-        if (now - statSync(path).mtimeMs <= SESSION_KEY_TTL_MS) continue;
+        if (now - statSync(path).mtimeMs <= SESSION_DISPLAY_TTL_MS) continue;
         rmSync(path, { force: true });
         removed += 1;
       } catch {
@@ -288,8 +288,8 @@ var startDraftPublisher = (options) => {
       if (!key?.keyUploaded) return;
       const draft = options.snapshot(key.sessionKey);
       if (!draft) return;
-      const identity = JSON.stringify([sessionId, draft.startedAt, draft.revision]);
-      if (identity === sent) return;
+      const identity2 = JSON.stringify([sessionId, draft.startedAt, draft.revision]);
+      if (identity2 === sent) return;
       const response = await fetch(`${options.baseUrl}/api/agent/transcript`, {
         method: "POST",
         headers: { Authorization: `Bearer ${options.apiKey}`, "Content-Type": "application/json" },
@@ -301,7 +301,7 @@ var startDraftPublisher = (options) => {
         signal: AbortSignal.any([controller.signal, AbortSignal.timeout(5e3)])
       });
       if (!response.ok) throw new Error(`HTTP ${response.status}`);
-      sent = identity;
+      sent = identity2;
       retryAt = 0;
       retryMs = 1e3;
       reportedFailure = false;
@@ -364,6 +364,11 @@ var startDisplayPublisher = (options) => {
   }).stop;
 };
 
+// src/transcript-reader.ts
+import { createHash as createHash3 } from "crypto";
+import { join as join3 } from "path";
+import { closeSync as closeSync3, fstatSync as fstatSync3, openSync as openSync3, readFileSync as readFileSync5, readSync as readSync2, statSync as statSync2 } from "fs";
+
 // src/transcript-source.ts
 var normalizeTranscriptLines = (lines, source) => {
   if (source === "claude") return [...lines];
@@ -416,13 +421,456 @@ var transcriptLinesSince = (lines, oldestLineMs, dropCompactionSummaries) => lin
   return !stampedBefore(record, oldestLineMs) && !(dropCompactionSummaries && isCompactionSummary(record));
 });
 
+// src/transcript-snapshot-file.ts
+import { closeSync as closeSync2, fstatSync as fstatSync2, openSync as openSync2, readFileSync as readFileSync3 } from "fs";
+
+// src/transcript-snapshot-source.ts
+import { createHash } from "crypto";
+var identity = external_exports.string().min(1).max(256);
+var timestamp = external_exports.string().refine((value) => Number.isFinite(Date.parse(value)));
+var geminiTool = external_exports.object({ id: identity, name: external_exports.string(), args: external_exports.record(external_exports.string(), external_exports.unknown()), result: external_exports.unknown().optional(), status: external_exports.string() });
+var geminiMessage = external_exports.object({
+  id: identity,
+  type: external_exports.enum(["user", "gemini", "info", "warning", "error"]),
+  timestamp,
+  content: external_exports.unknown(),
+  displayContent: external_exports.unknown().optional(),
+  toolCalls: external_exports.array(geminiTool).optional()
+});
+var toolPatch = external_exports.object({ id: identity, result: external_exports.unknown().optional() });
+var messagePatch = external_exports.object({ id: identity, content: external_exports.unknown().optional(), toolCalls: external_exports.array(toolPatch).optional() });
+var patchSchema = messagePatch.partial().extend({ updates: external_exports.array(messagePatch).optional(), removeIds: external_exports.array(identity).optional(), orderIds: external_exports.array(identity).optional() });
+var metadataSchema = external_exports.object({ sessionId: identity, kind: external_exports.enum(["main", "subagent"]).optional() });
+var textParts = (value) => {
+  if (typeof value === "string") return [{ type: "text", text: value }];
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((part) => {
+    if (typeof part === "string") return [{ type: "text", text: part }];
+    return isRecord(part) && part.thought !== true && typeof part.text === "string" ? [{ type: "text", text: part.text }] : [];
+  });
+};
+var geminiResult = (value) => {
+  if (typeof value === "string") return value;
+  if (!Array.isArray(value)) return null;
+  const parts = value.flatMap((part) => {
+    if (!isRecord(part) || part.thought === true) return [];
+    if (typeof part.text === "string") return [part.text];
+    if (isRecord(part.functionResponse) && isRecord(part.functionResponse.response)) return [JSON.stringify(part.functionResponse.response)];
+    return [];
+  });
+  return parts.join("\n");
+};
+var geminiConversationMessage = (message) => {
+  if (message.type !== "user" && message.type !== "gemini") return [];
+  const content = textParts(message.displayContent ?? message.content);
+  for (const tool of message.toolCalls ?? []) {
+    content.push({ type: "tool_use", id: tool.id, name: tool.name, input: tool.args });
+    if (tool.result !== void 0 && tool.result !== null) content.push({ type: "tool_result", tool_use_id: tool.id, content: geminiResult(tool.result), is_error: tool.status === "error" });
+  }
+  return [{ id: message.id, role: message.type === "user" ? "user" : "assistant", timestamp: message.timestamp, content }];
+};
+var applyMessagePatch = (messages, patch) => {
+  const previous = messages.get(patch.id);
+  if (!previous) return;
+  const updates = new Map(patch.toolCalls?.map((tool) => [tool.id, tool]));
+  const toolCalls = previous.toolCalls?.map((tool) => {
+    const update = updates.get(tool.id);
+    return update && Object.hasOwn(update, "result") ? { ...tool, result: update.result } : tool;
+  });
+  messages.set(patch.id, { ...previous, ...Object.hasOwn(patch, "content") ? { content: patch.content } : {}, toolCalls });
+};
+var applyGeminiPatch = (messages, value) => {
+  const patch = patchSchema.parse(value);
+  if (patch.id) applyMessagePatch(messages, { ...patch, id: patch.id });
+  for (const update of patch.updates ?? []) applyMessagePatch(messages, update);
+  for (const id of patch.removeIds ?? []) messages.delete(id);
+  for (const id of patch.orderIds ?? []) {
+    const message = messages.get(id);
+    if (message) {
+      messages.delete(id);
+      messages.set(id, message);
+    }
+  }
+};
+var replaceMessages = (messages, value) => {
+  const replacement = external_exports.array(geminiMessage).parse(value);
+  messages.clear();
+  for (const message of replacement) messages.set(message.id, message);
+};
+var rewindMessages = (messages, id) => {
+  if (!messages.has(id)) {
+    messages.clear();
+    return;
+  }
+  let remove = false;
+  for (const key of messages.keys()) {
+    if (key === id) remove = true;
+    if (remove) messages.delete(key);
+  }
+};
+var parseGeminiSnapshot = (text, sessionId) => {
+  let records;
+  try {
+    records = [JSON.parse(text)];
+  } catch {
+    records = text.split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
+  }
+  const messages = /* @__PURE__ */ new Map();
+  let identified = false;
+  for (const record of records) {
+    if (!isRecord(record)) throw new Error("Invalid Gemini history record");
+    if ("sessionId" in record) {
+      const metadata = metadataSchema.parse(record);
+      if (metadata.sessionId !== sessionId || metadata.kind === "subagent") throw new Error("Gemini history identity mismatch");
+      identified = true;
+      if ("messages" in record) replaceMessages(messages, record.messages);
+    } else if ("$rewindTo" in record) rewindMessages(messages, identity.parse(record.$rewindTo));
+    else if ("$patch" in record) applyGeminiPatch(messages, record.$patch);
+    else if ("$set" in record) {
+      if (!isRecord(record.$set)) throw new Error("Invalid Gemini checkpoint");
+      if ("sessionId" in record.$set && record.$set.sessionId !== sessionId) throw new Error("Gemini checkpoint identity mismatch");
+      if (record.$set.kind === "subagent") throw new Error("Gemini subagent history is not a main session");
+      if ("messages" in record.$set) replaceMessages(messages, record.$set.messages);
+    } else {
+      const message = geminiMessage.parse(record);
+      messages.set(message.id, message);
+    }
+  }
+  if (!identified) throw new Error("Gemini history metadata unavailable");
+  return [...messages.values()].flatMap(geminiConversationMessage);
+};
+var cursorBlock = external_exports.discriminatedUnion("type", [
+  external_exports.object({ type: external_exports.literal("text"), text: external_exports.string() }),
+  external_exports.object({ type: external_exports.literal("tool_use"), name: external_exports.string(), input: external_exports.record(external_exports.string(), external_exports.unknown()) })
+]);
+var cursorMessage = external_exports.object({ role: external_exports.enum(["user", "assistant"]), message: external_exports.object({ content: external_exports.array(cursorBlock) }) });
+var parseCursorSnapshot = (text) => {
+  const messages = [];
+  const occurrences = /* @__PURE__ */ new Map();
+  for (const line of text.split("\n").filter((line2) => line2.trim())) {
+    const record = JSON.parse(line);
+    if (isRecord(record) && (record.type === "metadata" || record.type === "turn_ended")) continue;
+    const message = cursorMessage.parse(record);
+    const fingerprint = createHash("sha256").update(canonicalJsonText(message)).digest("hex");
+    const occurrence = occurrences.get(fingerprint) ?? 0;
+    occurrences.set(fingerprint, occurrence + 1);
+    messages.push({ id: `cursor:${fingerprint}:${occurrence}`, role: message.role, content: message.message.content });
+  }
+  return messages;
+};
+var historyBlock = external_exports.discriminatedUnion("type", [
+  external_exports.object({ type: external_exports.literal("text"), text: external_exports.string() }),
+  external_exports.object({ type: external_exports.literal("tool_use"), id: identity, name: external_exports.string(), input: external_exports.record(external_exports.string(), external_exports.unknown()) }),
+  external_exports.object({ type: external_exports.literal("tool_result"), tool_use_id: identity, content: external_exports.unknown(), is_error: external_exports.boolean().optional() })
+]);
+var hermesSnapshot = external_exports.object({
+  version: external_exports.literal(1),
+  sessionId: identity,
+  completed: external_exports.boolean().default(false),
+  updatedAtMs: external_exports.number().int().positive(),
+  error: external_exports.string().optional(),
+  messages: external_exports.array(external_exports.object({ id: identity, role: external_exports.enum(["user", "assistant"]), timestamp, content: external_exports.array(historyBlock) })).max(5e3)
+});
+var TranscriptSourceUnavailable = class extends Error {
+};
+var parseHermesSnapshot = (text, sessionId, nowMs) => {
+  const snapshot = hermesSnapshot.parse(JSON.parse(text));
+  if (snapshot.sessionId !== sessionId) throw new Error("Hermes history identity mismatch");
+  if (snapshot.error || !snapshot.completed && nowMs - snapshot.updatedAtMs > 18e4 || snapshot.updatedAtMs > nowMs + 5e3) throw new TranscriptSourceUnavailable("Hermes history exporter is unavailable");
+  return snapshot.messages;
+};
+
+// src/transcript-snapshot-file.ts
+var MAXIMUM_SNAPSHOT_MESSAGES = 5e3;
+var readTranscriptSnapshot = (path, source, sessionId) => {
+  const descriptor = openSync2(path, "r");
+  try {
+    const before = fstatSync2(descriptor);
+    if (!before.isFile() || before.size === 0 || before.size > SESSION_HISTORY_BACKFILL_LIMIT_BYTES) throw new Error("History snapshot is empty or exceeds its size limit");
+    const text = readFileSync3(descriptor, "utf8");
+    const after = fstatSync2(descriptor);
+    if (before.size !== after.size || before.mtimeMs !== after.mtimeMs) throw new Error("History snapshot changed while reading");
+    let messages;
+    switch (source) {
+      case "gemini":
+        messages = parseGeminiSnapshot(text, sessionId);
+        break;
+      case "cursor":
+        messages = parseCursorSnapshot(text);
+        break;
+      case "hermes":
+        messages = parseHermesSnapshot(text, sessionId, Date.now());
+        break;
+    }
+    if (messages.length > MAXIMUM_SNAPSHOT_MESSAGES) throw new Error("History snapshot exceeds its message limit");
+    return messages;
+  } finally {
+    closeSync2(descriptor);
+  }
+};
+
+// src/transcript-snapshot-journal.ts
+import { lstatSync as lstatSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync4 } from "fs";
+import { dirname } from "path";
+
+// src/transcript-projection.ts
+import { createHash as createHash2 } from "crypto";
+var projectTranscriptSnapshot = (previous, messages) => {
+  const revision = (previous?.revision ?? 0) + 1;
+  const entries = /* @__PURE__ */ Object.create(null);
+  const lines = [];
+  for (const [order, message] of messages.entries()) {
+    if (!message.id || message.id.length > 256 || Object.hasOwn(entries, message.id)) throw new Error("Invalid or duplicate history message identity");
+    const record = { timestamp: message.timestamp, observedAtMs: message.observedAtMs, historyMessage: { role: message.role, content: message.content } };
+    const digest = createHash2("sha256").update(JSON.stringify(record)).digest("hex");
+    entries[message.id] = { digest, order };
+    const earlier = previous?.entries[message.id];
+    if (earlier?.digest === digest && earlier.order === order) continue;
+    lines.push(JSON.stringify({ ...record, historySource: { id: message.id, order, removed: false }, historyRevision: revision }));
+  }
+  for (const [id, entry] of Object.entries(previous?.entries ?? {})) {
+    if (Object.hasOwn(entries, id)) continue;
+    lines.push(JSON.stringify({ historySource: { id, order: entry.order, removed: true }, historyRevision: revision }));
+  }
+  return { lines, next: { revision: lines.length ? revision : previous?.revision ?? 0, entries } };
+};
+
+// src/transcript-snapshot-journal.ts
+var MAXIMUM_JOURNAL_BYTES = 64 * 1024 * 1024;
+var projectionSchema = external_exports.object({
+  revision: external_exports.number().int().nonnegative(),
+  entries: external_exports.record(external_exports.string(), external_exports.object({ digest: external_exports.string().regex(/^[a-f0-9]{64}$/), order: external_exports.number().int().nonnegative() }))
+});
+var journalSchema = external_exports.object({
+  version: external_exports.literal(1),
+  binding: external_exports.string(),
+  epochStartedAtMs: external_exports.number(),
+  initialized: external_exports.boolean(),
+  observedAtMs: external_exports.record(external_exports.string(), external_exports.number().nonnegative()).default({}),
+  excludedIds: external_exports.array(external_exports.string()),
+  projection: projectionSchema.nullable(),
+  pending: external_exports.object({ lines: external_exports.array(external_exports.string()), next: projectionSchema }).nullable()
+});
+var TranscriptSnapshotJournal = class {
+  constructor(path, binding, epochStartedAtMs) {
+    this.path = path;
+    const info = lstatSync2(path, { throwIfNoEntry: false });
+    if (!info) {
+      this.current = { version: 1, binding, epochStartedAtMs, initialized: false, observedAtMs: {}, excludedIds: [], projection: null, pending: null };
+      return;
+    }
+    if (!info.isFile() || info.nlink !== 1 || info.size > MAXIMUM_JOURNAL_BYTES || process.getuid && (info.uid !== process.getuid() || (info.mode & 511) !== 384)) throw new Error("Unsafe history checkpoint");
+    const saved = journalSchema.parse(JSON.parse(readFileSync4(path, "utf8")));
+    if (saved.binding !== binding) throw new Error("History checkpoint belongs to another source");
+    this.current = saved.epochStartedAtMs === epochStartedAtMs ? saved : { ...saved, epochStartedAtMs, initialized: false, observedAtMs: {}, pending: null, excludedIds: [], projection: { revision: Math.max(saved.projection?.revision ?? 0, saved.pending?.next.revision ?? 0), entries: {} } };
+  }
+  current;
+  prepare(messages, oldestMessageMs, nowMs = Date.now()) {
+    const pending = this.pendingLinesSince(oldestMessageMs);
+    if (pending) return pending;
+    const identities = new Set(messages.map((message) => message.id));
+    const excluded = new Set(this.current.excludedIds.filter((id) => identities.has(id)));
+    if (!this.current.initialized) {
+      for (const message of messages) if (!message.timestamp) excluded.add(message.id);
+    }
+    const observedAtMs = Object.fromEntries(Object.entries(this.current.observedAtMs).filter(([id]) => identities.has(id)));
+    for (const message of messages) {
+      if (!message.timestamp && !excluded.has(message.id) && !Object.hasOwn(observedAtMs, message.id)) observedAtMs[message.id] = nowMs;
+    }
+    const allowed = messages.filter((message) => !excluded.has(message.id) && (message.timestamp ? Date.parse(message.timestamp) : observedAtMs[message.id] ?? 0) >= oldestMessageMs).map((message) => message.timestamp ? message : { ...message, observedAtMs: observedAtMs[message.id] });
+    const projected = projectTranscriptSnapshot(this.current.projection, allowed);
+    if (projected.lines.length === 0) {
+      const metadataChanged = excluded.size !== this.current.excludedIds.length || Object.keys(observedAtMs).length !== Object.keys(this.current.observedAtMs).length;
+      if (!this.current.initialized || metadataChanged) this.store({ ...this.current, initialized: true, observedAtMs, excludedIds: [...excluded], projection: projected.next, pending: null });
+      return [];
+    }
+    this.store({ ...this.current, initialized: true, observedAtMs, excludedIds: [...excluded], pending: { lines: [...projected.lines], next: projected.next } });
+    return projected.lines;
+  }
+  pendingLinesSince(oldestMessageMs) {
+    const pending = this.current.pending;
+    if (!pending) return null;
+    const lines = pending.lines.filter((line) => {
+      const record = JSON.parse(line);
+      if (!record || typeof record !== "object") throw new Error("Invalid pending history record");
+      if ("timestamp" in record) return typeof record.timestamp === "string" && Date.parse(record.timestamp) >= oldestMessageMs;
+      return !("observedAtMs" in record) || typeof record.observedAtMs === "number" && record.observedAtMs >= oldestMessageMs;
+    });
+    if (lines.length !== pending.lines.length) this.store({ ...this.current, pending: { ...pending, lines } });
+    return lines;
+  }
+  settle() {
+    if (!this.current.pending) return;
+    this.store({ ...this.current, projection: this.current.pending.next, pending: null });
+  }
+  store(next) {
+    if (Buffer.byteLength(JSON.stringify(next)) > MAXIMUM_JOURNAL_BYTES) throw new Error("History checkpoint exceeds its size limit");
+    mkdirSync2(dirname(this.path), { recursive: true, mode: 448 });
+    writeJsonAtomicDurable(this.path, next, 384);
+    this.current = journalSchema.parse(next);
+  }
+};
+
+// src/transcript-reader.ts
+var readPositionsKeptInMemory = { load: () => /* @__PURE__ */ new Map(), save: () => {
+} };
+var startTranscriptCaptureEpoch = (startedAtMs, positions = readPositionsKeptInMemory, backfill = null) => ({ startedAtMs, cutoffs: new Map(positions.load()), positions, backfill });
+var recordedBirthtime = (info) => process.platform === "darwin" && info.birthtimeMs > 0 ? info.birthtimeMs : null;
+var sightingOf = (info, seenAtMs) => info ? { identity: `${info.dev}:${info.ino}`, sizeBytes: info.size, birthtimeMs: recordedBirthtime(info), seenAtMs } : { identity: null, sizeBytes: 0, birthtimeMs: null, seenAtMs };
+var storeCutoff = (epoch, path, cutoff) => {
+  epoch.cutoffs.set(path, cutoff);
+  epoch.positions.save(epoch.cutoffs);
+};
+var recordSighting = (epoch, path, sighting) => {
+  const previous = epoch.cutoffs.get(path);
+  const cutoff = nextTranscriptCutoff(previous, sighting, epoch.startedAtMs, epoch.backfill);
+  if (cutoff !== previous) storeCutoff(epoch, path, cutoff);
+  return cutoff;
+};
+var recordSettledPosition = (epoch, path, readFrom, settledThroughOffset) => {
+  const current = epoch.cutoffs.get(path);
+  const advanced = advancedTranscriptCutoff(current, readFrom, settledThroughOffset);
+  if (advanced !== void 0 && advanced !== current) storeCutoff(epoch, path, advanced);
+};
+var forgetUnregisteredTranscripts = (epoch, registeredPaths) => {
+  const unregistered = [...epoch.cutoffs.keys()].filter((path) => !registeredPaths.has(path));
+  if (unregistered.length === 0) return;
+  for (const path of unregistered) epoch.cutoffs.delete(path);
+  epoch.positions.save(epoch.cutoffs);
+};
+var statOrNull = (path) => {
+  try {
+    return statSync2(path);
+  } catch {
+    return null;
+  }
+};
+var sightTranscript = (epoch, path, seenAtMs) => recordSighting(epoch, path, sightingOf(statOrNull(path), seenAtMs));
+var LINE_FEED = 10;
+var MAXIMUM_TRANSCRIPT_READ_BYTES = 4 * 1024 * 1024;
+var nothingUnread = (cutoff) => ({ lines: [], cutoff, completeThroughOffset: cutoff.offset, reachedEnd: true });
+var readThroughALineEnd = (descriptor, offset, unread) => {
+  let window = Math.min(unread, MAXIMUM_TRANSCRIPT_READ_BYTES);
+  for (; ; ) {
+    const buffer = Buffer.alloc(window);
+    const received = buffer.subarray(0, readSync2(descriptor, buffer, 0, window, offset));
+    if (window >= unread || received.length < window || received.includes(LINE_FEED)) return received;
+    window = Math.min(unread, window * 2);
+  }
+};
+var readLinesSinceCutoff = (epoch, path, seenAtMs) => {
+  let descriptor;
+  try {
+    descriptor = openSync3(path, "r");
+  } catch {
+    return nothingUnread(sightTranscript(epoch, path, seenAtMs));
+  }
+  try {
+    const info = fstatSync3(descriptor);
+    const cutoff = recordSighting(epoch, path, sightingOf(info, seenAtMs));
+    const unread = info.size - cutoff.offset;
+    if (unread <= 0) return nothingUnread(cutoff);
+    const received = readThroughALineEnd(descriptor, cutoff.offset, unread);
+    const completeBytes = received.lastIndexOf(LINE_FEED) + 1;
+    const reachedEnd = received.length >= unread;
+    return {
+      lines: (reachedEnd ? received : received.subarray(0, completeBytes)).toString("utf8").split("\n"),
+      cutoff,
+      completeThroughOffset: cutoff.offset + completeBytes,
+      reachedEnd
+    };
+  } finally {
+    closeSync3(descriptor);
+  }
+};
+var linesSeenDuringEpoch = (epoch, path, source, seenAtMs, retentionDays) => {
+  const read2 = readLinesSinceCutoff(epoch, path, seenAtMs);
+  const oldestLineMs = oldestTranscriptLineMs(epoch.startedAtMs, epoch.backfill, retentionDays, seenAtMs);
+  return {
+    ...read2,
+    lines: transcriptLinesSince(normalizeTranscriptLines(read2.lines, source), oldestLineMs, dropsCompactionSummaries(read2.cutoff, epoch.backfill))
+  };
+};
+var sourceVersion = (path) => {
+  const info = statOrNull(path);
+  if (!info?.isFile()) throw new TranscriptSourceUnavailable("Conversation source unavailable");
+  return `${info.dev}:${info.ino}:${info.size}:${info.mtimeMs}`;
+};
+var appendOnlyReader = (path, source, epoch) => ({
+  requiresRevisions: false,
+  read(retentionDays, nowMs) {
+    const version = sourceVersion(path);
+    const read2 = epoch ? linesSeenDuringEpoch(epoch, path, source, nowMs, retentionDays) : null;
+    const lines = read2?.lines ?? normalizeTranscriptLines(readFileSync5(path, "utf8").split("\n"), source);
+    return {
+      lines,
+      acknowledge() {
+        if (epoch && read2) recordSettledPosition(epoch, path, read2.cutoff, read2.completeThroughOffset);
+        if ((read2?.reachedEnd ?? true) && sourceVersion(path) === version) return "caught_up";
+        return !read2 || read2.completeThroughOffset > read2.cutoff.offset ? "more" : "unchanged";
+      }
+    };
+  }
+});
+var snapshotReader = (options, source) => {
+  const { path, epoch } = options;
+  const binding = createHash3("sha256").update(JSON.stringify([options.baseUrl, options.apiKey, options.machineId, options.sessionId, source, path])).digest("hex");
+  const journalPath = join3(options.keyDirectory, "snapshots", binding + ".json");
+  const epochStart = epoch?.startedAtMs ?? 0;
+  const backfill = epoch ? epoch.backfill : SESSION_HISTORY_BACKFILL;
+  let journal;
+  return {
+    requiresRevisions: true,
+    read(retentionDays, nowMs) {
+      const checkpoint = journal ??= new TranscriptSnapshotJournal(journalPath, binding, backfill ? 0 : epochStart);
+      const oldestMessage = oldestTranscriptLineMs(epochStart, backfill, retentionDays, nowMs);
+      const pending = checkpoint.pendingLinesSince(oldestMessage);
+      const version = pending === null ? sourceVersion(path) : null;
+      const lines = pending ?? checkpoint.prepare(readTranscriptSnapshot(path, source, options.sessionId), oldestMessage, nowMs);
+      return {
+        lines,
+        acknowledge() {
+          checkpoint.settle();
+          return version === null || sourceVersion(path) !== version ? "more" : "caught_up";
+        }
+      };
+    }
+  };
+};
+var createTranscriptReader = (options) => options.source === "claude" || options.source === "codex" ? appendOnlyReader(options.path, options.source, options.epoch) : snapshotReader(options, options.source);
+
+// src/transcript-health.ts
+var HEALTH_REFRESH_MS = 6e4;
+var transcriptHealthReporter = (target) => {
+  let reported;
+  let reportedAt = 0;
+  let warned = false;
+  return async (state) => {
+    if (!target.machineId || state === reported && Date.now() - reportedAt < HEALTH_REFRESH_MS) return;
+    try {
+      const response = await fetch(`${target.baseUrl}/api/agent/transcript/status`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${target.apiKey}`, "Content-Type": "application/json" },
+        body: JSON.stringify({ sessionId: target.sessionId, machineId: target.machineId, captureState: state }),
+        signal: AbortSignal.timeout(2e3)
+      });
+      if (!response.ok) throw new Error("History status rejected");
+      reported = state;
+      reportedAt = Date.now();
+      warned = false;
+    } catch {
+      if (!warned) process.stderr.write("[pushary] History sync status could not reach the server.\n");
+      warned = true;
+    }
+  };
+};
+
 // src/transcript-sync.ts
-import { join as join3, resolve } from "path";
-import { closeSync as closeSync2, existsSync as existsSync2, fstatSync as fstatSync2, openSync as openSync2, readFileSync as readFileSync3, readSync as readSync2, statSync as statSync2 } from "fs";
+import { join as join4, resolve } from "path";
 var claudeTranscriptPath = (cwd, sessionId) => {
   const projectId = resolve(cwd).replace(/[^a-zA-Z0-9-]/g, "-");
   const configDir = claudeConfigDir();
-  return join3(configDir, "projects", projectId, `${sessionId}.jsonl`);
+  return join4(configDir, "projects", projectId, `${sessionId}.jsonl`);
 };
 var createSyncState = () => ({
   sessionKey: null,
@@ -434,6 +882,7 @@ var createSyncState = () => ({
   keyUploaded: false,
   keyRejected: false,
   keyUnavailable: false,
+  rejectedRecords: 0,
   unsettled: 0,
   retentionDays: null
 });
@@ -502,6 +951,7 @@ var syncTick = async (lines, state, uploader, sessionId, machineId) => {
     keyUploaded,
     keyRejected,
     keyUnavailable,
+    rejectedRecords: state.rejectedRecords + rejected,
     unsettled: built.records.filter((record) => !seen.has(record.localId)).length,
     retentionDays: keyed.retentionDays
   };
@@ -525,106 +975,34 @@ var chunkRecords = (records) => {
   if (current.length > 0) chunks.push(current);
   return chunks;
 };
-var readLines = (path) => {
-  try {
-    return existsSync2(path) ? readFileSync3(path, "utf-8").split("\n") : [];
-  } catch {
-    return [];
-  }
-};
 var IDLE_CEILING_MS = 6e4;
-var readPositionsKeptInMemory = { load: () => /* @__PURE__ */ new Map(), save: () => {
-} };
-var startTranscriptCaptureEpoch = (startedAtMs, positions = readPositionsKeptInMemory, backfill = null) => ({ startedAtMs, cutoffs: new Map(positions.load()), positions, backfill });
-var recordedBirthtime = (info) => process.platform === "darwin" && info.birthtimeMs > 0 ? info.birthtimeMs : null;
-var sightingOf = (info, seenAtMs) => info ? { identity: `${info.dev}:${info.ino}`, sizeBytes: info.size, birthtimeMs: recordedBirthtime(info), seenAtMs } : { identity: null, sizeBytes: 0, birthtimeMs: null, seenAtMs };
-var storeCutoff = (epoch, path, cutoff) => {
-  epoch.cutoffs.set(path, cutoff);
-  epoch.positions.save(epoch.cutoffs);
-};
-var recordSighting = (epoch, path, sighting) => {
-  const previous = epoch.cutoffs.get(path);
-  const cutoff = nextTranscriptCutoff(previous, sighting, epoch.startedAtMs, epoch.backfill);
-  if (cutoff !== previous) storeCutoff(epoch, path, cutoff);
-  return cutoff;
-};
-var recordSettledPosition = (epoch, path, readFrom, settledThroughOffset) => {
-  const current = epoch.cutoffs.get(path);
-  const advanced = advancedTranscriptCutoff(current, readFrom, settledThroughOffset);
-  if (advanced !== void 0 && advanced !== current) storeCutoff(epoch, path, advanced);
-};
-var forgetUnregisteredTranscripts = (epoch, registeredPaths) => {
-  const unregistered = [...epoch.cutoffs.keys()].filter((path) => !registeredPaths.has(path));
-  if (unregistered.length === 0) return;
-  for (const path of unregistered) epoch.cutoffs.delete(path);
-  epoch.positions.save(epoch.cutoffs);
-};
-var statOrNull = (path) => {
-  try {
-    return statSync2(path);
-  } catch {
-    return null;
-  }
-};
-var sightTranscript = (epoch, path, seenAtMs) => recordSighting(epoch, path, sightingOf(statOrNull(path), seenAtMs));
-var LINE_FEED = 10;
-var MAXIMUM_TRANSCRIPT_READ_BYTES = 4 * 1024 * 1024;
+var RECIPIENT_REFRESH_MS = 6e4;
 var CATCH_UP_DELAY_MS = 50;
 var STALLED_BACKOFF_FACTOR = 4;
-var nothingUnread = (cutoff) => ({ lines: [], cutoff, completeThroughOffset: cutoff.offset, reachedEnd: true });
-var readThroughALineEnd = (descriptor, offset, unread) => {
-  let window = Math.min(unread, MAXIMUM_TRANSCRIPT_READ_BYTES);
-  for (; ; ) {
-    const buffer = Buffer.alloc(window);
-    const received = buffer.subarray(0, readSync2(descriptor, buffer, 0, window, offset));
-    if (window >= unread || received.length < window || received.includes(LINE_FEED)) return received;
-    window = Math.min(unread, window * 2);
-  }
-};
-var readLinesSinceCutoff = (epoch, path, seenAtMs) => {
-  let descriptor;
-  try {
-    descriptor = openSync2(path, "r");
-  } catch {
-    return nothingUnread(sightTranscript(epoch, path, seenAtMs));
-  }
-  try {
-    const info = fstatSync2(descriptor);
-    const cutoff = recordSighting(epoch, path, sightingOf(info, seenAtMs));
-    const unread = info.size - cutoff.offset;
-    if (unread <= 0) return nothingUnread(cutoff);
-    const received = readThroughALineEnd(descriptor, cutoff.offset, unread);
-    const completeBytes = received.lastIndexOf(LINE_FEED) + 1;
-    const reachedEnd = received.length >= unread;
-    return {
-      lines: (reachedEnd ? received : received.subarray(0, completeBytes)).toString("utf8").split("\n"),
-      cutoff,
-      completeThroughOffset: cutoff.offset + completeBytes,
-      reachedEnd
-    };
-  } finally {
-    closeSync2(descriptor);
-  }
-};
-var linesSeenDuringEpoch = (epoch, path, source, seenAtMs, retentionDays) => {
-  const read2 = readLinesSinceCutoff(epoch, path, seenAtMs);
-  const oldestLineMs = oldestTranscriptLineMs(epoch.startedAtMs, epoch.backfill, retentionDays, seenAtMs);
-  return {
-    ...read2,
-    lines: transcriptLinesSince(normalizeTranscriptLines(read2.lines, source), oldestLineMs, dropsCompactionSummaries(read2.cutoff, epoch.backfill))
-  };
-};
 var nothingLeftToUpload = (state) => state.sessionKey !== null && !state.keyRejected && state.unsettled === 0;
 var uploadStalled = (before, after) => after.sessionKey !== null && !after.keyRejected && after.unsettled > 0 && after.seen.size === before.seen.size;
+var captureHealth = (state, stalled, catchingUp) => {
+  if (state.keyRejected || state.keyUnavailable || state.rejectedRecords > 0 || stalled) return "capture_failed";
+  return catchingUp ? "catching_up" : "capturing";
+};
 var nextInterval = (previousMs, idle, baseMs, maxMs) => idle ? Math.min(previousMs * 2, maxMs) : baseMs;
 var startTranscriptSync = (opts) => {
+  const reportHealth = transcriptHealthReporter({ ...opts, baseUrl: opts.baseUrl ?? getBaseUrl() });
+  let recipientFailure = "capture_failed";
   let warnedAboutRecipients = false;
+  let verifiedRecipients = null;
+  let recipientsVerifiedAt = 0;
   const fetchPinnedRecipients = async () => {
-    const offer = await fetchTranscriptRecipients(opts.apiKey, opts.baseUrl);
+    if (verifiedRecipients && Date.now() - recipientsVerifiedAt < RECIPIENT_REFRESH_MS) return verifiedRecipients;
+    verifiedRecipients = null;
+    const offer = await fetchTranscriptRecipients(opts.apiKey, opts.baseUrl, (reason) => {
+      recipientFailure = reason;
+    });
     if (!offer) return null;
     const verdict = verifyRecipients(offer, loadPin(opts.storage?.recipientPinFile));
     if (verdict.kind === "first-use" && !savePin(verdict.pin, opts.storage?.recipientPinFile)) return null;
     if (verdict.kind === "changed") {
+      recipientFailure = "phone_key_changed";
       if (!warnedAboutRecipients) {
         warnedAboutRecipients = true;
         process.stderr.write(`${changedRecipientsMessage(verdict, offer)}
@@ -632,6 +1010,8 @@ var startTranscriptSync = (opts) => {
       }
       return null;
     }
+    verifiedRecipients = offer;
+    recipientsVerifiedAt = Date.now();
     return offer;
   };
   const uploader = {
@@ -639,16 +1019,15 @@ var startTranscriptSync = (opts) => {
     uploadRecords: (params) => (opts.enabled ? opts.enabled() : transcriptsEnabled()) ? uploadTranscriptRecords(opts.apiKey, params, opts.baseUrl) : Promise.resolve({ ok: false, keyRegistered: false, keyConflict: false, keyUnavailable: false, settledIds: null, rejectedIds: [] })
   };
   const path = opts.path ?? claudeTranscriptPath(opts.cwd, opts.sessionId);
+  const reader = createTranscriptReader({ ...opts, source: opts.source ?? "claude", path, baseUrl: opts.baseUrl ?? getBaseUrl(), keyDirectory: opts.storage?.sessionKeyDirectory ?? sessionKeyDirectory() });
   const persisted = loadSessionKey(opts.sessionId, opts.storage?.sessionKeyDirectory);
   let state = persisted ? { ...createSyncState(), ...persisted } : createSyncState();
-  sweepStaleSessionKeys(Date.now(), opts.storage?.sessionKeyDirectory);
+  sweepStaleSessionDisplays(Date.now(), opts.storage?.sessionKeyDirectory);
   let persistedKey = persisted?.sessionKey ?? null;
   let persistedUploaded = persisted?.keyUploaded ?? false;
   const persistSessionKey = () => {
     if (!state.sessionKey || state.sessionKey === persistedKey && state.keyUploaded === persistedUploaded) return;
-    persistedKey = state.sessionKey;
-    persistedUploaded = state.keyUploaded;
-    saveSessionKey(opts.sessionId, {
+    const saved = saveSessionKey(opts.sessionId, {
       sessionKey: state.sessionKey,
       wrappedKey: state.wrappedKey,
       providerWrappedKey: state.providerWrappedKey,
@@ -656,6 +1035,9 @@ var startTranscriptSync = (opts) => {
       compressRecords: state.compressRecords,
       keyUploaded: state.keyUploaded
     }, opts.storage?.sessionKeyDirectory);
+    if (!saved) throw new Error("Could not persist transcript encryption key");
+    persistedKey = state.sessionKey;
+    persistedUploaded = state.keyUploaded;
   };
   let running = true;
   let inFlight = false;
@@ -668,27 +1050,42 @@ var startTranscriptSync = (opts) => {
     try {
       const ending = opts.ending?.() === true;
       if (state.keyRejected) {
+        await reportHealth("capture_failed");
         if (ending) opts.onDrained?.();
         return;
       }
-      state = await withSessionKey(state, uploader);
-      if (!state.sessionKey) return;
+      const recipients = await fetchPinnedRecipients();
+      if (!recipients) {
+        await reportHealth(recipientFailure);
+        return;
+      }
+      if (reader.requiresRevisions && recipients.phoneReadsTranscriptRevisions !== true) {
+        await reportHealth("phone_upgrade_required");
+        return;
+      }
+      state = await withSessionKey({ ...state, retentionDays: recipients.retentionDays }, uploader);
+      if (!state.sessionKey) {
+        await reportHealth(recipientFailure);
+        return;
+      }
       persistSessionKey();
       const previous = state;
-      const modified = existsSync2(path) ? statSync2(path).mtimeMs : null;
       const source = opts.source ?? "claude";
-      const retentionDays = state.retentionDays ?? SESSION_HISTORY_RETENTION_DAYS.standard;
-      const read2 = opts.epoch ? linesSeenDuringEpoch(opts.epoch, path, source, Date.now(), retentionDays) : null;
-      const lines = read2?.lines ?? normalizeTranscriptLines(readLines(path), source);
-      state = await syncTick(lines, state, uploader, opts.sessionId, opts.machineId);
+      const batch = reader.read(state.retentionDays ?? SESSION_HISTORY_RETENTION_DAYS.standard, Date.now());
+      state = await syncTick(batch.lines, state, uploader, opts.sessionId, opts.machineId);
       stalled = uploadStalled(previous, state);
       persistSessionKey();
       const settled = nothingLeftToUpload(state);
-      if (opts.epoch && read2 && settled) recordSettledPosition(opts.epoch, path, read2.cutoff, read2.completeThroughOffset);
-      catchingUp = settled && read2 !== null && !read2.reachedEnd && read2.completeThroughOffset > read2.cutoff.offset;
-      const readEverything = read2?.reachedEnd ?? true;
-      if (ending && opts.ending?.() && existsSync2(path) && statSync2(path).mtimeMs === modified && settled && readEverything) opts.onDrained?.();
-    } catch {
+      const progress = settled ? batch.acknowledge() : "unchanged";
+      catchingUp = progress === "more";
+      const health = captureHealth(state, stalled, catchingUp);
+      await reportHealth(source === "cursor" && health === "capturing" ? "capturing_limited" : health);
+      if (ending && opts.ending?.() && progress === "caught_up") {
+        await reportHealth(health === "capture_failed" ? health : source === "cursor" ? "synced_limited" : "synced");
+        opts.onDrained?.();
+      }
+    } catch (error) {
+      await reportHealth(error instanceof TranscriptSourceUnavailable ? "source_unavailable" : "capture_failed");
     } finally {
       inFlight = false;
     }
@@ -726,15 +1123,32 @@ var startTranscriptSync = (opts) => {
 
 // src/transcript-registration.ts
 import { homedir as homedir2 } from "os";
-var defaultRegistryDirectory = () => process.env.PUSHARY_TRANSCRIPT_REGISTRY_DIR || join4(pusharyDir(), "transcript-capture");
+var storedRegistrationSchema = external_exports.object({
+  sessionId: external_exports.string().min(1).max(128),
+  cwd: external_exports.string(),
+  path: external_exports.string(),
+  source: external_exports.enum(["claude", "codex", "gemini", "cursor", "hermes"]),
+  root: external_exports.string().optional(),
+  account: external_exports.string().regex(/^[a-f0-9]{64}$/),
+  consentOverride: external_exports.boolean().nullable().default(null),
+  expectedSiteId: external_exports.string().min(1).optional(),
+  expectedBaseUrl: external_exports.string().url().optional(),
+  verifiedSiteId: external_exports.string().min(1).optional(),
+  endedAt: external_exports.number().positive().optional(),
+  drained: external_exports.boolean().optional()
+});
+var defaultRegistryDirectory = () => process.env.PUSHARY_TRANSCRIPT_REGISTRY_DIR || join5(pusharyDir(), "transcript-capture");
 var cliRegistry = (apiKey = getApiKey()) => ({ apiKey, baseUrl: getBaseUrl(), directory: defaultRegistryDirectory() });
-var accountFor = (registry) => createHash("sha256").update(`${registry.baseUrl}\0${registry.apiKey}`).digest("hex");
+var accountFor = (registry) => createHash4("sha256").update(`${registry.baseUrl}\0${registry.apiKey}`).digest("hex");
 var TTL = 48 * 60 * 60 * 1e3;
-var read = (path) => JSON.parse(readFileSync4(path, "utf8"));
+var read = (path) => {
+  if (statSync3(path).size > 16384) throw new Error("History registration exceeds its size limit");
+  return storedRegistrationSchema.parse(JSON.parse(readFileSync6(path, "utf8")));
+};
 var consent = (record) => record.consentOverride ?? readTranscriptPreference() ?? true;
 var withoutTrailingSlash = (url) => url.replace(/\/+$/, "");
 var sameServer = (url, registry) => withoutTrailingSlash(url) === withoutTrailingSlash(registry.baseUrl);
-var fileFor3 = (registry, sessionId) => join4(registry.directory, `${createHash("sha256").update(accountFor(registry) + sessionId).digest("hex")}.json`);
+var fileFor3 = (registry, sessionId) => join5(registry.directory, `${createHash4("sha256").update(accountFor(registry) + sessionId).digest("hex")}.json`);
 var permitted = (registry, raw) => raw.account === accountFor(registry) && consent(raw) && !raw.drained && (raw.source !== "claude" || !!raw.expectedSiteId || !macOwnsClaudeHooks(raw.cwd)) && (!raw.expectedSiteId || raw.expectedSiteId === raw.verifiedSiteId && !!raw.expectedBaseUrl && sameServer(raw.expectedBaseUrl, registry));
 var registeredTranscriptEnabled = (apiKey, sessionId, registry = cliRegistry(apiKey)) => {
   try {
@@ -744,39 +1158,56 @@ var registeredTranscriptEnabled = (apiKey, sessionId, registry = cliRegistry(api
   }
 };
 var macOwnsClaudeHooks = (cwd) => [
-  join4(claudeConfigDir(), "settings.json"),
-  join4(cwd, ".claude", "settings.json"),
-  join4(cwd, ".claude", "settings.local.json")
+  join5(claudeConfigDir(), "settings.json"),
+  join5(cwd, ".claude", "settings.json"),
+  join5(cwd, ".claude", "settings.local.json")
 ].some((path) => {
   try {
-    return hookOwnerOf(JSON.parse(readFileSync4(path, "utf8"))) === "app";
+    return hookOwnerOf(JSON.parse(readFileSync6(path, "utf8"))) === "app";
   } catch {
     return false;
   }
 });
-var TRANSCRIPT_ROOT_NAME = { claude: "projects", codex: "sessions" };
+var TRANSCRIPT_ROOT_NAME = { claude: "projects", codex: "sessions", gemini: "tmp", cursor: "projects", hermes: "hermes-history" };
 var transcriptRoots = (source) => {
   const home = homedir2();
-  if (source === "codex") return [join4(codexHome(), TRANSCRIPT_ROOT_NAME.codex)];
+  if (source === "codex") return [join5(codexHome(), TRANSCRIPT_ROOT_NAME.codex)];
+  if (source === "cursor") return [join5(home, ".cursor", TRANSCRIPT_ROOT_NAME.cursor)];
+  if (source === "hermes") return [join5(home, ".pushary", TRANSCRIPT_ROOT_NAME.hermes)];
+  if (source === "gemini") return [join5(process.env.GEMINI_CLI_HOME || home, ".gemini", "tmp"), join5(home, ".cache", ".gemini", "tmp")];
   const configured = process.env.CLAUDE_CONFIG_DIR;
-  return [join4(configured || join4(home, ".claude"), TRANSCRIPT_ROOT_NAME.claude), join4(home, ".claude", TRANSCRIPT_ROOT_NAME.claude)];
+  return [join5(configured || join5(home, ".claude"), TRANSCRIPT_ROOT_NAME.claude), join5(home, ".claude", TRANSCRIPT_ROOT_NAME.claude)];
 };
 var isAgentTranscriptRoot = (root, source) => isAbsolute(root) && resolve2(root) === root && basename(root) === TRANSCRIPT_ROOT_NAME[source];
 var acceptedTranscriptRoots = (source, registeredRoot) => typeof registeredRoot === "string" && isAgentTranscriptRoot(registeredRoot, source) ? [...transcriptRoots(source), registeredRoot] : transcriptRoots(source);
+var resolvedSourcePath = (path) => {
+  const absolute = resolve2(path);
+  try {
+    return realpathSync(absolute);
+  } catch {
+    const parent = dirname2(absolute);
+    return parent === absolute ? absolute : join5(resolvedSourcePath(parent), basename(absolute));
+  }
+};
 var transcriptRootContaining = (candidate, roots) => {
-  const target = resolve2(candidate);
-  return roots.map((root) => resolve2(root)).find((root) => target.startsWith(root + sep)) ?? null;
+  const target = resolvedSourcePath(candidate);
+  return roots.map((root) => resolve2(root)).find((root) => target.startsWith(resolvedSourcePath(root) + sep)) ?? null;
 };
 var captureRegistration = (source, value, registeredRoot) => {
   const input = value;
-  if (source !== "claude" && source !== "codex") return null;
-  if (input.agent_id || typeof input.session_id !== "string" || !/^[\w-]{1,128}$/.test(input.session_id)) return null;
+  if (source !== "claude" && source !== "codex" && source !== "gemini" && source !== "cursor" && source !== "hermes") return null;
+  const sessionId = input.session_id ?? input.conversation_id;
+  if (input.agent_id || typeof sessionId !== "string" || !/^[\w-]{1,128}$/.test(sessionId)) return null;
   if (typeof input.cwd !== "string" || !isAbsolute(input.cwd)) return null;
-  const path = input.transcript_path ?? input.agent_transcript_path ?? (source === "claude" ? claudeTranscriptPath(input.cwd, input.session_id) : null);
-  if (typeof path !== "string" || !isAbsolute(path) || !path.endsWith(".jsonl")) return null;
+  const path = input.transcript_path ?? input.agent_transcript_path ?? (source === "claude" ? claudeTranscriptPath(input.cwd, sessionId) : null);
+  if (typeof path !== "string" || !isAbsolute(path) || !(path.endsWith(".jsonl") || (source === "gemini" || source === "hermes") && path.endsWith(".json"))) return null;
   const root = transcriptRootContaining(path, acceptedTranscriptRoots(source, registeredRoot));
   if (root === null) return null;
-  return { sessionId: input.session_id, cwd: input.cwd, path, source, root };
+  const segments = relative(root, path).split(sep);
+  if (source === "hermes" && (segments.length !== 2 || !/^[a-f0-9]{64}$/.test(segments[0] ?? "") || basename(path) !== `${sessionId}.json`)) return null;
+  if (source === "gemini" && (segments.length !== 3 || segments[1] !== "chats" || !basename(path).startsWith("session-"))) return null;
+  if (source === "cursor" && (segments[1] !== "agent-transcripts" || basename(path) !== `${sessionId}.jsonl` || !(segments.length === 3 || segments.length === 4 && basename(dirname2(path)) === sessionId))) return null;
+  return { sessionId, cwd: input.cwd, path, source, root };
 };
 var registerTranscript = (source, input, startDaemon = () => {
   void ensureDaemonRunning({ waitTimeoutMs: 0 }).catch(() => {
@@ -793,10 +1224,15 @@ var registerTranscript = (source, input, startDaemon = () => {
       previous = read(path);
     } catch {
     }
+    if (previous?.account === account && (resolvedSourcePath(previous.path) !== resolvedSourcePath(registration.path) || previous.source !== registration.source)) {
+      process.stderr.write("[pushary] History registration refused a conflicting source for this session.\n");
+      return;
+    }
     if (source === "claude" && !options.siteId && !previous?.expectedSiteId && macOwnsClaudeHooks(registration.cwd)) return;
     const ending = options.ended || input.hook_event_name === "SessionEnd" && process.env.PUSHARY_WRAPPER_ACTIVE !== "1";
     const stored = {
       ...registration,
+      path: previous?.account === account ? previous.path : registration.path,
       account,
       consentOverride: options.consentOverride ?? transcriptEnvironmentPreference(),
       // A wrapper refresh must not erase the Mac's account binding.
@@ -838,7 +1274,7 @@ var startRegisteredTranscripts = (apiKey, machineId, options = {}) => {
     try {
       let unreadable = 0;
       const files = readdirSync2(registry.directory).filter((name) => name.endsWith(".json")).flatMap((name) => {
-        const path = join4(registry.directory, name);
+        const path = join5(registry.directory, name);
         try {
           const time = statSync3(path).mtimeMs;
           if (Date.now() - time > TTL) {
@@ -887,13 +1323,18 @@ var startRegisteredTranscripts = (apiKey, machineId, options = {}) => {
       for (const [id, registration] of wanted) {
         if (active.has(id)) continue;
         const current = () => read(registration.registrationPath);
+        const snapshotKeys = join5(registry.directory, "snapshot-keys", accountFor(registry));
+        const keyStorage = storage ?? (registration.source === "claude" || registration.source === "codex" ? void 0 : {
+          sessionKeyDirectory: snapshotKeys,
+          recipientPinFile: join5(snapshotKeys, "recipients.json")
+        });
         active.set(id, { path: registration.path, stop: startTranscriptSync({
           apiKey,
           machineId,
           ...registration,
           intervalMs,
           baseUrl: registry.baseUrl,
-          storage,
+          storage: keyStorage,
           epoch,
           enabled: () => {
             try {