@pushary/agent-hooks 0.94.0 → 0.95.1

package/dist/bin/pushary-claude.js

@@ -1,47 +1,52 @@
 #!/usr/bin/env node
 import {
-  changedRecipientsMessage,
-  loadPin,
-  savePin,
-  verifyRecipients
-} from "../chunk-YKLCWWEI.js";
-import {
-  ensureDaemonRunning
-} from "../chunk-ZTJF6ANY.js";
-import {
-  buildTranscriptRecords,
-  decodePublicKey,
-  generateSessionKey,
-  wrapSessionKey
-} from "../chunk-46P3VES5.js";
-import {
-  fetchTranscriptRecipients,
-  uploadTranscriptRecords
-} from "../chunk-EQRS3SGM.js";
-import {
-  transcriptsEnabled
-} from "../chunk-6WYL3XIP.js";
+  WRAPPER_ACTIVE_ENV,
+  findClaudeBinary
+} from "../chunk-PQ4K74WL.js";
 import {
   SESSION_IDLE_TIMEOUT_MS,
   describeIdleWindow,
   startProcessOwnership,
   withSpawnProcessOwnership
-} from "../chunk-TDUTNYAQ.js";
+} from "../chunk-M64I4T7J.js";
+import {
+  isDeferAnswer
+} from "../chunk-YHG74UFF.js";
+import {
+  claudeTranscriptPath,
+  loadSessionKey,
+  registerTranscript,
+  registeredTranscriptEnabled
+} from "../chunk-CC625NRG.js";
+import "../chunk-YKLCWWEI.js";
+import "../chunk-ZW3KAWTM.js";
+import "../chunk-77U3ZVV6.js";
+import "../chunk-IFCS6LXB.js";
+import {
+  ensureDaemonRunning
+} from "../chunk-CU5KI425.js";
+import "../chunk-BWNU4MX4.js";
+import "../chunk-DSTLA2TC.js";
+import "../chunk-EZIEXHYM.js";
+import {
+  encryptRecord
+} from "../chunk-UFGDCMUD.js";
+import "../chunk-EQRS3SGM.js";
+import {
+  transcriptsEnabled
+} from "../chunk-ZOR5OJZJ.js";
 import {
   needsShell,
   spawnClaude
 } from "../chunk-XHKBHWLX.js";
 import "../chunk-L4ZCFMWW.js";
-import {
-  isDeferAnswer
-} from "../chunk-YHG74UFF.js";
 import {
   fetchModeState,
   getPolicy,
   phoneDrivenEnv,
   repoKeyFor,
   reportEvent
-} from "../chunk-5HGLZGI4.js";
+} from "../chunk-J55K6YS4.js";
 import {
   DEFAULT_SESSION,
   askUser,
@@ -59,20 +64,21 @@ import {
   deriveToolTarget,
   describeToolCall,
   scopePathFor
-} from "../chunk-4PE2SQVM.js";
-import "../chunk-Y3UGCQQC.js";
+} from "../chunk-VLKEAYJ4.js";
+import "../chunk-TTO76NZJ.js";
 import {
   getMachineId
-} from "../chunk-NVPYRDCT.js";
-import "../chunk-Y6XXFXVB.js";
+} from "../chunk-SSQ5X6SA.js";
+import "../chunk-3F4VV5TS.js";
+import "../chunk-GMXKITVA.js";
 import "../chunk-DINDL2CF.js";
-import "../chunk-6BIMJIRG.js";
+import "../chunk-JSASMV3H.js";
 import "../chunk-BC3VCZ3E.js";
 import "../chunk-EYRGBYZG.js";
 import "../chunk-SAF6HGAA.js";
 import "../chunk-7QLSKOSU.js";
 import "../chunk-KZERVKTD.js";
