pushary 1.9.73 → 1.9.76

package/dist/bin/pushary-daemon.js

@@ -1,26 +1,30 @@
 #!/usr/bin/env node
 import {
   inspectConfiguredManagedProviders
-} from "../chunk-JNTYPMVU.js";
+} from "../chunk-VZSSL6US.js";
 import {
   HEARTBEAT_INTERVAL_MS,
   sendHeartbeat
-} from "../chunk-ZBZBYUNZ.js";
-import "../chunk-VJUDBZGC.js";
+} from "../chunk-2QFYEB3P.js";
+import "../chunk-USZJJWZL.js";
 import {
   readSignedOutDiagnosis
-} from "../chunk-2QB7HJVJ.js";
-import "../chunk-FAKEKFCI.js";
+} from "../chunk-B2PFCS72.js";
+import {
+  HERMES_INSTALL_MARKER_FILE,
+  defaultHermesHome,
+  parseHermesInstallMarker
+} from "../chunk-FAGQAR6I.js";
 import {
   writeHuman
 } from "../chunk-QCGNGEGE.js";
-import "../chunk-KSLBS3II.js";
-import "../chunk-EUEGCEA7.js";
-import "../chunk-W47XZJSH.js";
-import "../chunk-3RAWW5DH.js";
+import "../chunk-W5AUTVVL.js";
+import "../chunk-SWRNJ3BP.js";
+import "../chunk-C2AR7QXU.js";
+import "../chunk-QUGP76DQ.js";
 import {
   exitOnHelpFlag
-} from "../chunk-OJ3ZD5VX.js";
+} from "../chunk-WK2L3XVQ.js";
 import {
   codexBinaryIsBroken,
   detectProviderLiveCapabilities,
@@ -29,8 +33,8 @@ import {
   launchableProviders,
   resolveControlPolicy,
   trackProviderInventory
-} from "../chunk-EITOMPFB.js";
-import "../chunk-JYOR57ZW.js";
+} from "../chunk-74ONBRPF.js";
+import "../chunk-NFUV25JZ.js";
 import {
   SESSION_REAP_SILENCE_MS,
   describeIdleWindow,
@@ -38,16 +42,17 @@ import {
   listProcessProofs,
   ownsLiveProcess,
   silentSpawnedProofs
-} from "../chunk-PNXNWZ5P.js";
-import "../chunk-TFDMJHAB.js";
+} from "../chunk-XLGD5LDG.js";
+import "../chunk-UMBVIFP5.js";
 import {
   readLocalAutoUpdateReport
-} from "../chunk-TTGBS5JB.js";
+} from "../chunk-CMNB4IZO.js";
 import {
   startRegisteredTranscripts
-} from "../chunk-AC5TVOAH.js";
-import "../chunk-FB262EOM.js";
-import "../chunk-UIF7HWHX.js";
+} from "../chunk-7SFP6Y5U.js";
+import "../chunk-YLB4AGZJ.js";
+import "../chunk-MHUKYYYR.js";
+import "../chunk-3YU6NIIL.js";
 import {
   DAEMON_LEASE_RENEW_INTERVAL_MS,
   acquireDaemonLease,
@@ -64,52 +69,1273 @@ import {
   requestDaemonHandoff,
   stopDaemonRunning,
   writeDaemonNeedsLogin
-} from "../chunk-WJJVCDEU.js";
-import "../chunk-QAWWTRDD.js";
-import "../chunk-2HFC4W6J.js";
-import "../chunk-BLX6KRK5.js";
+} from "../chunk-DB3NOEDW.js";
+import {
+  hookOwnerOf
+} from "../chunk-KGWLDNNT.js";
+import "../chunk-PPD64MZW.js";
+import "../chunk-5FV472Q2.js";
 import "../chunk-NMUI3ZWG.js";
-import "../chunk-JC7XUZST.js";
-import "../chunk-S63VIM7E.js";
+import "../chunk-ITLWEGLE.js";
+import "../chunk-XMSDA5WA.js";
+import "../chunk-5M5F4IWR.js";
 import {
   spawnClaude
 } from "../chunk-XHKBHWLX.js";
 import {
   readControlMode
-} from "../chunk-NGNBX3YH.js";
-import "../chunk-AJWGZJFS.js";
-import "../chunk-QMPM3CAN.js";
-import "../chunk-CMYFV3VC.js";
+} from "../chunk-7LLC4R66.js";
+import {
+  pendingCommandReceipts,
+  removePendingCommand
+} from "../chunk-NVLKH5FS.js";
+import "../chunk-ZY25SNFQ.js";
+import "../chunk-7ZOWQBHQ.js";
 import "../chunk-POFBE6ZY.js";
-import "../chunk-7M4AA7QF.js";
-import "../chunk-S7VMHSJW.js";
-import "../chunk-O4EAMVSC.js";
+import "../chunk-JNV5LOZH.js";
+import "../chunk-E7U4YM4A.js";
+import "../chunk-KWGOKO4E.js";
 import {
   getMachineId
-} from "../chunk-UUCRWEEU.js";
-import "../chunk-PPY5N2E6.js";
+} from "../chunk-BUR2LYQI.js";
+import "../chunk-5NW7VM35.js";
 import {
-  EXIT
-} from "../chunk-KZERVKTD.js";
-import "../chunk-7FROPPIH.js";
-import "../chunk-7S46LCKD.js";
+  claudeConfigDir,
+  codexHome
+} from "../chunk-7KYQ24FI.js";
 import {
-  resolveBinary
-} from "../chunk-RZVWEDIS.js";
+  resolveBinary,
+  writeJsonAtomicDurable
+} from "../chunk-T2EJ3H6Y.js";
 import {
   getApiKey,
   getBaseUrl
-} from "../chunk-R5PZPROX.js";
-import "../chunk-PPKIL4EL.js";
+} from "../chunk-M7JFGDGP.js";
+import "../chunk-PPY5N2E6.js";
+import {
+  EXIT
+} from "../chunk-KZERVKTD.js";
+import "../chunk-R3HXGHRQ.js";
 import "../chunk-QTOLNRET.js";
-import "../chunk-AVHL2ZTS.js";
+import {
+  CLAUDE_INBOX,
+  CLAUDE_INBOX_MAX_SESSIONS,
+  CLAUDE_INBOX_RECEIVER,
+  CLAUDE_INBOX_SETTLEMENTS,
+  CLAUDE_WAKE,
+  CLAUDE_WAKE_API,
+  COMMAND_RECOVERY,
+  NATIVE_INPUT,
+  NativeInputAgent,
+  claudeInboxAction,
+  claudeWakeDecision,
+  claudeWakeWaitingOn,
+  hermesPendingAdmissionId,
+  hermesReplayAdmissionId,
+  isClaudeInboxReceipt,
+  isCodexInputReceipt,
+  isCodexQueuedReceipt,
+  isCommandAcknowledgementReceipt,
+  nativeIdentifier,
+  nativeInputAction,
+  nativeRecord,
+  parseClaudeInboxClaim,
+  parseClaudeInboxPoll,
+  parseClaudeInboxSession,
+  parseHermesAdmission,
+  parseHermesReplayCursor,
+  qualifyHermesReceiptMode
+} from "../chunk-Y4OBAK4I.js";
 import "../chunk-MLKGABMK.js";
 
