@pushary/agent-hooks 0.43.0 → 0.48.0

package/dist/bin/pushary-claude.js

@@ -10,9 +10,10 @@ import {
   fetchModeState,
   getMachineId,
   getPolicy,
+  reportEvent,
   resolvePolicy,
   waitForAnswer
-} from "../chunk-ETDXSKR5.js";
+} from "../chunk-VZNP4R5I.js";
 import "../chunk-DWED7BS3.js";
 import "../chunk-Z5PL3K7C.js";
 import {
@@ -100,7 +101,7 @@ var runLocalPassthrough = (binary, args2) => {
   });
 };
 
-// src/wrapper/remoteMode.ts
+// src/wrapper/dualMode.ts
 import { basename } from "path";
 
 // src/wrapper/sdkLoader.ts
@@ -150,7 +151,7 @@ var ensureClaudeSdk = async (log) => {
   } catch {
     return null;
   }
-  log?.("[pushary] setting up remote mode (one-time, fetching the Claude Agent SDK)...");
+  log?.("[pushary] setting up phone control (one-time, fetching the Claude Agent SDK)...");
   const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
   const installed = await new Promise((resolve) => {
     const child = spawn2(
@@ -224,6 +225,12 @@ var BoundedInputQueue = class {
       resolve({ value: void 0, done: true });
     }
   }
+  // Drop every buffered item without closing the queue. Used when phone control
+  // turns out to be unavailable (offline SDK setup) so a pending instruction does
+  // not make the local leg switch again into a mode that cannot run.
+  clear() {
+    this.buffer.length = 0;
+  }
   get isClosed() {
     return this.closed;
   }
@@ -329,6 +336,7 @@ var createRemoteApprover = (deps) => {
     }
     const controller = new AbortController();
     const entry = { controller };
+    let answered = false;
     pending.add(entry);
     const outerAbort = () => controller.abort();
     if (options?.signal) {
@@ -365,6 +373,7 @@ var createRemoteApprover = (deps) => {
       entry.correlationId = question.correlationId;
       if (question.noDevices) return applyTimeout(policy, input);
       const answer = await waitForPhone(entry, question.correlationId, windowFor(policy));
+      answered = answer.answered;
       if (answer.answered) {
         if (isDeferAnswer(answer.value)) return deny("Deferred \u2014 handle it on the machine");
         return answer.value === "yes" ? allow(input) : deny("Denied from your phone");
@@ -374,6 +383,10 @@ var createRemoteApprover = (deps) => {
       return deny("Approval unavailable; denied by default");
     } finally {
       if (options?.signal) options.signal.removeEventListener("abort", outerAbort);
+      if (entry.correlationId && !answered && !tornDown) {
+        void cancelQuestion2(deps.apiKey, entry.correlationId).catch(() => {
+        });
+      }
       pending.delete(entry);
     }
   };
@@ -464,10 +477,23 @@ var startCommandPoller = (opts) => {
     const timeout = setTimeout(() => controller.abort(), requestTimeout);
     try {
       const wantCommands = opts.shouldDrainCommands ? opts.shouldDrainCommands() : true;
-      const [command] = await Promise.all([
-        wantCommands ? drain(opts.apiKey, opts.getSessionId?.(), controller.signal) : Promise.resolve(null),
-        fetchMode()
-      ]);
+      let command;
+      if (opts.poll) {
+        const result = await opts.poll(opts.apiKey, opts.getSessionId?.(), wantCommands, controller.signal);
+        command = result.command;
+        if (result.mode && opts.onModeState) {
+          try {
+            opts.onModeState(result.mode);
+          } catch {
+          }
+        }
+      } else {
+        ;
+        [command] = await Promise.all([
+          wantCommands ? drain(opts.apiKey, opts.getSessionId?.(), controller.signal) : Promise.resolve(null),
+          fetchMode()
+        ]);
+      }
       errorStreak = 0;
       if (command) {
         idleTicks = 0;
@@ -498,19 +524,39 @@ var startCommandPoller = (opts) => {
   };
 };
 
+// src/wrapper/pollClient.ts
+var APPROVAL_MODES = /* @__PURE__ */ new Set(["push_only", "terminal_only", "push_first", "notify_only"]);
+var pollAgent = async (apiKey, sessionId, wantCommand, signal, baseUrl = getBaseUrl()) => {
+  try {
+    const response = await fetch(`${baseUrl}/api/agent/poll`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
+      body: JSON.stringify({
+        ...sessionId ? { sessionId } : {},
+        ...wantCommand ? {} : { drain: false }
+      }),
+      signal
+    });
+    if (!response.ok) return { command: null, mode: null };
+    const data = await response.json();
+    const command = typeof data.command === "string" && data.command.length > 0 ? data.command : null;
+    const m = data.override?.mode;
+    const mode = {
+      mode: typeof m === "string" && APPROVAL_MODES.has(m) ? m : null,
+      kill: data.kill === true,
+      policyVersion: typeof data.policyVersion === "string" && data.policyVersion.length > 0 ? data.policyVersion : null,
+      relayUrl: typeof data.relayUrl === "string" && data.relayUrl.length > 0 ? data.relayUrl : null
+    };
+    return { command, mode };
+  } catch {
+    return { command: null, mode: null };
+  }
+};
+
 // src/wrapper/wsProtocol.ts
 var PROTOCOL_VERSION = 1;
-var TRANSCRIPT_TEXT_MAX = 4e3;
 var encodeFrame = (frame) => JSON.stringify(frame);
 var helloFrame = (fields) => ({ v: PROTOCOL_VERSION, t: "hello", ...fields });
-var transcriptFrame = (seq, kind, text, meta) => ({
-  v: PROTOCOL_VERSION,
-  t: "transcript",
-  seq,
-  kind,
-  ...text !== void 0 ? { text: text.slice(0, TRANSCRIPT_TEXT_MAX) } : {},
-  ...meta ? { meta } : {}
-});
 var parse = (raw) => {
   try {
     const value = JSON.parse(raw);
@@ -523,21 +569,18 @@ var parse = (raw) => {
   }
 };
 var isString = (v) => typeof v === "string";
-var isFiniteNumber = (v) => typeof v === "number" && Number.isFinite(v);
 var decodeServerFrame = (raw) => {
   const f = parse(raw);
   if (!f) return null;
   switch (f.t) {
     case "welcome":
-      return isFiniteNumber(f.resumeFromSeq) ? { v: PROTOCOL_VERSION, t: "welcome", resumeFromSeq: f.resumeFromSeq } : null;
+      return { v: PROTOCOL_VERSION, t: "welcome" };
     case "ping":
       return { v: PROTOCOL_VERSION, t: "ping" };
     case "pong":
       return { v: PROTOCOL_VERSION, t: "pong" };
     case "command":
       return isString(f.id) && isString(f.text) ? { v: PROTOCOL_VERSION, t: "command", id: f.id, text: f.text } : null;
-    case "resume":
-      return isFiniteNumber(f.afterSeq) ? { v: PROTOCOL_VERSION, t: "resume", afterSeq: f.afterSeq } : null;
     case "error":
       if (isString(f.code) && isString(f.message)) {
         return { v: PROTOCOL_VERSION, t: "error", code: f.code, message: f.message, fatal: f.fatal === true };
@@ -551,7 +594,6 @@ var decodeServerFrame = (raw) => {
 // src/wrapper/relayClient.ts
 var DEFAULT_HEARTBEAT_MS = 2e4;
 var DEFAULT_PONG_TIMEOUT_MS = 1e4;
-var DEFAULT_MAX_OUTBOUND = 128;
 var DEFAULT_MAX_SEEN_COMMANDS = 256;
 var defaultBackoff = (attempt) => Math.min(1e3 * 2 ** attempt, 3e4);
 var defaultSocketFactory = (url) => {
@@ -572,17 +614,14 @@ var createRelayClient = (options) => {
   const heartbeatMs = options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS;
   const pongTimeoutMs = options.pongTimeoutMs ?? DEFAULT_PONG_TIMEOUT_MS;
   const backoff = options.backoffMs ?? defaultBackoff;
-  const maxOutbound = Math.max(1, options.maxOutbound ?? DEFAULT_MAX_OUTBOUND);
   const maxSeenCommands = Math.max(1, options.maxSeenCommands ?? DEFAULT_MAX_SEEN_COMMANDS);
   let socket;
   let isConnected = false;
   let stopped = false;
-  let seq = 0;
   let attempt = 0;
   let reconnectTimer;
   let heartbeatTimer;
   let pongTimer;
-  const outbound = [];
   const seenCommands = [];
   const seenSet = /* @__PURE__ */ new Set();
   const log = (message) => options.log?.(message);
@@ -611,20 +650,14 @@ var createRelayClient = (options) => {
     } catch {
     }
   };
-  const enqueueTranscript = (frame) => {
-    if (isConnected) {
-      sendFrame(frame);
-      return;
-    }
-    outbound.push(frame);
-    while (outbound.length > maxOutbound) outbound.shift();
-  };
-  const flushOutbound = () => {
-    while (outbound.length > 0 && isConnected) {
-      const frame = outbound.shift();
-      if (frame) sendFrame(frame);
-    }
-  };
+  const sendHello = () => sendFrame(
+    helloFrame({
+      apiKey: options.apiKey,
+      machineId: options.machineId,
+      agentType: options.agentType,
+      sessionId: options.getSessionId()
+    })
+  );
   const armPong = () => {
     if (pongTimer) clearTimeout(pongTimer);
     pongTimer = setTimeout(() => {
@@ -645,7 +678,6 @@ var createRelayClient = (options) => {
     switch (frame.t) {
       case "welcome":
         attempt = 0;
-        flushOutbound();
         log("[pushary] relay connected");
         break;
       case "command":
@@ -664,9 +696,6 @@ var createRelayClient = (options) => {
         if (pongTimer) clearTimeout(pongTimer);
         pongTimer = void 0;
         break;
-      case "resume":
-        log(`[pushary] relay signalled a gap; catch up after seq ${frame.afterSeq}`);
-        break;
       case "error":
         if (frame.fatal) {
           log(`[pushary] relay fatal: ${frame.message}`);
@@ -724,15 +753,7 @@ var createRelayClient = (options) => {
     socket = created;
     created.onOpen(() => {
       isConnected = true;
-      sendFrame(
-        helloFrame({
-          apiKey: options.apiKey,
-          machineId: options.machineId,
-          agentType: options.agentType,
-          sessionId: options.getSessionId(),
-          lastSeq: seq
-        })
-      );
+      sendHello();
       startHeartbeat();
     });
     created.onMessage((data) => onServerFrame(data));
@@ -751,22 +772,9 @@ var createRelayClient = (options) => {
     connected() {
       return isConnected;
     },
-    sendTranscript(kind, text, meta) {
-      if (stopped) return;
-      seq++;
-      enqueueTranscript(transcriptFrame(seq, kind, text, meta));
-    },
     reannounce() {
       if (stopped || !isConnected) return;
-      sendFrame(
-        helloFrame({
-          apiKey: options.apiKey,
-          machineId: options.machineId,
-          agentType: options.agentType,
-          sessionId: options.getSessionId(),
-          lastSeq: seq
-        })
-      );
+      sendHello();
     },
     stop() {
       if (stopped) return;
@@ -778,6 +786,166 @@ var createRelayClient = (options) => {
   };
 };
 
+// src/wrapper/stdinHandoff.ts
+var isTty = () => Boolean(process.stdin.isTTY);
+var createStdinHandoff = () => {
+  let listener;
+  let captured = false;
+  const removeListener = () => {
+    if (listener) {
+      process.stdin.off("data", listener);
+      listener = void 0;
+    }
+  };
+  const setRaw = (on) => {
+    if (!isTty()) return;
+    try {
+      process.stdin.setRawMode(on);
+    } catch {
+    }
+  };
+  const captureForWrapper = (onKey) => {
+    removeListener();
+    listener = onKey;
+    if (!isTty()) return;
+    try {
+      process.stdin.resume();
+      setRaw(true);
+      process.stdin.setEncoding("utf8");
+      process.stdin.on("data", listener);
+      captured = true;
+    } catch {
+      removeListener();
+    }
+  };
+  const releaseToChild = () => {
+    removeListener();
+    setRaw(false);
+    if (captured && isTty()) {
+      try {
+        process.stdin.pause();
+      } catch {
+      }
+    }
+    captured = false;
+  };
+  return {
+    captureForWrapper,
+    releaseToChild,
+    dispose: releaseToChild
+  };
+};
+
+// src/wrapper/args.ts
+var resolveClaudeArgs = (argv) => {
+  const rest = argv.slice(2);
+  return rest[0] === "claude" ? rest.slice(1) : rest;
+};
+var extractRemoteFlag = (args2) => ({
+  remote: args2.includes("--remote"),
+  rest: args2.filter((arg) => arg !== "--remote")
+});
+var flagValue = (args2, index) => {
+  const inline = args2[index];
+  const eq = inline?.indexOf("=") ?? -1;
+  if (inline && eq > 0) return inline.slice(eq + 1);
+  const next = args2[index + 1];
+  return next && !next.startsWith("-") ? next : void 0;
+};
+var parseRemoteArgs = (args2) => {
+  let initialPrompt;
+  let resume;
+  let permissionMode;
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "-p" || arg === "--print" || arg?.startsWith("--print=")) {
+      initialPrompt = flagValue(args2, i);
+    } else if (arg === "-r" || arg === "--resume" || arg?.startsWith("--resume=")) {
+      resume = flagValue(args2, i);
+    } else if (arg === "--permission-mode" || arg?.startsWith("--permission-mode=")) {
+      permissionMode = flagValue(args2, i);
+    }
+  }
+  return { initialPrompt, resume, permissionMode };
+};
+
+// src/wrapper/localLeg.ts
+var SIGNAL_EXIT_BASE = 128;
+var SIGNAL_NUMBERS2 = { SIGHUP: 1, SIGINT: 2, SIGTERM: 15 };
+var nativeArgs = (session) => {
+  const args2 = [...session.claudeArgs];
+  const id = session.getSessionId();
+  if (id && !session.userManagesSession) {
+    args2.push(session.isSessionCreated() ? "--resume" : "--session-id", id);
+  }
+  return args2;
+};
+var runLocalLeg = (session, deps = {}) => {
+  const spawn3 = deps.spawn ?? spawnClaude;
+  return new Promise((resolve) => {
+    const legAbort = new AbortController();
+    let exitReason = null;
+    let settled = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      session.setActiveLeg(null);
+      resolve(exitReason ?? { type: "exit", code: 0 });
+    };
+    const control = {
+      onPhoneCommand: () => {
+        if (!exitReason) exitReason = "switch";
+        if (!legAbort.signal.aborted) legAbort.abort();
+      },
+      stop: (reason) => {
+        if (!exitReason) exitReason = { type: "exit", code: reason === "signal" ? 130 : 0 };
+        if (!legAbort.signal.aborted) legAbort.abort();
+      }
+    };
+    session.setActiveLeg(control);
+    if (session.input.bufferedCount > 0) {
+      exitReason = "switch";
+      finish();
+      return;
+    }
+    session.stdin.releaseToChild();
+    let child;
+    try {
+      child = spawn3(session.binary, nativeArgs(session), {
+        stdio: "inherit",
+        env: { ...process.env, [WRAPPER_ACTIVE_ENV]: "1" },
+        signal: legAbort.signal
+      });
+    } catch {
+      exitReason = exitReason ?? { type: "exit", code: 127 };
+      finish();
+      return;
+    }
+    session.markSessionCreated();
+    child.on("error", () => {
+      if (!legAbort.signal.aborted && !exitReason) {
+        exitReason = { type: "exit", code: 127 };
+      }
+      finish();
+    });
+    child.on("exit", (code, signal) => {
+      if (signal === "SIGTERM" && legAbort.signal.aborted) {
+      } else if (!exitReason) {
+        if (session.input.bufferedCount > 0) {
+          exitReason = "switch";
+        } else if (typeof code === "number") {
+          exitReason = { type: "exit", code };
+        } else if (signal) {
+          exitReason = { type: "exit", code: SIGNAL_EXIT_BASE + (SIGNAL_NUMBERS2[signal] ?? 0) };
+        } else {
+          exitReason = { type: "exit", code: 0 };
+        }
+      }
+      finish();
+    });
+  });
+};
+
 // src/wrapper/remoteLoop.ts
 var errMsg = (err) => err instanceof Error ? err.message : String(err);
 var DEFAULT_MAX_RESTARTS = 5;
@@ -845,41 +1013,89 @@ var runRemoteLoop = async (deps) => {
   return { exitCode: 130, totalCostUsd: totalCost };
 };
 
-// src/wrapper/args.ts
-var resolveClaudeArgs = (argv) => {
-  const rest = argv.slice(2);
-  return rest[0] === "claude" ? rest.slice(1) : rest;
-};
-var extractRemoteFlag = (args2) => ({
-  remote: args2.includes("--remote"),
-  rest: args2.filter((arg) => arg !== "--remote")
-});
-var flagValue = (args2, index) => {
-  const inline = args2[index];
-  const eq = inline?.indexOf("=") ?? -1;
-  if (inline && eq > 0) return inline.slice(eq + 1);
-  const next = args2[index + 1];
-  return next && !next.startsWith("-") ? next : void 0;
+// src/wrapper/remoteLeg.ts
+var CTRL_RIGHT_BRACKET = "";
+var CTRL_C = "";
+var runRemoteLeg = async (session, sdk) => {
+  const legAbort = new AbortController();
+  let switchBack = false;
+  const control = {
+    // The running query already drains the shared input queue, so a freshly pushed
+    // phone command is delivered without any action here.
+    onPhoneCommand: () => {
+    },
+    stop: () => {
+      if (!legAbort.signal.aborted) legAbort.abort();
+    }
+  };
+  session.setActiveLeg(control);
+  session.stdin.captureForWrapper((data) => {
+    if (data.includes(CTRL_RIGHT_BRACKET)) {
+      switchBack = true;
+      if (!legAbort.signal.aborted) legAbort.abort();
+    } else if (data.includes(CTRL_C)) {
+      if (!legAbort.signal.aborted) legAbort.abort();
+    }
+  });
+  process.stderr.write(
+    "[pushary] remote \u2014 driving from your phone \xB7 press Ctrl-] for the local terminal\n"
+  );
+  let exitCode = 0;
+  try {
+    const result = await runRemoteLoop({
+      sdk,
+      input: session.input,
+      canUseTool: session.approver.canUseTool,
+      signal: legAbort.signal,
+      // Resume the session the local leg (or a prior turn) created, so the
+      // conversation is continuous across the switch. Undefined = fresh session.
+      initialResume: session.getSessionId(),
+      permissionMode: session.permissionMode,
+      // The SDK REPLACES the subprocess env; spread process.env and mark the
+      // recursion guard so a wrapper-spawned claude cannot re-enter the wrapper.
+      env: { ...process.env, [WRAPPER_ACTIVE_ENV]: "1" },
+      cwd: process.cwd(),
+      // Run the user's OWN claude (auth + version parity); Windows .cmd shims keep
+      // the SDK's bundled binary since the SDK cannot spawn a shim directly.
+      pathToClaudeCodeExecutable: needsShell(session.binary) ? void 0 : session.binary,
+      onSessionId: (id) => session.setSessionId(id),
+      onMessage: (message) => session.streamMessage(message),
+      log: (message) => process.stderr.write(`${message}
+`)
+    });
+    exitCode = result.exitCode;
+  } finally {
+    session.stdin.releaseToChild();
+    session.setActiveLeg(null);
+  }
+  return switchBack ? "switch" : { type: "exit", code: exitCode };
 };
-var parseRemoteArgs = (args2) => {
-  let initialPrompt;
-  let resume;
-  let permissionMode;
-  for (let i = 0; i < args2.length; i++) {
-    const arg = args2[i];
-    if (arg === "-p" || arg === "--print" || arg?.startsWith("--print=")) {
-      initialPrompt = flagValue(args2, i);
-    } else if (arg === "-r" || arg === "--resume" || arg?.startsWith("--resume=")) {
-      resume = flagValue(args2, i);
-    } else if (arg === "--permission-mode" || arg?.startsWith("--permission-mode=")) {
-      permissionMode = flagValue(args2, i);
+
+// src/wrapper/modeLoop.ts
+var DEFAULT_MIN_DWELL_MS = 300;
+var driveModeLoop = async (deps) => {
+  const sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const now = deps.now ?? (() => Date.now());
+  const minDwell = deps.minDwellMs ?? DEFAULT_MIN_DWELL_MS;
+  let mode = deps.startingMode;
+  let lastSwitchAt = 0;
+  while (true) {
+    const result = mode === "local" ? await deps.runLocal() : await deps.runRemote();
+    if (result !== "switch" || deps.isFinished()) {
+      return result === "switch" ? 0 : result.code;
     }
+    const since = now() - lastSwitchAt;
+    if (since < minDwell) await sleep(minDwell - since);
+    lastSwitchAt = now();
+    mode = mode === "local" ? "remote" : "local";
   }
-  return { initialPrompt, resume, permissionMode };
 };
 
-// src/wrapper/remoteMode.ts
+// src/wrapper/dualMode.ts
 var INPUT_QUEUE_CAP = 32;
+var MIN_MODE_DWELL_MS = 300;
+var RELAY_FALLBACK_POLL_MS = 6e4;
+var SESSION_FLAG_RE = /^(-r|--resume|-c|--continue|--session-id)(=.*)?$/;
 var extractAssistantText = (message) => {
   const content = message.message?.content;
   if (typeof content === "string") return content || void 0;
@@ -889,54 +1105,50 @@ var extractAssistantText = (message) => {
   }
   return void 0;
 };
-var echoLocal = (message) => {
-  if (message.type === "assistant") {
-    const text = extractAssistantText(message);
-    if (text) process.stdout.write(`${text}
-`);
-  } else if (message.type === "result") {
-    process.stderr.write("[pushary] turn complete \u2014 standing by for phone commands (Ctrl-C to exit)\n");
-  }
-};
-var streamTranscript = (relay, message) => {
-  if (message.type === "assistant") {
-    const text = extractAssistantText(message);
-    if (text) relay.sendTranscript("assistant", text);
-  } else if (message.type === "result") {
-    relay.sendTranscript(
-      "turn_end",
-      void 0,
-      typeof message.total_cost_usd === "number" ? { cost: message.total_cost_usd } : void 0
-    );
-  }
-};
-var runRemoteMode = async (binary, args2) => {
+var runDualMode = async (binary, args2, startingMode) => {
   let apiKey;
   try {
     apiKey = getApiKey();
   } catch {
     process.stderr.write(
-      "[pushary] remote mode needs an API key. Run `npx @pushary/agent-hooks setup`. Running the normal passthrough for now.\n"
+      "[pushary] phone control needs an API key. Run `npx @pushary/agent-hooks setup`. Running the normal passthrough for now.\n"
     );
     return { implemented: false };
   }
-  const sdk = await ensureClaudeSdk((message) => process.stderr.write(`${message}
+  let sdk;
+  let remoteAvailable = true;
+  let noticedUnavailable = false;
+  const ensureSdk = async () => {
+    if (sdk === void 0) {
+      sdk = await ensureClaudeSdk((message) => process.stderr.write(`${message}
 `));
-  if (!sdk) {
-    process.stderr.write("[pushary] remote mode is unavailable; running the normal passthrough.\n");
+      if (!sdk) remoteAvailable = false;
+    }
+    return sdk;
+  };
+  if (startingMode === "remote" && !await ensureSdk()) {
+    process.stderr.write("[pushary] phone control is unavailable; running the normal passthrough.\n");
     return { implemented: false };
   }
   const projectName = basename(process.cwd());
+  const agentName = `Claude Code - ${projectName}`;
   const machineId = getMachineId();
-  const controller = new AbortController();
-  let sessionId;
-  let killed = false;
+  const stdin = createStdinHandoff();
+  const { initialPrompt, resume, permissionMode } = parseRemoteArgs(args2);
+  const userManagesSession = args2.some((a) => SESSION_FLAG_RE.test(a));
+  let sessionId = resume;
+  let sessionCreated = Boolean(resume);
+  if (!sessionId && startingMode === "local" && !userManagesSession) {
+    sessionId = crypto.randomUUID();
+  }
   let totalCostUsd = 0;
+  let killed = false;
+  let finished = false;
+  let activeLeg = null;
   const input = new BoundedInputQueue({
     cap: INPUT_QUEUE_CAP,
     onDrop: (_dropped, total) => process.stderr.write(`[pushary] input queue full; dropped ${total} stale instruction(s)
 `),
-    // Several instructions that piled up between turns are sent as one turn.
     coalesce: (items) => userMessage(items.map((m) => m.message.content).join("\n\n"))
   });
   const approver = createRemoteApprover({
@@ -945,16 +1157,17 @@ var runRemoteMode = async (binary, args2) => {
     projectName,
     getSessionId: () => sessionId
   });
-  const initialMode = await fetchModeState(apiKey).catch(() => null);
+  const initialModeState = await fetchModeState(apiKey).catch(() => null);
+  const relayAdvertised = Boolean(initialModeState?.relayUrl);
   let relay;
-  if (initialMode?.relayUrl) {
+  if (initialModeState?.relayUrl) {
     relay = createRelayClient({
-      url: initialMode.relayUrl,
+      url: initialModeState.relayUrl,
       apiKey,
       machineId,
       agentType: "claude_code",
       getSessionId: () => sessionId,
-      onCommand: (command) => input.push(userMessage(command)),
+      onCommand: (command) => onPhoneCommand(command),
       onFatal: (message) => process.stderr.write(`[pushary] relay unavailable (${message}); using polling
 `),
       log: (message) => process.stderr.write(`${message}
@@ -962,81 +1175,144 @@ var runRemoteMode = async (binary, args2) => {
     });
     relay.start();
   }
+  const announcePresence = (event, action) => {
+    if (!sessionId) return Promise.resolve();
+    return reportEvent(
+      { event, agentType: "claude_code", agentName, action, sessionId, machineId },
+      { maxAttempts: 2, timeoutMs: 4e3 }
+    ).then(() => {
+    }).catch(() => {
+    });
+  };
+  const setSessionId = (id) => {
+    const isNew = sessionId !== id;
+    sessionId = id;
+    sessionCreated = true;
+    relay?.reannounce();
+    if (isNew) void announcePresence("session_start", "Remote session ready \u2014 reachable from your phone");
+  };
+  const onPhoneCommand = (command) => {
+    if (!remoteAvailable) {
+      if (!noticedUnavailable) {
+        noticedUnavailable = true;
+        process.stderr.write("[pushary] phone control is unavailable this run; the instruction was not delivered.\n");
+      }
+      return;
+    }
+    input.push(userMessage(command));
+    activeLeg?.onPhoneCommand();
+  };
+  const streamMessage = (message) => {
+    if (message.type === "assistant") {
+      const text = extractAssistantText(message);
+      if (text) process.stdout.write(`${text}
+`);
+    } else if (message.type === "result") {
+      if (typeof message.total_cost_usd === "number") totalCostUsd = message.total_cost_usd;
+      process.stderr.write("[pushary] turn complete \u2014 standing by for phone commands\n");
+    }
+  };
   const poller = startCommandPoller({
     apiKey,
     getSessionId: () => sessionId,
-    onCommand: (command) => input.push(userMessage(command)),
-    // While the relay socket owns command delivery, the poller must not also drain
-    // the single-use queue (that would deliver the command twice); it still reads
-    // mode/kill. When the socket is down or absent, the poller is the source.
+    onCommand: (command) => onPhoneCommand(command),
     shouldDrainCommands: () => !(relay?.connected() ?? false),
-    // Watch the kill switch: a phone "stop" interrupts the running turn (via the
-    // controller abort below), instead of only denying the next tool call.
+    // Unified poll: one request per tick for both command + mode/kill (half the
+    // requests and the per-poll DB write of the old drain + mode pair).
+    poll: pollAgent,
     fetchModeState,
+    // Relay-primary: idle the safety-net poll at 60s (see RELAY_FALLBACK_POLL_MS).
+    // No relay advertised -> the poller IS the command path, so keep the default.
+    slowPollMs: relayAdvertised ? RELAY_FALLBACK_POLL_MS : void 0,
     onModeState: (state) => {
       if (state.kill && !killed) {
         killed = true;
+        finished = true;
         process.stderr.write("[pushary] halted from Pushary \u2014 stopping the agent\n");
-        controller.abort();
+        activeLeg?.stop("kill");
       }
     },
     log: (message) => process.stderr.write(`${message}
 `)
   });
   const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
-  const onSignal = () => controller.abort();
+  const onSignal = () => {
+    finished = true;
+    activeLeg?.stop("signal");
+  };
   for (const signal of signals) process.on(signal, onSignal);
-  const { initialPrompt, resume, permissionMode } = parseRemoteArgs(args2);
+  const restoreStdin = () => stdin.dispose();
+  process.once("exit", restoreStdin);
+  const session = {
+    apiKey,
+    machineId,
+    projectName,
+    agentName,
+    binary,
+    input,
+    approver,
+    stdin,
+    claudeArgs: args2,
+    permissionMode,
+    userManagesSession,
+    getSessionId: () => sessionId,
+    setSessionId,
+    isSessionCreated: () => sessionCreated,
+    markSessionCreated: () => {
+      sessionCreated = true;
+    },
+    relayConnected: () => relay?.connected() ?? false,
+    streamMessage,
+    setActiveLeg: (control) => {
+      activeLeg = control;
+    }
+  };
   try {
-    if (initialPrompt) input.push(userMessage(initialPrompt));
-    const result = await runRemoteLoop({
-      sdk,
-      input,
-      canUseTool: approver.canUseTool,
-      signal: controller.signal,
-      permissionMode,
-      initialResume: resume,
-      // The SDK REPLACES the subprocess env, so spread process.env and set the
-      // recursion guard so a wrapper-spawned claude cannot re-enter the wrapper.
-      env: { ...process.env, [WRAPPER_ACTIVE_ENV]: "1" },
-      cwd: process.cwd(),
-      // Run the user's OWN claude, not the SDK's bundled copy, so whatever login
-      // already works for `claude` works here with no extra setup. On Windows a
-      // `.cmd`/`.bat` shim can't be spawned directly by the SDK, so there we let
-      // the SDK use its bundled binary (Windows reads creds from a plain file, so
-      // there is no keychain-ACL mismatch to work around).
-      pathToClaudeCodeExecutable: needsShell(binary) ? void 0 : binary,
-      onSessionId: (id) => {
-        sessionId = id;
-        relay?.reannounce();
-      },
-      onCost: (usd) => {
-        totalCostUsd = usd;
-      },
-      // Always echo the turn to the local terminal; also stream a bounded live
-      // transcript to the phone when the relay is up (it presence-gates it).
-      onMessage: (message) => {
-        echoLocal(message);
-        if (relay) streamTranscript(relay, message);
+    if (sessionId && startingMode === "local") {
+      void announcePresence("session_start", "Session ready \u2014 reachable from your phone");
+    }
+    if (startingMode === "remote" && initialPrompt) input.push(userMessage(initialPrompt));
+    const exitCode = await driveModeLoop({
+      startingMode,
+      runLocal: () => runLocalLeg(session),
+      runRemote: async () => {
+        const ready = await ensureSdk();
+        if (!ready) {
+          remoteAvailable = false;
+          input.clear();
+          if (!noticedUnavailable) {
+            noticedUnavailable = true;
+            process.stderr.write(
+              "[pushary] could not start phone control (offline?); staying in the terminal. Relaunch when online to enable.\n"
+            );
+          }
+          return "switch";
+        }
+        return runRemoteLeg(session, ready);
       },
-      log: (message) => process.stderr.write(`${message}
-`)
+      isFinished: () => finished,
+      minDwellMs: MIN_MODE_DWELL_MS
     });
-    return { implemented: true, exitCode: result.exitCode };
+    return { implemented: true, exitCode };
   } finally {
     for (const signal of signals) process.off(signal, onSignal);
+    process.removeListener("exit", restoreStdin);
     relay?.stop();
     poller.stop();
     approver.teardown();
     input.close();
+    stdin.dispose();
+    await announcePresence("session_closed", "Session ended");
     if (totalCostUsd > 0) {
-      process.stderr.write(`[pushary] remote session cost: $${totalCostUsd.toFixed(4)}
+      process.stderr.write(`[pushary] session cost: $${totalCostUsd.toFixed(4)}
 `);
     }
   }
 };
 
 // src/wrapper/runClaudeWrapper.ts
+var hasPrintFlag = (args2) => args2.some((a) => a === "-p" || a === "--print" || a.startsWith("--print="));
+var isInteractiveTty = () => Boolean(process.stdin.isTTY && process.stdout.isTTY);
 var runClaudeWrapper = async (args2) => {
   const binary = findClaudeBinary();
   if (!binary) {
@@ -1047,10 +1323,11 @@ var runClaudeWrapper = async (args2) => {
   }
   const nested = process.env[WRAPPER_ACTIVE_ENV] === "1";
   const { remote: wantRemote, rest } = extractRemoteFlag(args2);
-  if (!nested && wantRemote) {
+  const useDual = !nested && (wantRemote || isInteractiveTty() && !hasPrintFlag(rest));
+  if (useDual) {
     try {
-      const remote = await runRemoteMode(binary, rest);
-      if (remote.implemented) return remote.exitCode ?? 0;
+      const result = await runDualMode(binary, rest, wantRemote ? "remote" : "local");
+      if (result.implemented) return result.exitCode ?? 0;
     } catch {
     }
   }