-import "../chunk-ODL52O5V.js";
+import "../chunk-T5B3LRYF.js";
 import "../chunk-4LL6LG5X.js";
 import {
   getApiKey,
@@ -80,34 +86,9 @@ import {
 } from "../chunk-2UMNXADU.js";
 import {
   KILL_REASON,
+  redactSecrets,
   resolveGate
-} from "../chunk-Z6CP5ZZD.js";
-
-// src/wrapper/claudeBinary.ts
-import { statSync } from "fs";
-import { join, delimiter } from "path";
-var WRAPPER_ACTIVE_ENV = "PUSHARY_WRAPPER_ACTIVE";
-var isFile = (path) => {
-  try {
-    return statSync(path).isFile();
-  } catch {
-    return false;
-  }
-};
-var findClaudeBinary = () => {
-  const override = process.env.PUSHARY_CLAUDE_BIN?.trim();
-  if (override) return isFile(override) ? override : null;
-  const pathVar = process.env.PATH ?? "";
-  const exts = process.platform === "win32" ? [".cmd", ".exe", ".bat", ""] : [""];
-  for (const dir of pathVar.split(delimiter)) {
-    if (!dir) continue;
-    for (const ext of exts) {
-      const candidate = join(dir, `claude${ext}`);
-      if (isFile(candidate)) return candidate;
-    }
-  }
-  return null;
-};
+} from "../chunk-VOWZ5VOO.js";
 
 // src/wrapper/localPassthrough.ts
 var SIGNAL_NUMBERS = {
@@ -119,7 +100,7 @@ var SIGNAL_NUMBERS = {
 };
 var FORWARDED_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
 var runLocalPassthrough = (binary, args2) => {
-  return new Promise((resolve2) => {
+  return new Promise((resolve) => {
     let child;
     try {
       child = spawnClaude(binary, args2, {
@@ -127,7 +108,7 @@ var runLocalPassthrough = (binary, args2) => {
         env: { ...process.env, [WRAPPER_ACTIVE_ENV]: "1" }
       });
     } catch {
-      resolve2(127);
+      resolve(127);
       return;
     }
     const forward = (signal) => {
@@ -142,275 +123,126 @@ var runLocalPassthrough = (binary, args2) => {
     };
     child.on("error", () => {
       cleanup();
-      resolve2(127);
+      resolve(127);
     });
     child.on("exit", (code2, signal) => {
       cleanup();
-      if (typeof code2 === "number") resolve2(code2);
-      else if (signal) resolve2(128 + (SIGNAL_NUMBERS[signal] ?? 0));
-      else resolve2(0);
+      if (typeof code2 === "number") resolve(code2);
+      else if (signal) resolve(128 + (SIGNAL_NUMBERS[signal] ?? 0));
+      else resolve(0);
     });
   });
 };
 
 // src/wrapper/dualMode.ts
-import { basename } from "path";
-
-// src/transcript-sync.ts
-import { homedir as homedir2 } from "os";
-import { join as join3, resolve } from "path";
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync2 } from "fs";
 
-// src/transcript-session-key.ts
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync as statSync2, writeFileSync } from "fs";
-import { homedir } from "os";
-import { join as join2 } from "path";
-var sessionDir = () => process.env.PUSHARY_SESSION_KEY_DIR?.trim() || join2(homedir(), ".pushary", "sessions");
-var SESSION_KEY_TTL_MS = 48 * 60 * 60 * 1e3;
-var SAFE_SESSION_ID = /^[A-Za-z0-9._-]{1,128}$/;
-var fileFor = (sessionId) => SAFE_SESSION_ID.test(sessionId) ? join2(sessionDir(), `${sessionId}.json`) : null;
-var loadSessionKey = (sessionId) => {
-  const path = fileFor(sessionId);
-  if (!path || !existsSync(path)) return null;
-  try {
-    if (Date.now() - statSync2(path).mtimeMs > SESSION_KEY_TTL_MS) return null;
-    const raw = JSON.parse(readFileSync(path, "utf-8"));
-    const key = typeof raw.sessionKey === "string" ? Buffer.from(raw.sessionKey, "base64") : null;
-    if (!key || key.length !== 32) return null;
-    return {
-      sessionKey: new Uint8Array(key),
-      wrappedKey: typeof raw.wrappedKey === "string" ? raw.wrappedKey : null,
-      providerWrappedKey: typeof raw.providerWrappedKey === "string" ? raw.providerWrappedKey : null,
-      providerKeyId: typeof raw.providerKeyId === "string" ? raw.providerKeyId : null,
-      keyUploaded: raw.keyUploaded === true
-    };
-  } catch {
-    return null;
+// src/transcript-draft.ts
+var redactDraft = (text, complete = false) => {
+  let end = complete ? text.length : text.lastIndexOf("\n") + 1;
+  const pem = /-----BEGIN [^\n]*PRIVATE KEY-----/g;
+  for (const match of text.matchAll(pem)) {
+    if (!/-----END [^\n]*PRIVATE KEY-----/.test(text.slice(match.index, end))) end = Math.min(end, match.index);
   }
-};
-var saveSessionKey = (sessionId, value) => {
-  const path = fileFor(sessionId);
-  if (!path) return;
-  try {
-    mkdirSync(sessionDir(), { recursive: true, mode: 448 });
-    writeFileSync(
-      path,
-      JSON.stringify({
-        sessionKey: Buffer.from(value.sessionKey).toString("base64"),
-        wrappedKey: value.wrappedKey,
-        providerWrappedKey: value.providerWrappedKey,
-        providerKeyId: value.providerKeyId,
-        keyUploaded: value.keyUploaded
-      }),
-      { mode: 384 }
-    );
-  } catch {
+  const quoted = /(?:secret|token|password|passwd|api[_-]?key|access[_-]?key|client[_-]?secret|private[_-]?key)\s*[=:]\s*(["'])/gi;
+  for (const match of text.matchAll(quoted)) {
+    const close = text.indexOf(match[1], match.index + match[0].length);
+    if (close < 0 || close >= end) end = Math.min(end, match.index);
   }
+  return redactSecrets(text.slice(0, end));
 };
-var sweepStaleSessionKeys = (now = Date.now()) => {
-  const dir = sessionDir();
-  if (!existsSync(dir)) return 0;
-  let removed = 0;
-  try {
-    for (const name of readdirSync(dir)) {
-      if (!name.endsWith(".json")) continue;
-      const path = join2(dir, name);
-      try {
-        if (now - statSync2(path).mtimeMs <= SESSION_KEY_TTL_MS) continue;
-        rmSync(path, { force: true });
-        removed += 1;
-      } catch {
+var DraftText = class {
+  messageId = "";
+  text = "";
+  complete = false;
+  interrupted = false;
+  add(message) {
+    if (message.parent_tool_use_id) return;
+    const event = message.event;
+    if (message.type === "stream_event" && event?.type === "message_start") {
+      this.messageId = event.message?.id ?? "";
+      this.text = "";
+      this.complete = false;
+      this.interrupted = false;
+    } else if (message.type === "stream_event" && event?.type === "content_block_delta" && event.delta?.type === "text_delta") {
+      this.text = (this.text + (event.delta.text ?? "")).slice(0, 32 * 1024);
+    } else if (message.type === "assistant") {
+      const body = message.message;
+      if (body?.id === this.messageId && Array.isArray(body.content)) {
+        this.text = body.content.filter((block) => block.type === "text").map((block) => block.text).join("").slice(0, 32 * 1024);
+        this.complete = true;
       }
     }
-  } catch {
-    return removed;
   }
-  return removed;
-};
-
-// src/transcript-sync.ts
-var claudeTranscriptPath = (cwd, sessionId) => {
-  const projectId = resolve(cwd).replace(/[^a-zA-Z0-9-]/g, "-");
-  const configDir = process.env.CLAUDE_CONFIG_DIR || join3(homedir2(), ".claude");
-  return join3(configDir, "projects", projectId, `${sessionId}.jsonl`);
-};
-var createSyncState = () => ({
-  sessionKey: null,
-  wrappedKey: null,
-  providerWrappedKey: null,
-  providerKeyId: null,
-  seen: /* @__PURE__ */ new Set(),
-  keyUploaded: false,
-  keyRejected: false,
-  keyUnavailable: false
-});
-var syncTick = async (lines, state, uploader, sessionId, machineId) => {
-  if (state.keyRejected) return state;
-  let sessionKey = state.sessionKey;
-  let wrappedKey = state.wrappedKey;
-  let providerWrappedKey = state.providerWrappedKey;
-  let providerKeyId = state.providerKeyId;
-  if (!sessionKey) {
-    const recipients = await uploader.fetchTranscriptRecipients();
-    if (!recipients) return state;
-    sessionKey = generateSessionKey();
-    wrappedKey = wrapSessionKey(sessionKey, decodePublicKey(recipients.phonePublicKey));
-    if (recipients.provider) {
-      providerWrappedKey = wrapSessionKey(sessionKey, decodePublicKey(recipients.provider.publicKey));
-      providerKeyId = recipients.provider.keyId;
-    }
-  }
-  const built = buildTranscriptRecords(lines, sessionKey, state.seen);
-  if (built.records.length === 0) {
-    return { ...state, sessionKey, wrappedKey, providerWrappedKey, providerKeyId, seen: built.seen };
-  }
-  const seen = new Set(state.seen);
-  let keyUploaded = state.keyUploaded;
-  let keyRejected = false;
-  let keyUnavailable = false;
-  let rejected = 0;
-  for (const chunk of chunkRecords(built.records)) {
-    const result = await uploader.uploadRecords({
-      sessionId,
-      machineId,
-      dataEncryptionKey: keyUploaded ? void 0 : wrappedKey ?? void 0,
-      providerWrappedSessionKey: keyUploaded ? void 0 : providerWrappedKey ?? void 0,
-      providerKeyId: keyUploaded ? void 0 : providerKeyId ?? void 0,
-      records: chunk
-    });
-    keyUploaded = keyUploaded || result.keyRegistered;
-    if (result.keyConflict) {
-      keyRejected = true;
-      break;
-    }
-    if (result.keyUnavailable) {
-      keyUnavailable = true;
-      break;
-    }
-    if (!result.ok) break;
-    for (const id of result.settledIds ?? chunk.map((r) => r.localId)) seen.add(id);
-    rejected += result.rejectedIds.length;
+  interrupt() {
+    if (!this.complete) this.interrupted = true;
   }
-  if (rejected > 0) {
-    process.stderr.write(`[pushary] transcript: ${rejected} record${rejected === 1 ? "" : "s"} could not be stored and will not be retried.
-`);
-  }
-  return {
-    sessionKey,
-    wrappedKey,
-    providerWrappedKey,
-    providerKeyId,
-    seen,
-    keyUploaded,
-    keyRejected,
-    keyUnavailable
-  };
-};
-var MAX_RECORDS_PER_BATCH = 200;
-var MAX_BATCH_BYTES = 3e6;
-var chunkRecords = (records) => {
-  const chunks = [];
-  let current = [];
-  let bytes = 0;
-  for (const record of records) {
-    const size = record.content.length;
-    if (current.length > 0 && (current.length >= MAX_RECORDS_PER_BATCH || bytes + size > MAX_BATCH_BYTES)) {
-      chunks.push(current);
-      current = [];
-      bytes = 0;
-    }
-    current.push(record);
-    bytes += size;
+  snapshot() {
+    const text = redactDraft(this.text, this.complete);
+    return this.messageId && text ? { messageId: this.messageId, text, status: this.interrupted ? "interrupted" : this.complete ? "complete" : "streaming" } : null;
   }
-  if (current.length > 0) chunks.push(current);
-  return chunks;
 };
-var readLines = (path) => {
-  try {
-    return existsSync2(path) ? readFileSync2(path, "utf-8").split("\n") : [];
-  } catch {
-    return [];
-  }
-};
-var IDLE_CEILING_MS = 6e4;
-var nextInterval = (previousMs, idle, baseMs, maxMs) => idle ? Math.min(previousMs * 2, maxMs) : baseMs;
-var startTranscriptSync = (opts) => {
-  let warnedAboutRecipients = false;
-  const fetchPinnedRecipients = async () => {
-    const offer = await fetchTranscriptRecipients(opts.apiKey);
-    if (!offer) return null;
-    const verdict = verifyRecipients(offer, loadPin());
-    if (verdict.kind === "first-use" && !savePin(verdict.pin)) return null;
-    if (verdict.kind === "changed") {
-      if (!warnedAboutRecipients) {
-        warnedAboutRecipients = true;
-        process.stderr.write(`${changedRecipientsMessage(verdict, offer)}
-`);
-      }
-      return null;
-    }
-    return offer;
-  };
-  const uploader = {
-    fetchTranscriptRecipients: fetchPinnedRecipients,
-    uploadRecords: (params) => uploadTranscriptRecords(opts.apiKey, params)
-  };
-  const path = claudeTranscriptPath(opts.cwd, opts.sessionId);
-  const persisted = loadSessionKey(opts.sessionId);
-  let state = persisted ? { ...createSyncState(), ...persisted } : createSyncState();
-  sweepStaleSessionKeys();
-  let persistedUploaded = persisted?.keyUploaded ?? false;
-  let running = true;
-  let inFlight = false;
-  const tick = async () => {
-    if (!running || inFlight) return;
-    inFlight = true;
-    try {
-      const before = state.sessionKey;
-      state = await syncTick(readLines(path), state, uploader, opts.sessionId, opts.machineId);
-      if (state.sessionKey && (before !== state.sessionKey || state.keyUploaded !== persistedUploaded)) {
-        persistedUploaded = state.keyUploaded;
-        saveSessionKey(opts.sessionId, {
-          sessionKey: state.sessionKey,
-          wrappedKey: state.wrappedKey,
-          providerWrappedKey: state.providerWrappedKey,
-          providerKeyId: state.providerKeyId,
-          keyUploaded: state.keyUploaded
+var startTranscriptDraft = (apiKey, getSessionId) => {
+  const text = new DraftText();
+  const startedAt = Date.now();
+  let revision = 0;
+  let stopped = false;
+  let pending;
+  let ending = false;
+  let sent = "";
+  const flush = async () => {
+    if (stopped || pending || !transcriptsEnabled()) return;
+    const sessionId = getSessionId();
+    const snapshot = text.snapshot();
+    if (!sessionId || !snapshot || !registeredTranscriptEnabled(apiKey, sessionId)) return;
+    const raw = JSON.stringify(snapshot);
+    if (raw === sent) return;
+    const key = loadSessionKey(sessionId);
+    if (!key?.keyUploaded) return;
+    pending = (async () => {
+      try {
+        const response = await fetch(`${getBaseUrl()}/api/agent/transcript`, {
+          method: "POST",
+          headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+          body: JSON.stringify({ sessionId, draft: { startedAt, revision: ++revision, content: encryptRecord(raw, key.sessionKey) } }),
+          signal: AbortSignal.timeout(5e3)
         });
+        if (response.ok) sent = raw;
+      } catch {
       }
-    } catch {
+    })();
+    try {
+      await pending;
     } finally {
-      inFlight = false;
+      pending = void 0;
     }
   };
-  const baseIntervalMs = opts.intervalMs ?? 3e3;
-  const maxIntervalMs = Math.max(baseIntervalMs, IDLE_CEILING_MS);
-  let timer;
-  const schedule = (delayMs) => {
-    if (!running) return;
-    timer = setTimeout(() => {
-      void (async () => {
-        const before = state.sessionKey;
-        await tick();
-        const idle = state.sessionKey === null && before === null || state.keyUnavailable;
-        schedule(nextInterval(delayMs, idle, baseIntervalMs, maxIntervalMs));
-      })();
-    }, delayMs);
-    if (typeof timer.unref === "function") timer.unref();
-  };
-  void tick();
-  schedule(baseIntervalMs);
-  return () => {
-    running = false;
-    if (timer) clearTimeout(timer);
+  const timer = setInterval(() => void flush(), 800);
+  timer.unref();
+  return {
+    add: (message) => {
+      if (!ending) text.add(message);
+    },
+    stop: async () => {
+      if (ending) return;
+      ending = true;
+      clearInterval(timer);
+      text.interrupt();
+      await pending;
+      await flush();
+      stopped = true;
+    }
   };
 };
 
+// src/wrapper/dualMode.ts
+import { basename } from "path";
+
 // src/wrapper/sdkLoader.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
 import { pathToFileURL } from "url";
 var userMessage = (text) => ({
   type: "user",
@@ -420,8 +252,8 @@ var userMessage = (text) => ({
 var SDK_VERSION = "0.3.207";
 var SDK_PACKAGE = "@anthropic-ai/claude-agent-sdk";
 var SDK_SPEC = `${SDK_PACKAGE}@${SDK_VERSION}`;
-var sdkCacheDir = () => process.env.PUSHARY_REMOTE_SDK_DIR?.trim() || join4(homedir3(), ".pushary", "remote-sdk");
-var cachedSdkEntry = () => join4(sdkCacheDir(), "node_modules", "@anthropic-ai", "claude-agent-sdk", "sdk.mjs");
+var sdkCacheDir = () => process.env.PUSHARY_REMOTE_SDK_DIR?.trim() || join(homedir(), ".pushary", "remote-sdk");
+var cachedSdkEntry = () => join(sdkCacheDir(), "node_modules", "@anthropic-ai", "claude-agent-sdk", "sdk.mjs");
 var importSdk = async (specifierOrUrl) => {
   try {
     const mod = await import(specifierOrUrl);
@@ -436,7 +268,7 @@ var loadClaudeSdk = async () => {
   const fromResolution = await importSdk(SDK_PACKAGE);
   if (fromResolution) return fromResolution;
   const entry = cachedSdkEntry();
-  if (existsSync3(entry)) return importSdk(pathToFileURL(entry).href);
+  if (existsSync(entry)) return importSdk(pathToFileURL(entry).href);
   return null;
 };
 var ensureClaudeSdk = async (log) => {
@@ -444,10 +276,10 @@ var ensureClaudeSdk = async (log) => {
   if (present) return present;
   const dir = sdkCacheDir();
   try {
-    mkdirSync2(dir, { recursive: true });
-    const pkgJson = join4(dir, "package.json");
-    if (!existsSync3(pkgJson)) {
-      writeFileSync2(pkgJson, `${JSON.stringify({ name: "pushary-remote-sdk", private: true })}
+    mkdirSync(dir, { recursive: true });
+    const pkgJson = join(dir, "package.json");
+    if (!existsSync(pkgJson)) {
+      writeFileSync(pkgJson, `${JSON.stringify({ name: "pushary-remote-sdk", private: true })}
 `);
     }
   } catch {
@@ -455,14 +287,14 @@ var ensureClaudeSdk = async (log) => {
   }
   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((resolve2) => {
+  const installed = await new Promise((resolve) => {
     const child = spawn(
       npmCmd,
       ["install", "--no-optional", "--no-audit", "--no-fund", "--loglevel=error", SDK_SPEC],
       { cwd: dir, stdio: "ignore", shell: process.platform === "win32" }
     );
-    child.on("error", () => resolve2(false));
-    child.on("close", (code2) => resolve2(code2 === 0));
+    child.on("error", () => resolve(false));
+    child.on("close", (code2) => resolve(code2 === 0));
   });
   if (!installed) {
     log?.(`[pushary] could not auto-install the SDK. Install it manually: npm i -g ${SDK_SPEC}`);
@@ -476,6 +308,7 @@ var BoundedInputQueue = class {
   buffer = [];
   waiter;
   closed = false;
+  generation = 0;
   cap;
   onDrop;
   coalesce;
@@ -491,18 +324,18 @@ var BoundedInputQueue = class {
     if (this.closed) return false;
     this.pushedCount++;
     if (this.waiter) {
-      const resolve2 = this.waiter;
+      const resolve = this.waiter;
       this.waiter = void 0;
       this.deliveredCount++;
-      resolve2({ value: item, done: false });
+      resolve({ value: item, done: false });
       return true;
     }
-    this.buffer.push(item);
-    while (this.buffer.length > this.cap) {
-      const dropped = this.buffer.shift();
+    if (this.buffer.length >= this.cap) {
       this.droppedCount++;
-      this.onDrop?.(dropped, this.droppedCount);
+      this.onDrop?.(item, this.droppedCount);
+      return false;
     }
+    this.buffer.push(item);
     return true;
   }
   // Mark done. Any parked consumer completes; further push() is ignored. The
@@ -512,9 +345,9 @@ var BoundedInputQueue = class {
     this.closed = true;
     this.buffer.length = 0;
     if (this.waiter) {
-      const resolve2 = this.waiter;
+      const resolve = this.waiter;
       this.waiter = void 0;
-      resolve2({ value: void 0, done: true });
+      resolve({ value: void 0, done: true });
     }
   }
   // End the CURRENT consumer without closing the queue, so a fresh query can
@@ -522,10 +355,11 @@ var BoundedInputQueue = class {
   // the parked waiter as done lets the abandoned query's for-await unwind cleanly
   // instead of hanging on a promise that would otherwise never settle.
   detachConsumer() {
+    this.generation++;
     if (this.waiter) {
-      const resolve2 = this.waiter;
+      const resolve = this.waiter;
       this.waiter = void 0;
-      resolve2({ value: void 0, done: true });
+      resolve({ value: void 0, done: true });
     }
   }
   // Drop every buffered item without closing the queue. Used when phone control
@@ -548,8 +382,12 @@ var BoundedInputQueue = class {
     return { pushed: this.pushedCount, delivered: this.deliveredCount, dropped: this.droppedCount };
   }
   [Symbol.asyncIterator]() {
+    const generation = this.generation;
     return {
       next: () => {
+        if (generation !== this.generation || this.closed) {
+          return Promise.resolve({ value: void 0, done: true });
+        }
         if (this.buffer.length > 0) {
           if (this.coalesce && this.buffer.length > 1) {
             const items = this.buffer.splice(0, this.buffer.length);
@@ -568,12 +406,12 @@ var BoundedInputQueue = class {
             new Error("BoundedInputQueue: concurrent consumers are not supported")
           );
         }
-        return new Promise((resolve2) => {
-          this.waiter = resolve2;
+        return new Promise((resolve) => {
+          this.waiter = resolve;
         });
       },
       return: () => {
-        this.close();
+        if (generation === this.generation) this.detachConsumer();
         return Promise.resolve({ value: void 0, done: true });
       }
     };
@@ -610,8 +448,8 @@ var createRemoteApprover = (deps) => {
     const deadline = now() + windowMs;
     while (now() < deadline && !entry.controller.signal.aborted) {
       const remaining = Math.min(Math.max(deadline - now(), 1e3), 3e4);
-      const abortPromise = new Promise((resolve2) => {
-        entry.controller.signal.addEventListener("abort", () => resolve2({ answered: false, aborted: true }), {
+      const abortPromise = new Promise((resolve) => {
+        entry.controller.signal.addEventListener("abort", () => resolve({ answered: false, aborted: true }), {
           once: true
         });
       });
@@ -842,7 +680,7 @@ var startCommandPoller = (opts) => {
         const text = typeof command === "string" ? command : command.text;
         let accepted = false;
         try {
-          accepted = opts.onCommand(text) !== false;
+          accepted = await opts.onCommand(text) !== false;
         } catch {
         }
         if (typeof command !== "string") {
@@ -878,7 +716,7 @@ 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(), machineId) => {
+var pollAgent = async (apiKey, sessionId, wantCommand, signal, baseUrl = getBaseUrl(), machineId, controlMode, takeoverDeclined) => {
   try {
     const sessionKey = sessionId || DEFAULT_SESSION;
     const receiptNamespace = `${apiKey}:${machineId}:claude_code`;
@@ -921,6 +759,8 @@ var pollAgent = async (apiKey, sessionId, wantCommand, signal, baseUrl = getBase
       headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
       body: JSON.stringify({
         ...sessionId ? { sessionId } : {},
+        ...controlMode ? { controlMode } : {},
+        ...takeoverDeclined ? { takeoverDeclined } : {},
         ...machineId ? { machineId } : {},
         ...wantCommand && !storedCommand ? {} : { drain: false },
         ...wantCommand && !storedCommand && machineId ? { ackMode: true } : {}
@@ -956,7 +796,7 @@ var pollAgent = async (apiKey, sessionId, wantCommand, signal, baseUrl = getBase
       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, rejected: false };
+    return { command, mode, rejected: false, ...data.takeoverRequested === true ? { takeoverRequested: true } : {} };
   } catch {
     return { command: null, mode: null, rejected: false };
   }
@@ -1034,6 +874,7 @@ var createRelayClient = (options) => {
   let pongTimer;
   const seenCommands = [];
   const seenSet = /* @__PURE__ */ new Set();
+  const pendingCommands = /* @__PURE__ */ new Map();
   const log = (message) => options.log?.(message);
   const receiptNamespace = `${options.apiKey}:${options.machineId}:${options.agentType}`;
   const acknowledgeStored = (id) => {
@@ -1093,7 +934,7 @@ var createRelayClient = (options) => {
       armPong();
     }, heartbeatMs);
   };
-  const onServerFrame = (raw) => {
+  const onServerFrame = async (raw) => {
     const frame = decodeServerFrame(raw);
     if (!frame) return;
     switch (frame.t) {
@@ -1102,6 +943,11 @@ var createRelayClient = (options) => {
         log("[pushary] relay connected");
         break;
       case "command":
+        if (pendingCommands.has(frame.id)) {
+          await pendingCommands.get(frame.id);
+          acknowledgeStored(frame.id);
+          break;
+        }
         if (seenSet.has(frame.id)) {
           sendFrame({ v: PROTOCOL_VERSION, t: "ack", id: frame.id, state: "delivered" });
           break;
@@ -1118,9 +964,14 @@ var createRelayClient = (options) => {
           acknowledgeStored(frame.id);
           break;
         }
+        let completePending;
+        pendingCommands.set(frame.id, new Promise((resolve) => {
+          completePending = resolve;
+        }));
         let accepted = false;
         try {
-          accepted = options.onCommand(frame.text) !== false;
+          const result = options.onCommand(frame.text);
+          accepted = (result instanceof Promise ? await result : result) !== false;
         } catch {
         }
         if (accepted && markPendingCommandDelivered(sessionKey, frame.id, receiptNamespace)) {
@@ -1135,6 +986,8 @@ var createRelayClient = (options) => {
             failureCode: "consumer_rejected"
           });
         }
+        completePending();
+        pendingCommands.delete(frame.id);
         break;
       case "ping":
         sendFrame({ v: PROTOCOL_VERSION, t: "pong" });
@@ -1299,14 +1152,22 @@ var flagValue = (args2, index) => {
   const next = args2[index + 1];
   return next && !next.startsWith("-") ? next : void 0;
 };
-var PASS_THROUGH_VALUE_FLAGS = /* @__PURE__ */ new Set(["--model", "-m", "--cwd", "--add-dir", "--settings"]);
+var PASS_THROUGH_VALUE_FLAGS = /* @__PURE__ */ new Set(["--cwd", "--add-dir"]);
 var parseRemoteArgs = (args2) => {
   let initialPrompt;
   let resume;
   let permissionMode;
+  let model;
+  let settings;
   for (let i = 0; i < args2.length; i++) {
     const arg = args2[i];
-    if (PASS_THROUGH_VALUE_FLAGS.has(arg ?? "")) {
+    if (arg === "--model" || arg === "-m" || arg?.startsWith("--model=")) {
+      model = flagValue(args2, i);
+      if (!arg.includes("=")) i++;
+    } else if (arg === "--settings" || arg?.startsWith("--settings=")) {
+      settings = flagValue(args2, i);
+      if (!arg.includes("=")) i++;
+    } else if (PASS_THROUGH_VALUE_FLAGS.has(arg ?? "")) {
       i++;
     } else if (arg === "-p" || arg === "--print" || arg?.startsWith("--print=")) {
       initialPrompt = flagValue(args2, i);
@@ -1316,15 +1177,38 @@ var parseRemoteArgs = (args2) => {
       permissionMode = flagValue(args2, i);
     }
   }
-  return { initialPrompt, resume, permissionMode };
+  return { initialPrompt, resume, permissionMode, ...model ? { model } : {}, ...settings ? { settings } : {} };
+};
+var remoteCompatibilityIssue = (args2) => {
+  const values = /* @__PURE__ */ new Set(["--model", "-m", "--settings", "--permission-mode", "--resume", "-r", "--session-id", "-p", "--print", "--cwd", "--add-dir"]);
+  const switches = /* @__PURE__ */ new Set(["--continue", "-c", "--verbose", "--debug", "--dangerously-skip-permissions"]);
+  for (let index = 0; index < args2.length; index++) {
+    const arg = args2[index];
+    if (!arg.startsWith("-")) continue;
+    const flag = arg.split("=")[0];
+    if (switches.has(flag)) continue;
+    if (!values.has(flag)) return `Phone takeover does not yet preserve ${flag}; keep using this terminal.`;
+    if (!arg.includes("=") && args2[index + 1] && !args2[index + 1].startsWith("-")) index++;
+  }
+  return null;
 };
 
 // src/wrapper/localLeg.ts
+import { readFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
 var SIGNAL_EXIT_BASE = 128;
 var SIGNAL_NUMBERS2 = { SIGHUP: 1, SIGINT: 2, SIGTERM: 15 };
 var nativeArgs = (session) => {
-  const args2 = [...session.claudeArgs];
+  let args2 = [...session.claudeArgs];
   const id = session.getSessionId();
+  if (id && session.userManagesSession && session.isSessionCreated()) {
+    args2 = args2.filter((arg, index, all) => {
+      if (/^(--resume|-r|--session-id)(=|$)|^(--continue|-c)$/.test(arg)) return false;
+      return !/^(--resume|-r|--session-id)$/.test(all[index - 1] ?? "") || arg.startsWith("-");
+    });
+    return [...args2, "--resume", id];
+  }
   if (id && !session.userManagesSession) {
     args2.push(session.isSessionCreated() ? "--resume" : "--session-id", id);
   }
@@ -1332,22 +1216,24 @@ var nativeArgs = (session) => {
 };
 var runLocalLeg = (session, deps = {}) => {
   const spawn2 = deps.spawn ?? spawnClaude;
-  return new Promise((resolve2) => {
+  return new Promise((resolve) => {
     const legAbort = new AbortController();
     let exitReason = null;
     let settled = false;
+    let identityTimer;
     const finish = () => {
       if (settled) return;
       settled = true;
+      if (identityTimer) clearInterval(identityTimer);
       session.setActiveLeg(null);
-      resolve2(exitReason ?? { type: "exit", code: 0 });
+      resolve(exitReason ?? { type: "exit", code: 0 });
     };
     const control = {
       onPhoneCommand: () => {
         if (!exitReason) exitReason = "switch";
         if (!legAbort.signal.aborted) {
           process.stderr.write(
-            "\n[pushary] instruction from your phone \u2014 taking this session over to run it (Ctrl-] hands the terminal back)\n"
+            "\n[pushary] phone takeover requested \u2014 resuming this conversation with phone control (Ctrl-] hands the terminal back)\n"
           );
           legAbort.abort();
         }
@@ -1376,8 +1262,24 @@ var runLocalLeg = (session, deps = {}) => {
       finish();
       return;
     }
+    const spawnedAt = Date.now();
+    const readIdentity = () => {
+      if (!child.pid) return;
+      try {
+        const root = process.env.CLAUDE_CONFIG_DIR || join2(homedir2(), ".claude");
+        const record = JSON.parse(readFileSync(join2(root, "sessions", `${child.pid}.json`), "utf8"));
+        if (record.pid !== child.pid || record.cwd !== process.cwd() || record.startedAt < spawnedAt - 5e3 || typeof record.startedAt !== "number" || !/^[a-f0-9-]{36}$/i.test(record.sessionId)) return;
+        if (record.sessionId !== session.getSessionId()) session.setSessionId(record.sessionId);
+        session.markSessionCreated();
+      } catch {
+      }
+    };
     session.markSessionCreated();
-    child.on("error", () => {
+    readIdentity();
+    identityTimer = setInterval(readIdentity, 500);
+    identityTimer.unref();
+    child.on("error", (error) => {
+      if (legAbort.signal.aborted && error.name === "AbortError") return;
       if (!legAbort.signal.aborted && !exitReason) {
         exitReason = { type: "exit", code: 127 };
       }
@@ -1435,7 +1337,10 @@ var runRemoteLoop = async (deps) => {
         prompt: deps.input,
         options: {
           resume: resumeId,
+          includePartialMessages: true,
           permissionMode: deps.permissionMode,
+          model: deps.model,
+          settings: deps.settings,
           canUseTool: deps.canUseTool,
           env: deps.env,
           cwd: deps.cwd,
@@ -1447,8 +1352,9 @@ var runRemoteLoop = async (deps) => {
       return ended(1, "failed");
     }
     const onAbort = () => {
-      deps.input.close();
-      void query.interrupt?.().catch(() => {
+      deps.input.detachConsumer();
+      if (query.close) query.close();
+      else void query.interrupt?.().catch(() => {
       });
     };
     if (deps.signal.aborted) onAbort();
@@ -1471,6 +1377,14 @@ var runRemoteLoop = async (deps) => {
       for await (const message of query) {
         deps.onMessage?.(message);
         if (isInit(message) && typeof message.session_id === "string") {
+          if (resumeId && message.session_id !== resumeId) {
+            disarmIdle();
+            deps.signal.removeEventListener("abort", onAbort);
+            deps.input.detachConsumer();
+            query.close?.();
+            deps.log?.("[pushary] refused a different session ID during resume");
+            return ended(1, "failed");
+          }
           resumeId = message.session_id;
           deps.onSessionId?.(resumeId);
         }
@@ -1484,11 +1398,13 @@ var runRemoteLoop = async (deps) => {
       }
       disarmIdle();
       deps.signal.removeEventListener("abort", onAbort);
+      query.close?.();
       if (idleExpired) return ended(0, "idle");
       return deps.signal.aborted ? ended(130, "aborted") : ended(0, "input-closed");
     } catch (err) {
       disarmIdle();
       deps.signal.removeEventListener("abort", onAbort);
+      query.close?.();
       if (idleExpired) return ended(0, "idle");
       if (deps.signal.aborted) return ended(130, "aborted");
       restarts++;
@@ -1511,6 +1427,7 @@ var CTRL_C = "";
 var terminalAttended = () => Boolean(process.stdin.isTTY);
 var runRemoteLeg = async (session, sdk, deps = {}) => {
   const legAbort = new AbortController();
+  const launchArgs = parseRemoteArgs(session.claudeArgs);
   const attended = deps.attended ?? terminalAttended();
   let switchBack = false;
   let idleEnded = false;
@@ -1546,6 +1463,8 @@ var runRemoteLeg = async (session, sdk, deps = {}) => {
       // conversation is continuous across the switch. Undefined = fresh session.
       initialResume: session.getSessionId(),
       permissionMode: session.permissionMode,
+      model: launchArgs.model,
+      settings: launchArgs.settings,
       // 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: phoneDrivenEnv({ ...process.env, [WRAPPER_ACTIVE_ENV]: "1" }),
@@ -1596,7 +1515,6 @@ var driveModeLoop = async (deps) => {
 // src/wrapper/dualMode.ts
 var INPUT_QUEUE_CAP = 32;
 var MIN_MODE_DWELL_MS = 300;
-var RELAY_FALLBACK_POLL_MS = 6e4;
 var PRESENCE_HEARTBEAT_MS = 6e4;
 var SESSION_FLAG_RE = /^(-r|--resume|-c|--continue|--session-id)(=.*)?$/;
 var extractAssistantText = (message) => {
@@ -1609,6 +1527,12 @@ var extractAssistantText = (message) => {
   return void 0;
 };
 var runDualMode = async (binary, args2, startingMode) => {
+  const compatibilityIssue = remoteCompatibilityIssue(args2);
+  if (startingMode === "remote" && compatibilityIssue) {
+    process.stderr.write(`[pushary] ${compatibilityIssue}
+`);
+    return { implemented: false };
+  }
   let apiKey;
   try {
     apiKey = getApiKey();
@@ -1619,12 +1543,14 @@ var runDualMode = async (binary, args2, startingMode) => {
     return { implemented: false };
   }
   let sdk;
+  let sdkLoading;
   let remoteAvailable = true;
   let noticedUnavailable = false;
   const ensureSdk = async () => {
     if (sdk === void 0) {
-      sdk = await ensureClaudeSdk((message) => process.stderr.write(`${message}
+      sdkLoading ??= ensureClaudeSdk((message) => process.stderr.write(`${message}
 `));
+      sdk = await sdkLoading;
       if (!sdk) remoteAvailable = false;
     }
     return sdk;
@@ -1644,7 +1570,9 @@ var runDualMode = async (binary, args2, startingMode) => {
   };
   const { initialPrompt, resume, permissionMode } = parseRemoteArgs(args2);
   const userManagesSession = args2.some((a) => SESSION_FLAG_RE.test(a));
-  let sessionId = resume;
+  const explicitIdIndex = args2.findIndex((arg) => arg === "--session-id" || arg.startsWith("--session-id="));
+  const explicitId = explicitIdIndex < 0 ? void 0 : args2[explicitIdIndex].split("=")[1] ?? args2[explicitIdIndex + 1];
+  let sessionId = resume ?? explicitId;
   let sessionCreated = Boolean(resume);
   if (!sessionId && startingMode === "local" && !userManagesSession) {
     sessionId = crypto.randomUUID();
@@ -1653,9 +1581,12 @@ var runDualMode = async (binary, args2, startingMode) => {
   let killed = false;
   let finished = false;
   let activeLeg = null;
+  let controlMode = startingMode;
+  let takeoverPending = false;
+  let takeoverDecline;
   const input = new BoundedInputQueue({
     cap: INPUT_QUEUE_CAP,
-    onDrop: (_dropped, total) => process.stderr.write(`[pushary] input queue full; dropped ${total} stale instruction(s)
+    onDrop: (_dropped, total) => process.stderr.write(`[pushary] input queue full; refused ${total} instruction(s)
 `),
     coalesce: (items) => userMessage(items.map((m) => m.message.content).join("\n\n"))
   });
@@ -1667,9 +1598,9 @@ var runDualMode = async (binary, args2, startingMode) => {
     getSessionId: () => sessionId
   });
   const initialModeState = await fetchModeState(apiKey).catch(() => null);
-  const relayAdvertised = Boolean(initialModeState?.relayUrl);
   let relay;
-  if (initialModeState?.relayUrl) {
+  const startRelay = () => {
+    if (!initialModeState?.relayUrl || relay) return;
     relay = createRelayClient({
       url: initialModeState.relayUrl,
       apiKey,
@@ -1681,7 +1612,7 @@ var runDualMode = async (binary, args2, startingMode) => {
       log: verboseLog
     });
     relay.start();
-  }
+  };
   let ownership;
   let ownershipSessionId;
   const ensureOwnership = async () => {
@@ -1707,13 +1638,12 @@ var runDualMode = async (binary, args2, startingMode) => {
     } catch {
     }
   };
-  let stopTranscript;
   let presenceHeartbeat;
-  let transcriptStarted = false;
+  let transcriptStarted;
   const ensureTranscriptSync = () => {
-    if (transcriptStarted || !transcriptsEnabled() || !sessionId) return;
-    transcriptStarted = true;
-    stopTranscript = startTranscriptSync({ apiKey, sessionId, cwd: process.cwd(), machineId });
+    if (transcriptStarted === sessionId || !transcriptsEnabled() || !sessionId) return;
+    transcriptStarted = sessionId;
+    registerTranscript("claude", { session_id: sessionId, cwd: process.cwd() });
   };
   const ensurePresenceHeartbeat = () => {
     if (presenceHeartbeat || !sessionId) return;
@@ -1732,19 +1662,22 @@ var runDualMode = async (binary, args2, startingMode) => {
     ensurePresenceHeartbeat();
     ensureTranscriptSync();
   };
-  const onPhoneCommand = (command) => {
-    if (!remoteAvailable) {
+  const onPhoneCommand = async (command) => {
+    if (controlMode !== "remote") return false;
+    if (!sessionId || finished || !await ensureSdk() || !remoteAvailable) {
       if (!noticedUnavailable) {
         noticedUnavailable = true;
         process.stderr.write("[pushary] phone control is unavailable this run; the instruction was not delivered.\n");
       }
       return false;
     }
-    if (!input.push(userMessage(command))) return false;
+    if (finished || !input.push(userMessage(command))) return false;
     activeLeg?.onPhoneCommand();
     return true;
   };
+  let draft;
   const streamMessage = (message) => {
+    draft?.add(message);
     if (message.type === "assistant") {
       const text = extractAssistantText(message);
       if (text) process.stdout.write(`${text}
@@ -1755,18 +1688,52 @@ var runDualMode = async (binary, args2, startingMode) => {
       void announcePresence("stop", "Turn complete");
     }
   };
+  const declineTakeover = (reason, message) => {
+    takeoverDecline = reason;
+    process.stderr.write(`[pushary] ${message}
+`);
+  };
+  const takeOver = async () => {
+    if (controlMode !== "local" || takeoverPending || finished) return;
+    if (compatibilityIssue) {
+      declineTakeover("unsupported_flags", compatibilityIssue);
+      return;
+    }
+    takeoverPending = true;
+    try {
+      if (!sessionId || !existsSync2(claudeTranscriptPath(process.cwd(), sessionId))) {
+        declineTakeover("no_transcript", "phone takeover needs a turn in this session first; your terminal and queued instructions are unchanged.");
+        return;
+      }
+      if (!await ensureSdk()) {
+        declineTakeover("sdk_unavailable", "phone takeover could not start the Agent SDK; your terminal and queued instructions are unchanged.");
+        return;
+      }
+      if (!finished && controlMode === "local") activeLeg?.onPhoneCommand();
+    } finally {
+      takeoverPending = false;
+    }
+  };
   const poller = startCommandPoller({
     apiKey,
     getSessionId: () => sessionId,
     onCommand: (command) => onPhoneCommand(command),
-    shouldDrainCommands: () => !(relay?.connected() ?? false),
+    shouldDrainCommands: () => controlMode === "remote" && Boolean(sessionId) && !(relay?.connected() ?? false),
     // 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: (key, id, wantCommand, signal) => pollAgent(key, id, wantCommand, signal, void 0, machineId),
+    poll: async (key, id, wantCommand, signal) => {
+      const declined = takeoverDecline;
+      takeoverDecline = void 0;
+      const result = await pollAgent(key, id, wantCommand, signal, void 0, machineId, controlMode, declined);
+      if (result.takeoverRequested) void takeOver();
+      return result;
+    },
     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,
+    // Observe explicit takeover promptly even when the command queue is idle.
+    // Not faster than this: the poll runs for the life of every wrapper, including
+    // local mode where it cannot return a command, and each tick costs a handful
+    // of Redis round trips. Takeover already sits behind a confirm and a biometric.
+    slowPollMs: 15e3,
     onAuthRejected: () => {
       process.stderr.write(
         "[pushary] this key was rejected \u2014 remote stop and phone messages are NOT active; run `pushary login` to reconnect\n"
@@ -1817,7 +1784,7 @@ var runDualMode = async (binary, args2, startingMode) => {
   try {
     if (sessionId && startingMode === "local") {
       process.stderr.write(
-        "[pushary] reachable from your phone \u2014 send an instruction from the app when this goes idle (Ctrl-] keeps the terminal).\n"
+        "[pushary] phone messages queue for the next turn. Choose Continue on phone in the app for idle control (Ctrl-] returns the terminal).\n"
       );
       void announcePresence("session_start", "Session ready \u2014 reachable from your phone");
       ensurePresenceHeartbeat();
@@ -1827,8 +1794,17 @@ var runDualMode = async (binary, args2, startingMode) => {
     if (startingMode === "remote" && initialPrompt) input.push(userMessage(initialPrompt));
     const exitCode = await driveModeLoop({
       startingMode,
-      runLocal: () => runLocalLeg(session),
+      runLocal: async () => {
+        controlMode = "local";
+        await draft?.stop();
+        draft = void 0;
+        relay?.stop();
+        relay = void 0;
+        return runLocalLeg(session);
+      },
       runRemote: async () => {
+        controlMode = "remote";
+        startRelay();
         const ready = await ensureSdk();
         if (!ready) {
           remoteAvailable = false;
@@ -1847,6 +1823,7 @@ var runDualMode = async (binary, args2, startingMode) => {
           }
           return "switch";
         }
+        draft = startTranscriptDraft(apiKey, () => sessionId);
         return runRemoteLeg(session, ready);
       },
       isFinished: () => finished,
@@ -1856,13 +1833,14 @@ var runDualMode = async (binary, args2, startingMode) => {
   } finally {
     for (const signal of signals) process.off(signal, onSignal);
     process.removeListener("exit", restoreStdin);
+    await draft?.stop();
     relay?.stop();
     poller.stop();
     if (presenceHeartbeat) clearInterval(presenceHeartbeat);
-    stopTranscript?.();
     approver.teardown();
     input.close();
     stdin.dispose();
+    if (sessionId) registerTranscript("claude", { session_id: sessionId, cwd: process.cwd() }, void 0, { ended: true });
     await announcePresence("session_closed", "Session ended");
     ownership?.stop();
     if (totalCostUsd > 0) {