-// src/spawn-daemon.ts
-import { execFileSync, spawn } from "child_process";
-import { existsSync, statSync } from "fs";
+// src/native-host-receiver.ts
+import { join as join2 } from "path";
 import { homedir } from "os";
-import { basename, dirname, join } from "path";
+import { readFileSync as readFileSync3 } from "fs";
+
+// src/native-host.ts
+import WebSocket from "ws";
+import { createConnection } from "net";
+import { createHash } from "crypto";
+import {
+  readdirSync,
+  lstatSync,
+  realpathSync,
+  readFileSync,
+  mkdirSync,
+  openSync,
+  writeSync,
+  fsyncSync,
+  closeSync
+} from "fs";
+import { dirname, join, resolve } from "path";
+var privateNode = (path, kind) => {
+  try {
+    const s = lstatSync(path);
+    return s.uid === process.getuid?.() && (s.mode & 63) === 0 && (kind === "socket" ? s.isSocket() : s.isDirectory());
+  } catch {
+    return false;
+  }
+};
+var ownerControlledDirectory = (path) => {
+  try {
+    const node = lstatSync(path);
+    return node.isDirectory() && node.uid === process.getuid?.() && (node.mode & 18) === 0;
+  } catch {
+    return false;
+  }
+};
+var syncDirectory = (path) => {
+  const fd = openSync(path, "r");
+  try {
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+};
+var Rpc = class _Rpc {
+  constructor(socket, timeout) {
+    this.socket = socket;
+    this.timeout = timeout;
+    socket.on("message", (data) => {
+      let v;
+      try {
+        v = JSON.parse(data.toString());
+      } catch {
+        socket.terminate();
+        return;
+      }
+      if (!nativeRecord(v) || typeof v.id !== "number") return;
+      const p = this.pending.get(v.id);
+      if (!p) return;
+      this.pending.delete(v.id);
+      clearTimeout(p.timer);
+      if (v.error) p.reject(new Error("native RPC refused"));
+      else p.resolve(v.result);
+    });
+    socket.on("close", () => this.fail());
+    socket.on("error", () => this.fail());
+  }
+  sequence = 0;
+  pending = /* @__PURE__ */ new Map();
+  fail() {
+    for (const p of this.pending.values()) {
+      clearTimeout(p.timer);
+      p.reject(new Error("native RPC disconnected"));
+    }
+    this.pending.clear();
+  }
+  static async connect(url, protocols, timeout) {
+    const socket = new WebSocket(url, [...protocols], {
+      handshakeTimeout: timeout,
+      maxPayload: NATIVE_INPUT.maxFrameBytes,
+      followRedirects: false
+    });
+    const rpc = new _Rpc(socket, timeout);
+    await new Promise((resolve3, reject) => {
+      socket.once("open", resolve3);
+      socket.once("error", reject);
+    });
+    if (protocols.length && socket.protocol !== protocols[0]) {
+      rpc.close();
+      throw new Error("native protocol mismatch");
+    }
+    return rpc;
+  }
+  request(method, params) {
+    const id = ++this.sequence;
+    return new Promise((resolve3, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error("native RPC timeout"));
+      }, this.timeout);
+      this.pending.set(id, { resolve: resolve3, reject, timer });
+      this.socket.send(
+        JSON.stringify({ jsonrpc: "2.0", id, method, params }),
+        (error) => {
+          if (error) {
+            clearTimeout(timer);
+            this.pending.delete(id);
+            reject(error);
+          }
+        }
+      );
+    });
+  }
+  notify(method) {
+    this.socket.send(JSON.stringify({ method }));
+  }
+  close() {
+    this.fail();
+    this.socket.terminate();
+  }
+};
+var controlRequest = (path, request, timeout) => new Promise((resolve3, reject) => {
+  const s = createConnection(path);
+  let buffer = "";
+  const timer = setTimeout(() => {
+    s.destroy();
+    reject(new Error("native control timeout"));
+  }, timeout);
+  s.on("connect", () => s.write(JSON.stringify(request) + "\n"));
+  s.on("error", reject);
+  s.on("close", () => {
+    clearTimeout(timer);
+    reject(new Error("native control closed"));
+  });
+  s.on("data", (chunk) => {
+    buffer += chunk.toString();
+    if (buffer.length > 65536) {
+      s.destroy();
+      return;
+    }
+    if (!buffer.includes("\n")) return;
+    try {
+      resolve3(JSON.parse(buffer.slice(0, buffer.indexOf("\n"))));
+    } catch {
+      reject(new Error("invalid native control response"));
+    }
+    s.destroy();
+  });
+});
+var NativeHostClient = class {
+  constructor(options) {
+    this.options = options;
+    this.timeout = options.timeoutMs ?? NATIVE_INPUT.rpcTimeoutMs;
+  }
+  timeout;
+  async connect() {
+    if ((this.options.platform ?? process.platform) !== "darwin")
+      throw new Error("native host platform unqualified");
+    const home = resolve(this.options.home);
+    if (this.options.agent === "codex" /* codex */) {
+      const published = join(home, NATIVE_INPUT.codexSocket);
+      const path2 = realpathSync(published);
+      if (lstatSync(published).uid !== process.getuid?.() || !privateNode(join(home, "app-server-control"), "directory") || !privateNode(dirname(path2), "directory") || !privateNode(path2, "socket"))
+        throw new Error("native control unavailable");
+      const rpc = await Rpc.connect(`ws+unix://${path2}:/`, [], this.timeout);
+      try {
+        const v2 = await rpc.request("initialize", {
+          clientInfo: { name: "pushary_native_input", version: "1" },
+          capabilities: { experimentalApi: true }
+        });
+        if (!nativeRecord(v2) || v2.codexHome !== home || typeof v2.userAgent !== "string" || !v2.userAgent.includes(`/${NATIVE_INPUT.codexVersion} `) || v2.platformOs !== "macos")
+          throw new Error("unqualified native host");
+        rpc.notify("initialized");
+        return { rpc, profile: home };
+      } catch (e) {
+        rpc.close();
+        throw e;
+      }
+    }
+    const path = join(home, NATIVE_INPUT.hermesSocket);
+    if (!ownerControlledDirectory(home) || !privateNode(path, "socket"))
+      throw new Error("native control unavailable");
+    const v = await controlRequest(
+      path,
+      { protocol: 1, verb: "identify", id: 1 },
+      this.timeout
+    );
+    if (!nativeRecord(v)) throw new Error("invalid host");
+    const d = nativeRecord(v.result) ? v.result : v;
+    if (d.runtime_protocol !== 1 || d.state !== "ready" || !Array.isArray(d.served_profiles) || !nativeIdentifier(d.instance_id) || typeof d.api_origin !== "string")
+      throw new Error("unqualified native host");
+    const profiles = d.served_profiles.filter(
+      (p) => nativeRecord(p) && p.home === home
+    );
+    const profile = profiles[0];
+    if (profiles.length !== 1 || !nativeRecord(profile) || typeof profile.profile_id !== "string")
+      throw new Error("native profile mismatch");
+    const hermesReceiptMode = qualifyHermesReceiptMode(
+      d.code_sha,
+      d.capabilities
+    );
+    if (!hermesReceiptMode) throw new Error("native admission unavailable");
+    const url = new URL(d.api_origin);
+    if (url.protocol !== "http:" || url.hostname !== "127.0.0.1" || url.username || url.password || url.pathname !== "/")
+      throw new Error("nonlocal native host");
+    const t = await controlRequest(
+      path,
+      {
+        protocol: 1,
+        id: 1,
+        verb: "session-ticket",
+        params: {
+          profile_id: profile.profile_id,
+          instance_id: d.instance_id,
+          purpose: "interactive"
+        }
+      },
+      this.timeout
+    );
+    const ticket = nativeRecord(t) && nativeRecord(t.result) ? t.result : t;
+    if (!nativeRecord(ticket) || ticket.profile_id !== profile.profile_id || ticket.instance_id !== d.instance_id || ticket.runtime_protocol !== 1 || typeof ticket.ticket !== "string")
+      throw new Error("native ticket mismatch");
+    return {
+      rpc: await Rpc.connect(
+        `ws://${url.host}/api/ws`,
+        [
+          NATIVE_INPUT.hermesWebSocketProtocol,
+          NATIVE_INPUT.hermesTicketPrefix + ticket.ticket
+        ],
+        this.timeout
+      ),
+      profile: profile.profile_id,
+      hermesReceiptMode
+    };
+  }
+  async list(host) {
+    const { rpc } = host;
+    if (this.options.agent === "codex" /* codex */) {
+      const v2 = await rpc.request("thread/loaded/list", {
+        limit: NATIVE_INPUT.maxSessions
+      });
+      if (!nativeRecord(v2) || !Array.isArray(v2.data) || !v2.data.every(nativeIdentifier))
+        throw new Error("invalid loaded sessions");
+      const sessions = [];
+      for (const id of v2.data) {
+        const t = await this.thread(rpc, id, false);
+        if (t && typeof t.cwd === "string")
+          sessions.push({
+            sessionId: id,
+            cwd: t.cwd,
+            agent: this.options.agent
+          });
+      }
+      return sessions;
+    }
+    const v = await rpc.request("session.list", {
+      limit: NATIVE_INPUT.maxSessions
+    });
+    if (!nativeRecord(v) || v.scope !== "live" || !Array.isArray(v.sessions))
+      throw new Error("invalid live sessions");
+    return v.sessions.filter(
+      (row) => nativeRecord(row) && nativeIdentifier(row.session_id) && (row.source === "cli" || row.source === "local")
+    ).map((row) => ({
+      sessionId: String(row.session_id),
+      cwd: this.options.home,
+      agent: this.options.agent
+    }));
+  }
+  async sessions() {
+    let host;
+    try {
+      host = await this.connect();
+      return await this.list(host);
+    } catch (error) {
+      this.options.report?.(
+        error instanceof Error ? error.message : "native discovery failed"
+      );
+      return [];
+    } finally {
+      host?.rpc.close();
+    }
+  }
+  async thread(rpc, id, includeTurns = false) {
+    const v = await rpc.request("thread/read", { threadId: id, includeTurns });
+    return nativeRecord(v) && nativeRecord(v.thread) && v.thread.id === id ? v.thread : null;
+  }
+  async hasReceipt(rpc, sessionId, commandId) {
+    for (const method of [
+      "thread/queue/list" /* queueList */,
+      "thread/items/list" /* itemsList */
+    ]) {
+      let cursor;
+      for (let page = 0; page < NATIVE_INPUT.receiptMaxPages; page++) {
+        const result = await rpc.request(method, {
+          threadId: sessionId,
+          ...method === "thread/items/list" /* itemsList */ ? { sortDirection: "desc" } : {},
+          limit: NATIVE_INPUT.receiptPageSize,
+          ...cursor ? { cursor } : {}
+        });
+        if (!nativeRecord(result) || !Array.isArray(result.data))
+          throw new Error("invalid native receipt page");
+        if (method === "thread/queue/list" /* queueList */) {
+          if (result.data.some((row) => isCodexQueuedReceipt(row, commandId)))
+            return true;
+        } else {
+          const items = result.data.flatMap(
+            (row) => nativeRecord(row) && nativeRecord(row.item) ? [row.item] : []
+          );
+          if (isCodexInputReceipt(
+            { id: sessionId, turns: [{ items }] },
+            sessionId,
+            commandId
+          ))
+            return true;
+        }
+        if (typeof result.nextCursor !== "string" || !result.nextCursor || result.nextCursor === cursor)
+          break;
+        cursor = result.nextCursor;
+      }
+    }
+    return false;
+  }
+  async hasHermesReceipt(host, intent, snapshot) {
+    if (host.hermesReceiptMode === "submission" /* submission */) {
+      const receipt2 = parseHermesAdmission(
+        await host.rpc.request("prompt.receipt" /* receipt */, {
+          session_id: intent.sessionId,
+          submission_id: intent.commandId
+        }),
+        host.profile,
+        intent.sessionId
+      );
+      return receipt2 !== null && receipt2.status !== "unknown" /* unknown */;
+    }
+    let admissionId = hermesPendingAdmissionId(
+      snapshot,
+      host.profile,
+      intent.sessionId,
+      intent.commandId
+    );
+    if (!admissionId && intent.hermesCursor) {
+      const replay = await host.rpc.request("session.events.since" /* eventsSince */, {
+        session_id: intent.sessionId,
+        ...intent.hermesCursor
+      });
+      admissionId = hermesReplayAdmissionId(
+        replay,
+        intent.hermesCursor,
+        intent.sessionId,
+        intent.commandId
+      );
+    }
+    if (!admissionId) return false;
+    const receipt = parseHermesAdmission(
+      await host.rpc.request("prompt.receipt" /* receipt */, {
+        session_id: intent.sessionId,
+        admission_id: admissionId
+      }),
+      host.profile,
+      intent.sessionId
+    );
+    return receipt?.admissionId === admissionId && receipt.status !== "unknown" /* unknown */;
+  }
+  journalPath(sessionId, commandId) {
+    return join(
+      this.options.journalDir,
+      createHash("sha256").update(`${sessionId}\0${commandId}`).digest("hex") + ".json"
+    );
+  }
+  readIntent(sessionId, commandId) {
+    try {
+      const file = this.journalPath(sessionId, commandId);
+      const node = lstatSync(file);
+      if (!node.isFile() || node.uid !== process.getuid?.() || node.size > 4096 || (node.mode & 63) !== 0)
+        throw new Error("unsafe intent");
+      const v = JSON.parse(readFileSync(file, "utf8"));
+      if (!nativeRecord(v) || v.version !== NATIVE_INPUT.journalVersion || v.agent !== this.options.agent || v.sessionId !== sessionId || v.commandId !== commandId || v.home !== resolve(this.options.home) || typeof v.submittedAtMs !== "number" || !Number.isSafeInteger(v.submittedAtMs) || typeof v.accepted !== "boolean" || v.hermesCursor !== void 0 && !parseHermesReplayCursor(v.hermesCursor))
+        throw new Error("invalid intent");
+      const hermesCursor = parseHermesReplayCursor(v.hermesCursor);
+      return {
+        version: v.version,
+        agent: v.agent,
+        sessionId,
+        commandId,
+        home: v.home,
+        submittedAtMs: v.submittedAtMs,
+        accepted: v.accepted,
+        settled: v.settled === true,
+        ...hermesCursor ? { hermesCursor } : {}
+      };
+    } catch (e) {
+      if (e instanceof Error && "code" in e && e.code === "ENOENT") return null;
+      throw e;
+    }
+  }
+  pendingSettlements() {
+    try {
+      return readdirSync(this.options.journalDir).filter((file) => /^[0-9a-f]{64}\.json$/.test(file)).flatMap((file) => {
+        try {
+          const raw = JSON.parse(
+            readFileSync(join(this.options.journalDir, file), "utf8")
+          );
+          if (!nativeRecord(raw) || !nativeIdentifier(raw.sessionId) || !nativeIdentifier(raw.commandId))
+            return [];
+          const intent = this.readIntent(raw.sessionId, raw.commandId);
+          return intent?.accepted && !intent.settled ? [{ sessionId: intent.sessionId, commandId: intent.commandId }] : [];
+        } catch {
+          return [];
+        }
+      });
+    } catch {
+      return [];
+    }
+  }
+  confirmSettlement(sessionId, commandId) {
+    const intent = this.readIntent(sessionId, commandId);
+    if (intent?.accepted)
+      writeJsonAtomicDurable(
+        this.journalPath(sessionId, commandId),
+        { ...intent, settled: true },
+        384
+      );
+  }
+  writeIntent(sessionId, commandId, hermesCursor) {
+    mkdirSync(this.options.journalDir, { recursive: true, mode: 448 });
+    const fd = openSync(this.journalPath(sessionId, commandId), "wx", 384);
+    try {
+      writeSync(
+        fd,
+        JSON.stringify({
+          version: NATIVE_INPUT.journalVersion,
+          agent: this.options.agent,
+          sessionId,
+          commandId,
+          home: resolve(this.options.home),
+          submittedAtMs: Date.now(),
+          accepted: false,
+          ...hermesCursor ? { hermesCursor } : {}
+        })
+      );
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    syncDirectory(this.options.journalDir);
+  }
+  accept(intent) {
+    writeJsonAtomicDurable(
+      this.journalPath(intent.sessionId, intent.commandId),
+      { ...intent, accepted: true },
+      384
+    );
+    return "accepted" /* accepted */;
+  }
+  async deliver(sessionId, command, signal) {
+    let intent;
+    try {
+      intent = this.readIntent(sessionId, command.id);
+    } catch {
+      return "outcome_unknown" /* outcomeUnknown */;
+    }
+    if (intent?.accepted) return "accepted" /* accepted */;
+    if (!intent && command.expiresAtMs <= Date.now())
+      return "expired" /* expired */;
+    let host;
+    let hermesCursor;
+    try {
+      host = await this.connect();
+      const { rpc } = host;
+      if (!(await this.list(host)).some((s) => s.sessionId === sessionId))
+        return intent ? "outcome_unknown" /* outcomeUnknown */ : "not_sent" /* notSent */;
+      if (this.options.agent === "codex" /* codex */) {
+        if (intent) {
+          if (await this.hasReceipt(rpc, sessionId, command.id))
+            return this.accept(intent);
+        } else {
+          const queue = await rpc.request("thread/queue/list" /* queueList */, {
+            threadId: sessionId,
+            limit: 1
+          });
+          if (!nativeRecord(queue) || !Array.isArray(queue.data))
+            throw new Error("native queue unavailable");
+        }
+      } else if (host.hermesReceiptMode === "submission" /* submission */) {
+        if (intent && await this.hasHermesReceipt(host, intent))
+          return this.accept(intent);
+        if (!intent) {
+          const snapshot = await rpc.request("session.resume" /* resume */, {
+            session_id: sessionId
+          });
+          if (!nativeRecord(snapshot) || snapshot.session_id !== sessionId)
+            throw new Error("native session mismatch");
+        }
+      } else {
+        const snapshot = await rpc.request("session.resume" /* resume */, {
+          session_id: sessionId
+        });
+        if (!nativeRecord(snapshot) || snapshot.session_id !== sessionId)
+          throw new Error("native session mismatch");
+        hermesCursor = parseHermesReplayCursor(snapshot) ?? void 0;
+        if (intent && await this.hasHermesReceipt(host, intent, snapshot))
+          return this.accept(intent);
+        if (!intent && !hermesCursor)
+          throw new Error("native replay cursor unavailable");
+      }
+      const action = nativeInputAction({
+        attempted: !!intent,
+        accepted: false,
+        nowMs: Date.now(),
+        expiresAtMs: Math.min(
+          command.expiresAtMs,
+          intent ? intent.submittedAtMs + NATIVE_INPUT.receiptWindowMs : Infinity
+        )
+      });
+      if (action === "expire" /* expire */) return "expired" /* expired */;
+      if (action === "outcome_unknown" /* outcomeUnknown */)
+        return "outcome_unknown" /* outcomeUnknown */;
+      if (action === "observe" /* observe */)
+        return "unconfirmed" /* unconfirmed */;
+      if (signal?.aborted) return "not_sent" /* notSent */;
+      if (!intent) {
+        this.writeIntent(sessionId, command.id, hermesCursor);
+        intent = this.readIntent(sessionId, command.id);
+      }
+      if (!intent) return "outcome_unknown" /* outcomeUnknown */;
+      if (this.options.agent === "hermes" /* hermes */) {
+        const receipt = parseHermesAdmission(
+          await rpc.request("prompt.submit" /* submit */, {
+            session_id: sessionId,
+            submission_id: command.id,
+            text: command.text
+          }),
+          host.profile,
+          sessionId
+        );
+        return receipt && receipt.status !== "unknown" /* unknown */ ? this.accept(intent) : "outcome_unknown" /* outcomeUnknown */;
+      }
+      const response = await rpc.request("thread/queue/add" /* queueAdd */, {
+        threadId: sessionId,
+        clientUserMessageId: command.id,
+        input: [{ type: "text", text: command.text, text_elements: [] }]
+      });
+      return nativeRecord(response) && isCodexQueuedReceipt(response.queuedSubmission, command.id) || await this.hasReceipt(rpc, sessionId, command.id) ? this.accept(intent) : "unconfirmed" /* unconfirmed */;
+    } catch (error) {
+      this.options.report?.(
+        error instanceof Error ? error.message : "native delivery failed"
+      );
+      return intent ? Date.now() >= Math.min(
+        command.expiresAtMs,
+        intent.submittedAtMs + NATIVE_INPUT.receiptWindowMs
+      ) ? "outcome_unknown" /* outcomeUnknown */ : "unconfirmed" /* unconfirmed */ : "not_sent" /* notSent */;
+    } finally {
+      host?.rpc.close();
+    }
+  }
+};
+
+// src/hook-ownership-file.ts
+import { readFileSync as readFileSync2 } from "fs";
+var readHookOwner = (file) => {
+  try {
+    const value = JSON.parse(readFileSync2(file, "utf8"));
+    return nativeRecord(value) ? hookOwnerOf(value) : null;
+  } catch (error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT" ? "none" : null;
+  }
+};
+
+// src/native-input-receiver.ts
+import { basename } from "path";
+var startNativeInputReceiver = (apiKey, machineId, options) => {
+  const client = options.client;
+  const baseUrl = options.baseUrl ?? getBaseUrl();
+  const abort = new AbortController();
+  const busy = /* @__PURE__ */ new Set();
+  const heartbeats = /* @__PURE__ */ new Map();
+  const settlements = /* @__PURE__ */ new Map();
+  let scanning = false;
+  let cursor = 0;
+  const post = async (path, body) => {
+    const response = await fetch(`${baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.any([
+        abort.signal,
+        AbortSignal.timeout(CLAUDE_INBOX_RECEIVER.requestTimeoutMs)
+      ])
+    });
+    if (!response.ok) throw new Error(`native inbox HTTP ${response.status}`);
+    return response.json();
+  };
+  const settle = async (commandId) => {
+    const pending = settlements.get(commandId);
+    if (!pending) return false;
+    try {
+      const receipt = await post("/api/agent/command/ack", {
+        ...pending,
+        commandId,
+        machineId
+      });
+      if (!isCommandAcknowledgementReceipt(receipt))
+        throw new Error("native acknowledgement missing receipt");
+      client.confirmSettlement(pending.sessionId, commandId);
+      settlements.delete(commandId);
+      return true;
+    } catch (error) {
+      if (!abort.signal.aborted)
+        options.report?.(
+          error instanceof Error ? error.message : "native receipt recovery failed"
+        );
+      return false;
+    }
+  };
+  const receive = async (sessionId) => {
+    busy.add(sessionId);
+    try {
+      if ([...settlements.values()].some(
+        (receipt) => receipt.sessionId === sessionId
+      ))
+        return;
+      const raw = await post("/api/agent/command/native", {
+        operation: "claim" /* claim */,
+        sessionId,
+        machineId
+      });
+      const command = parseClaudeInboxClaim(raw);
+      if (!command || abort.signal.aborted) return;
+      const outcome = await client.deliver(sessionId, command, abort.signal);
+      const settlement = CLAUDE_INBOX_SETTLEMENTS[outcome];
+      if (abort.signal.aborted || !settlement) return;
+      settlements.set(command.id, { sessionId, ...settlement });
+      await settle(command.id);
+    } catch (error) {
+      if (!abort.signal.aborted)
+        options.report?.(
+          error instanceof Error ? error.message : "native inbox delivery failed"
+        );
+    } finally {
+      busy.delete(sessionId);
+    }
+  };
+  const tick = async () => {
+    if (scanning || abort.signal.aborted) return;
+    scanning = true;
+    try {
+      for (const receipt of client.pendingSettlements()) {
+        settlements.set(receipt.commandId, {
+          sessionId: receipt.sessionId,
+          state: "delivered"
+        });
+      }
+      for (const commandId of [...settlements.keys()]) await settle(commandId);
+      const sessions = (await client.sessions()).filter(options.ownsSession).slice(0, CLAUDE_INBOX_MAX_SESSIONS);
+      if (!sessions.length) return;
+      for (const session of sessions) {
+        if (Date.now() - (heartbeats.get(session.sessionId) ?? 0) < CLAUDE_INBOX_RECEIVER.heartbeatMs)
+          continue;
+        await post("/api/agent/event", {
+          event: "heartbeat",
+          agentType: options.agentType ?? "claude_code",
+          agentName: `${options.agentName ?? "Claude Code"} - ${basename(session.cwd)}`,
+          sessionId: session.sessionId,
+          machineId,
+          cwd: session.cwd,
+          sentAt: (/* @__PURE__ */ new Date()).toISOString(),
+          canDrainCommand: false
+        });
+        heartbeats.set(session.sessionId, Date.now());
+      }
+      const raw = await post("/api/agent/command/native", {
+        operation: "poll" /* poll */,
+        machineId,
+        sessionIds: sessions.map((session) => session.sessionId)
+      });
+      const pending = parseClaudeInboxPoll(raw);
+      if (!pending) throw new Error("native inbox protocol mismatch");
+      const rotated = [...pending.slice(cursor), ...pending.slice(0, cursor)];
+      cursor = pending.length ? (cursor + CLAUDE_INBOX_RECEIVER.maxConcurrent) % pending.length : 0;
+      for (const sessionId of rotated) {
+        if (abort.signal.aborted || busy.size >= CLAUDE_INBOX_RECEIVER.maxConcurrent)
+          break;
+        if (!busy.has(sessionId) && sessions.some((session) => session.sessionId === sessionId))
+          void receive(sessionId);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "native inbox polling failed";
+      if (!abort.signal.aborted) options.report?.(message);
+    } finally {
+      scanning = false;
+    }
+  };
+  const timer = setInterval(() => {
+    void tick();
+  }, options.pollMs ?? CLAUDE_INBOX_RECEIVER.pollMs);
+  timer.unref();
+  void tick();
+  return () => {
+    abort.abort();
+    clearInterval(timer);
+  };
+};
+
+// src/native-host-receiver.ts
+var ownsHermes = (home) => {
+  try {
+    return parseHermesInstallMarker(
+      JSON.parse(
+        readFileSync3(
+          join2(home, "plugins", "pushary", HERMES_INSTALL_MARKER_FILE),
+          "utf8"
+        )
+      )
+    )?.installedBy === "cli";
+  } catch {
+    return false;
+  }
+};
+var startNativeHostReceivers = (apiKey, machineId, report) => {
+  const homes = {
+    ["codex" /* codex */]: codexHome(),
+    ["hermes" /* hermes */]: defaultHermesHome()
+  };
+  const stops = Object.values(NativeInputAgent).map((agent) => {
+    const home = homes[agent];
+    return startNativeInputReceiver(apiKey, machineId, {
+      client: new NativeHostClient({
+        agent,
+        home,
+        report,
+        journalDir: join2(homedir(), ".pushary", NATIVE_INPUT.journalDirectory)
+      }),
+      agentType: agent,
+      agentName: agent === "codex" /* codex */ ? "Codex" : "Hermes",
+      report,
+      ownsSession: () => agent === "codex" /* codex */ ? readHookOwner(join2(home, "hooks.json")) === "cli" : ownsHermes(home)
+    });
+  });
+  return () => {
+    for (const stop of stops) stop();
+  };
+};
+
+// src/hook-command-receipts.ts
+var reconcileCommandReceipts = async (apiKey, machineId, agentType, baseUrl, signal) => {
+  const namespace = `${apiKey}:${machineId}:${agentType}`;
+  for (const { sessionId, command } of pendingCommandReceipts(namespace)) {
+    signal?.throwIfAborted();
+    const state = command.delivered ? "delivered" : command.attempted ? "uncertain" : "failed";
+    const response = await fetch(`${baseUrl}/api/agent/command/ack`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        commandId: command.id,
+        sessionId,
+        machineId,
+        state,
+        failureCode: command.attempted ? "delivery_unconfirmed" : "expired"
+      }),
+      signal: AbortSignal.any([
+        AbortSignal.timeout(COMMAND_RECOVERY.acknowledgementTimeoutMs),
+        ...signal ? [signal] : []
+      ])
+    });
+    if (response.ok) removePendingCommand(sessionId, command.id, namespace);
+  }
+};
+
+// src/claude-inbox-receiver.ts
+import { join as join4, basename as basename2 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/claude-inbox.ts
+import { createHash as createHash2, randomUUID } from "crypto";
+import { execFileSync } from "child_process";
+import {
+  closeSync as closeSync2,
+  fsyncSync as fsyncSync2,
+  lstatSync as lstatSync2,
+  mkdirSync as mkdirSync2,
+  openSync as openSync2,
+  readFileSync as readFileSync4,
+  readdirSync as readdirSync2,
+  readSync,
+  statSync,
+  writeFileSync,
+  unlinkSync
+} from "fs";
+import { dirname as dirname2, isAbsolute, join as join3, resolve as resolve2 } from "path";
+import { Socket } from "net";
+import { setTimeout as delay } from "timers/promises";
+var object = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var digest = (value) => createHash2("sha256").update(value).digest("hex");
+var readObject = (file) => {
+  const stat = lstatSync2(file);
+  if (!stat.isFile() || stat.size > CLAUDE_INBOX.maxRecordBytes || stat.uid !== process.getuid?.())
+    throw new Error("Invalid inbox record");
+  return JSON.parse(readFileSync4(file, "utf8"));
+};
+var readKey = (file) => {
+  const value = readObject(file);
+  return object(value) && typeof value.peerToken === "string" && /^[0-9a-f]{32}$/.test(value.peerToken) && typeof value.procStart === "string" ? { peerToken: value.peerToken, procStart: value.procStart } : null;
+};
+var processStart = (pid) => {
+  if (process.platform !== "darwin") return null;
+  try {
+    return execFileSync("/bin/ps", ["-p", String(pid), "-o", "lstart="], {
+      encoding: "utf8",
+      env: { ...process.env, TZ: "UTC", LC_ALL: "C" },
+      timeout: CLAUDE_INBOX.connectTimeoutMs
+    }).trim();
+  } catch {
+    return null;
+  }
+};
+var transcriptPath = (config, session) => join3(
+  config,
+  "projects",
+  resolve2(session.cwd).replace(/[^a-zA-Z0-9-]/g, "-"),
+  `${session.sessionId}.jsonl`
+);
+var transcriptSize = (file) => {
+  try {
+    return statSync(file).size;
+  } catch {
+    return 0;
+  }
+};
+var receiptPresent = (attempt) => {
+  let fd;
+  try {
+    fd = openSync2(attempt.transcript, "r");
+    const buffer = Buffer.alloc(CLAUDE_INBOX.maxTranscriptReadBytes);
+    const count = readSync(fd, buffer, 0, buffer.length, attempt.offset);
+    for (const line of buffer.subarray(0, count).toString("utf8").split("\n")) {
+      try {
+        if (isClaudeInboxReceipt(
+          JSON.parse(line),
+          attempt.sessionId,
+          attempt.commandId
+        ))
+          return true;
+      } catch {
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  } finally {
+    if (fd !== void 0) closeSync2(fd);
+  }
+};
+var connectInbox = (path) => new Promise((resolveConnection) => {
+  const socket = new Socket();
+  const timer = setTimeout(failed, CLAUDE_INBOX.connectTimeoutMs);
+  function failed() {
+    clearTimeout(timer);
+    socket.destroy();
+    resolveConnection(null);
+  }
+  socket.once("error", failed);
+  socket.connect(path, () => {
+    clearTimeout(timer);
+    socket.removeListener("error", failed);
+    socket.on("error", () => {
+    });
+    resolveConnection(socket);
+  });
+});
+var createAttempt = (file, attempt) => {
+  mkdirSync2(dirname2(file), { recursive: true, mode: 448 });
+  const fd = openSync2(file, "wx", 384);
+  try {
+    writeFileSync(fd, JSON.stringify(attempt));
+    fsyncSync2(fd);
+  } finally {
+    closeSync2(fd);
+  }
+  const directory = openSync2(dirname2(file), "r");
+  try {
+    fsyncSync2(directory);
+  } finally {
+    closeSync2(directory);
+  }
+  return true;
+};
+var ClaudeInboxClient = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  sessions() {
+    try {
+      const sessions = readdirSync2(
+        join3(this.options.configDir, "sessions")
+      ).filter((file) => /^\d+\.json$/.test(file));
+      return sessions.flatMap((file) => {
+        try {
+          const session = parseClaudeInboxSession(
+            readObject(join3(this.options.configDir, "sessions", file))
+          );
+          if (!session || file !== `${session.pid}.json` || !isAbsolute(session.cwd) || !isAbsolute(session.messagingSocketPath))
+            return [];
+          if ((this.options.processStart ?? processStart)(session.pid) !== session.procStart)
+            return [];
+          const socket = lstatSync2(session.messagingSocketPath);
+          if (!socket.isSocket() || socket.uid !== process.getuid?.()) return [];
+          return this.key(session) ? [session] : [];
+        } catch {
+          return [];
+        }
+      });
+    } catch {
+      return [];
+    }
+  }
+  key(session) {
+    const canonicalSocket = session.messagingSocketPath.replace(
+      /^\/private(?=\/(?:tmp|var|etc)\/)/,
+      ""
+    );
+    const key = readKey(
+      join3(
+        this.options.configDir,
+        "sessions",
+        `${session.pid}.${digest(canonicalSocket)}.key`
+      )
+    );
+    return key?.procStart === session.procStart ? key : null;
+  }
+  attempts(version) {
+    const directory = join3(this.options.journalDir, version);
+    mkdirSync2(directory, { recursive: true, mode: 448 });
+    const files = readdirSync2(directory).filter((file) => /^\d{13}-[0-9a-f-]{36}\.json$/.test(file)).sort().reverse();
+    const attempts = files.slice(0, CLAUDE_WAKE.retainedAttempts).map((name) => {
+      const file = join3(directory, name);
+      const value = readObject(file);
+      if (!object(value) || value.version !== CLAUDE_INBOX.journalVersion || typeof value.sessionId !== "string" || typeof value.commandId !== "string" || typeof value.transcript !== "string" || !resolve2(value.transcript).startsWith(
+        resolve2(this.options.configDir, "projects") + "/"
+      ) || typeof value.offset !== "number" || !Number.isSafeInteger(value.offset) || value.offset < 0 || typeof value.accepted !== "boolean" || typeof value.submittedAtMs !== "number" || !Number.isSafeInteger(value.submittedAtMs))
+        throw new Error("Invalid wake receipt");
+      const attempt = {
+        version: value.version,
+        sessionId: value.sessionId,
+        commandId: value.commandId,
+        transcript: value.transcript,
+        offset: value.offset,
+        accepted: value.accepted,
+        submittedAtMs: value.submittedAtMs
+      };
+      if (!attempt.accepted && receiptPresent(attempt)) {
+        const accepted = { ...attempt, accepted: true };
+        writeJsonAtomicDurable(file, accepted, 384);
+        return { file, attempt: accepted };
+      }
+      return { file, attempt };
+    });
+    for (const name of files.slice(CLAUDE_WAKE.retainedAttempts))
+      unlinkSync(join3(directory, name));
+    return attempts;
+  }
+  async wake(sessionId, signal) {
+    const matches = this.sessions().filter(
+      (candidate) => candidate.sessionId === sessionId
+    );
+    const session = matches.length === 1 ? matches[0] : null;
+    if (!session || signal?.aborted) return "wake_not_sent" /* notSent */;
+    try {
+      const attempts = this.attempts(session.version);
+      const decision = claudeWakeDecision({
+        sessionId,
+        idle: session.status === "idle",
+        nowMs: Date.now(),
+        attempts: attempts.map((entry) => entry.attempt)
+      });
+      if (decision) return decision;
+      const key = this.key(session);
+      if (!key) return "wake_not_sent" /* notSent */;
+      const socket = await connectInbox(session.messagingSocketPath);
+      if (!socket) return "wake_not_sent" /* notSent */;
+      if (signal?.aborted || (this.options.processStart ?? processStart)(session.pid) !== session.procStart) {
+        socket.destroy();
+        return "wake_not_sent" /* notSent */;
+      }
+      const commandId = randomUUID();
+      const transcript = transcriptPath(this.options.configDir, session);
+      const attempt = {
+        version: CLAUDE_INBOX.journalVersion,
+        sessionId,
+        commandId,
+        transcript,
+        offset: transcriptSize(transcript),
+        accepted: false,
+        submittedAtMs: Date.now()
+      };
+      const file = join3(
+        this.options.journalDir,
+        session.version,
+        `${attempt.submittedAtMs}-${commandId}.json`
+      );
+      try {
+        createAttempt(file, attempt);
+      } catch {
+        socket.destroy();
+        return "wake_not_sent" /* notSent */;
+      }
+      const frame = {
+        type: "user",
+        session_id: sessionId,
+        uuid: commandId,
+        msg_id: commandId,
+        from: CLAUDE_INBOX.sender,
+        priority: "next",
+        message: { role: "user", content: CLAUDE_WAKE.message }
+      };
+      socket.end(
+        JSON.stringify({ type: "auth", token: key.peerToken }) + "\n" + JSON.stringify(frame) + "\n"
+      );
+      socket.setTimeout(CLAUDE_INBOX.connectTimeoutMs, () => socket.destroy());
+      const outcome = await this.observe(
+        file,
+        attempt,
+        attempt.submittedAtMs + CLAUDE_WAKE.receiptWindowMs
+      );
+      return outcome === "accepted" /* accepted */ ? "wake_accepted" /* accepted */ : "wake_unconfirmed" /* unconfirmed */;
+    } catch {
+      return "wake_not_sent" /* notSent */;
+    }
+  }
+  async observe(file, attempt, expiresAtMs) {
+    const deliveryDeadline = Math.min(
+      expiresAtMs,
+      attempt.submittedAtMs + CLAUDE_INBOX.receiptWindowMs
+    );
+    if (claudeInboxAction({
+      attempted: true,
+      accepted: attempt.accepted,
+      expiresAtMs: deliveryDeadline,
+      nowMs: Date.now()
+    }) === "acknowledge" /* acknowledge */)
+      return "accepted" /* accepted */;
+    const deadline = Math.min(
+      deliveryDeadline,
+      Date.now() + (this.options.receiptWindowMs ?? CLAUDE_INBOX.receiptWindowMs)
+    );
+    do {
+      if (receiptPresent(attempt)) {
+        try {
+          writeJsonAtomicDurable(file, { ...attempt, accepted: true }, 384);
+        } catch {
+          return "unconfirmed" /* unconfirmed */;
+        }
+        return "accepted" /* accepted */;
+      }
+      if (Date.now() >= deadline) break;
+      await delay(this.options.receiptPollMs ?? CLAUDE_INBOX.receiptPollMs);
+    } while (Date.now() <= deadline);
+    return deliveryDeadline <= Date.now() ? "outcome_unknown" /* outcomeUnknown */ : "unconfirmed" /* unconfirmed */;
+  }
+};
+
+// src/claude-inbox-receiver.ts
+var ownsSession = (session) => {
+  const files = [
+    join4(claudeConfigDir(), "settings.json"),
+    join4(session.cwd, ".claude", "settings.json"),
+    join4(session.cwd, ".claude", "settings.local.json")
+  ];
+  const owners = files.map(readHookOwner);
+  return owners.includes("cli") && !owners.includes("app") && !owners.includes(null);
+};
+var startClaudeInboxReceiver = (apiKey, machineId, options = {}) => {
+  const client = options.client ?? new ClaudeInboxClient({
+    configDir: claudeConfigDir(),
+    journalDir: join4(homedir2(), ".pushary", CLAUDE_WAKE.directory)
+  });
+  const baseUrl = options.baseUrl ?? getBaseUrl();
+  const abort = new AbortController();
+  let scanning = false;
+  let cursor = 0;
+  const heartbeats = /* @__PURE__ */ new Map();
+  const post = async (body, path = CLAUDE_WAKE_API) => {
+    const response = await fetch(`${baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.any([
+        abort.signal,
+        AbortSignal.timeout(CLAUDE_INBOX_RECEIVER.requestTimeoutMs)
+      ])
+    });
+    if (!response.ok) throw new Error(`Claude wake HTTP ${response.status}`);
+    return response.json();
+  };
+  const report = async (sessionId, waitingOn) => {
+    await post({
+      operation: "report" /* report */,
+      sessionId,
+      machineId,
+      waitingOn
+    });
+  };
+  const tick = async () => {
+    if (scanning || abort.signal.aborted) return;
+    scanning = true;
+    try {
+      await reconcileCommandReceipts(
+        apiKey,
+        machineId,
+        "claude_code",
+        baseUrl,
+        abort.signal
+      );
+      const sessions = client.sessions().filter(options.ownsSession ?? ownsSession).slice(0, CLAUDE_INBOX_MAX_SESSIONS);
+      if (!sessions.length) return;
+      for (const session of sessions) {
+        if (Date.now() - (heartbeats.get(session.sessionId) ?? 0) < CLAUDE_INBOX_RECEIVER.heartbeatMs)
+          continue;
+        await post(
+          {
+            event: "heartbeat",
+            agentType: "claude_code",
+            agentName: `Claude Code - ${basename2(session.cwd)}`,
+            sessionId: session.sessionId,
+            machineId,
+            cwd: session.cwd,
+            sentAt: (/* @__PURE__ */ new Date()).toISOString(),
+            canDrainCommand: false,
+            skipCommandDrain: true
+          },
+          "/api/agent/event"
+        );
+        heartbeats.set(session.sessionId, Date.now());
+      }
+      const raw = await post({
+        operation: "poll" /* poll */,
+        machineId,
+        sessionIds: sessions.map((session) => session.sessionId)
+      });
+      const pending = parseClaudeInboxPoll(raw);
+      if (!pending) throw new Error("Claude wake protocol mismatch");
+      const rotated = [...pending.slice(cursor), ...pending.slice(0, cursor)];
+      const batch = rotated.slice(0, CLAUDE_INBOX_RECEIVER.maxConcurrent);
+      cursor = pending.length ? (cursor + batch.length) % pending.length : 0;
+      await Promise.all(
+        batch.map(async (sessionId) => {
+          if (!sessions.some((session) => session.sessionId === sessionId) || abort.signal.aborted)
+            return;
+          await report(sessionId, "waking" /* waking */);
+          const outcome = await client.wake(sessionId, abort.signal);
+          await report(sessionId, claudeWakeWaitingOn(outcome));
+        })
+      );
+    } catch (error) {
+      if (!abort.signal.aborted)
+        options.report?.(
+          error instanceof Error ? error.message : "Claude wake failed"
+        );
+    } finally {
+      scanning = false;
+    }
+  };
+  const timer = setInterval(() => {
+    void tick();
+  }, options.pollMs ?? CLAUDE_INBOX_RECEIVER.pollMs);
+  timer.unref();
+  void tick();
+  return () => {
+    abort.abort();
+    clearInterval(timer);
+  };
+};
+
+// src/spawn-daemon.ts
+import { execFileSync as execFileSync2, spawn } from "child_process";
+import { existsSync, statSync as statSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { basename as basename3, dirname as dirname3, join as join5 } from "path";
 
 // src/stop-requests.ts
 var STOP_CAPABILITY = "stop";
@@ -292,13 +1518,13 @@ var resolveSpawnDirectory = (requested, options = {}) => {
   const fallbackDir = options.fallbackDir ?? process.cwd();
   const value = requested?.trim();
   if (!value) return { ok: true, cwd: fallbackDir };
-  const homeDir = options.homeDir ?? homedir();
-  const cwd = value === "~" ? homeDir : value.startsWith("~/") || value.startsWith("~\\") ? join(homeDir, value.slice(2)) : value;
+  const homeDir = options.homeDir ?? homedir3();
+  const cwd = value === "~" ? homeDir : value.startsWith("~/") || value.startsWith("~\\") ? join5(homeDir, value.slice(2)) : value;
   if (!(options.exists ?? existsSync)(cwd)) {
     return { ok: false, message: `Directory does not exist: ${value}` };
   }
   try {
-    if (!(options.isDirectory ?? ((path) => statSync(path).isDirectory()))(cwd)) {
+    if (!(options.isDirectory ?? ((path) => statSync2(path).isDirectory()))(cwd)) {
       return { ok: false, message: `Not a directory: ${value}` };
     }
   } catch {
@@ -390,9 +1616,9 @@ var runSpawnDaemon = async () => {
     describedProviders = description;
   });
   describedProviders = describeLaunchableProviders(inventory.current.capabilities);
-  const siblingEntry = process.argv[1] ? join(dirname(process.argv[1]), "pushary.js") : "";
-  const codexBridgeEntry = process.argv[1] ? join(dirname(process.argv[1]), "pushary-codex-bridge.js") : "pushary-codex-bridge";
-  const geminiBridgeEntry = process.argv[1] ? join(dirname(process.argv[1]), "pushary-gemini-bridge.js") : "pushary-gemini-bridge";
+  const siblingEntry = process.argv[1] ? join5(dirname3(process.argv[1]), "pushary.js") : "";
+  const codexBridgeEntry = process.argv[1] ? join5(dirname3(process.argv[1]), "pushary-codex-bridge.js") : "pushary-codex-bridge";
+  const geminiBridgeEntry = process.argv[1] ? join5(dirname3(process.argv[1]), "pushary-gemini-bridge.js") : "pushary-gemini-bridge";
   const spawnDirect = siblingEntry.length > 0 && existsSync(siblingEntry);
   const existing = readDaemonStatus();
   let handoff;
@@ -492,7 +1718,7 @@ var runSpawnDaemon = async () => {
     if (!plan) {
       return Promise.reject(new Error(FLAG_SHAPED_PROMPT_MESSAGE));
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve3, reject) => {
       try {
         const child = plan.direct ? spawn(plan.command, plan.args, { cwd, detached: true, stdio: "ignore", env }) : spawnClaude(plan.command, plan.args, { cwd, detached: true, stdio: "ignore", env });
         let started = false;
@@ -521,8 +1747,8 @@ var runSpawnDaemon = async () => {
             });
           }
           child.unref();
-          log(`spawn ${req.id}: launched a phone-requested ${plan.agent} session in ${basename(cwd)} (pid ${child.pid ?? "unknown"})`);
-          resolve(typeof child.pid === "number" ? child.pid : null);
+          log(`spawn ${req.id}: launched a phone-requested ${plan.agent} session in ${basename3(cwd)} (pid ${child.pid ?? "unknown"})`);
+          resolve3(typeof child.pid === "number" ? child.pid : null);
         });
       } catch (err) {
         reject(err);
@@ -530,7 +1756,7 @@ var runSpawnDaemon = async () => {
     });
   };
   const kill = process.platform === "win32" ? (pid) => {
-    execFileSync("taskkill", windowsTaskkillArgs(pid), { stdio: "ignore" });
+    execFileSync2("taskkill", windowsTaskkillArgs(pid), { stdio: "ignore" });
   } : process.kill.bind(process);
   const stopDeps = {
     kill: (pid, signal) => {
@@ -542,7 +1768,7 @@ var runSpawnDaemon = async () => {
       return launched || ownsLiveProcess(request);
     },
     selfPid: process.pid,
-    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    sleep: (ms) => new Promise((resolve3) => setTimeout(resolve3, ms)),
     isAlive: (pid) => {
       try {
         process.kill(pid, 0);
@@ -600,7 +1826,7 @@ var runSpawnDaemon = async () => {
           completedStops.delete(acknowledgement.stopId);
           break;
         }
-        if (attempt < 2) await new Promise((resolve) => setTimeout(resolve, 200 * (attempt + 1)));
+        if (attempt < 2) await new Promise((resolve3) => setTimeout(resolve3, 200 * (attempt + 1)));
       }
     }
     async function apply() {
@@ -743,8 +1969,12 @@ var runSpawnDaemon = async () => {
     if (!stopped) timer = setTimeout(tick, jitter(nextDelay()));
   };
   const stopTranscripts = startRegisteredTranscripts(apiKey, machineId);
+  const stopNativeHosts = startNativeHostReceivers(apiKey, machineId, log);
+  const stopClaudeInbox = startClaudeInboxReceiver(apiKey, machineId, { report: log });
   const teardown = () => {
     stopTranscripts();
+    stopClaudeInbox();
+    stopNativeHosts();
     if (stopped) return;
     stopped = true;
     if (timer) clearTimeout(timer);
@@ -767,7 +1997,7 @@ var runSpawnDaemon = async () => {
       return;
     }
     const result = await sendHeartbeat(apiKey, {
-      repoKey: basename(process.cwd()),
+      repoKey: basename3(process.cwd()),
       capabilities: [
         ...launchAdvertisement(inventory.current.capabilities),
         STOP_CAPABILITY,
@@ -799,24 +2029,24 @@ var runSpawnDaemon = async () => {
   log(hasSpawnProvider(inventory.current.capabilities) ? `daemon online (pid ${process.pid}): this machine (${machineId}) can now be sent a new session from your phone. Ctrl-C to stop.` : `daemon online (pid ${process.pid}): no supported Claude, Codex, or Gemini CLI was found, so phone-start is unavailable. Ctrl-C to stop.`);
   timer = setTimeout(tick, 0);
   const signals = daemonSignals();
-  await new Promise((resolve) => {
+  await new Promise((resolve3) => {
     const onSignal = () => finish();
     for (const signal of signals) process.on(signal, onSignal);
     finish = () => {
       teardown();
       for (const signal of signals) process.off(signal, onSignal);
-      resolve();
+      resolve3();
     };
   });
   return 0;
 };
 
 // src/daemon-sessions.ts
-import { execFileSync as execFileSync2 } from "child_process";
+import { execFileSync as execFileSync3 } from "child_process";
 var readResidentSetKb = (pid) => {
   if (process.platform === "win32") return null;
   try {
-    const output = execFileSync2("ps", ["-o", "rss=", "-p", String(pid)], {
+    const output = execFileSync3("ps", ["-o", "rss=", "-p", String(pid)], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     });