@longleash/cli 0.1.0-rc.10 → 0.1.0-rc.12

package/runtime/daemon/bin/longleashd.mjs

@@ -12,8 +12,8 @@ import { dirname as dirname4, join as join10, resolve as resolve6 } from "node:p
 import { fileURLToPath } from "node:url";
 
 // ../daemon/src/daemon.ts
-import { accessSync, constants, mkdirSync as mkdirSync3, existsSync as existsSync6, writeFileSync as writeFileSync2 } from "node:fs";
-import { randomBytes as randomBytes6 } from "node:crypto";
+import { accessSync, constants, mkdirSync as mkdirSync3, existsSync as existsSync6, writeFileSync as writeFileSync2, renameSync, rmSync } from "node:fs";
+import { randomBytes as randomBytes7 } from "node:crypto";
 
 // ../daemon/src/delegation-handoff.ts
 async function pauseCurrentSessionOwner(managed, external, session, actor, reason) {
@@ -5425,6 +5425,79 @@ var IdeOpenSessionResultSchema = external_exports.object({
   }
 });
 
+// ../protocol/src/pairing.ts
+var VERIFIED_PAIRING_VERSION = 2;
+var PairingNonce = external_exports.string().regex(/^[A-Za-z0-9_-]{43}$/);
+var PairingDeviceName = external_exports.string().min(1).max(64).refine(
+  (name) => name.trim().length > 0 && !/[\p{Cc}\p{Cf}]/u.test(name),
+  "Device name must be visible text without control characters"
+);
+var PairingTranscript = external_exports.object({
+  v: external_exports.literal(VERIFIED_PAIRING_VERSION),
+  challengeId: external_exports.string().min(1).max(128),
+  attemptId: PairingNonce,
+  phoneNonce: PairingNonce,
+  daemonNonce: PairingNonce,
+  deviceName: PairingDeviceName,
+  expiresAt: external_exports.number().int().positive().safe()
+}).strict();
+var utf8 = (value) => new TextEncoder().encode(value);
+var hex = (bytes) => Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+function deriveVerifiedPairing(secret, raw) {
+  PairingNonce.parse(secret);
+  const t = PairingTranscript.parse(raw);
+  const transcript = JSON.stringify([
+    "longleash-pairing-v2",
+    t.v,
+    t.challengeId,
+    t.attemptId,
+    ["phone", t.phoneNonce, t.deviceName],
+    ["daemon", t.daemonNonce],
+    t.expiresAt
+  ]);
+  const salt = sha256(utf8(transcript));
+  const derive = (purpose) => hkdf(sha256, utf8(secret), salt, utf8(`longleash-pairing-v2/${purpose}`), 32);
+  const digits = (BigInt(`0x${hex(derive("display-code"))}`) % 100000000n).toString().padStart(8, "0");
+  return {
+    code: `${digits.slice(0, 4)} ${digits.slice(4)}`,
+    identity: { roomTag: hex(derive("room-tag")), frameKey: derive("frame-key") }
+  };
+}
+var PairingBegin = external_exports.object({
+  v: external_exports.literal(2),
+  type: external_exports.literal("pair-begin"),
+  challengeId: external_exports.string().min(1).max(128),
+  phoneNonce: PairingNonce,
+  deviceName: PairingDeviceName
+}).strict();
+var PairingDecision = external_exports.object({
+  v: external_exports.literal(2),
+  type: external_exports.enum(["pair-confirm", "pair-reject", "pair-ping"]),
+  attemptId: PairingNonce
+}).strict();
+var PairingReply = external_exports.discriminatedUnion("type", [
+  external_exports.object({ v: external_exports.literal(2), type: external_exports.literal("pair-transcript"), transcript: PairingTranscript, remainingMs: external_exports.number().int().min(1).max(3e5) }).strict(),
+  external_exports.object({ v: external_exports.literal(2), type: external_exports.literal("pair-waiting"), attemptId: PairingNonce }).strict(),
+  external_exports.object({
+    v: external_exports.literal(2),
+    type: external_exports.literal("paired"),
+    attemptId: PairingNonce,
+    token: external_exports.string().regex(/^llt_[A-Za-z0-9_-]{43}$/),
+    relaySecret: PairingNonce,
+    deviceId: external_exports.string().min(1).max(128)
+  }).strict(),
+  external_exports.object({ v: external_exports.literal(2), type: external_exports.literal("pair-error"), reason: external_exports.enum([
+    "update-required",
+    "invalid-input",
+    "expired",
+    "competing-attempt",
+    "cancelled",
+    "disconnected",
+    "unavailable"
+  ]) }).strict()
+]);
+var PAIRING_FRAME_LIMIT = 8192;
+
 // ../protocol/src/index.ts
 var PROTOCOL_VERSION = 1;
 var AgentKind = external_exports.enum(["claude", "gemini", "codex", "terminal"]);
@@ -5496,6 +5569,8 @@ var sessionStartedPayload = external_exports.object({
   origin: SessionOrigin.optional(),
   /** Who owns the process now; unlike origin, this changes after a safe handoff. */
   controller: external_exports.enum(["longleash", "external"]).optional(),
+  /** Where the process is controlled now; origin remains its historical birthplace. */
+  surface: SessionOrigin.optional(),
   /** Observation-only means the native surface is visible but has not exposed process control. */
   control: external_exports.enum(["full", "observe"]).optional(),
   /**
@@ -5531,6 +5606,8 @@ var sessionStatusPayload = external_exports.object({
   /** LongLeash's own gate for this session: whether it should page the phone at all. */
   gate: SessionGate.optional(),
   controller: external_exports.enum(["longleash", "external"]).optional(),
+  /** Current UI/process surface after a handoff. */
+  surface: SessionOrigin.optional(),
   /** Observation-only sessions are never presented as remotely stoppable or writable. */
   control: external_exports.enum(["full", "observe"]).optional(),
   /** Current overrides. An empty object explicitly means provider defaults. */
@@ -5547,6 +5624,13 @@ var streamDeltaPayload = external_exports.object({
   kind: external_exports.enum(["text", "tool", "thinking", "user"]),
   text: external_exports.string()
 }).passthrough();
+var transcriptResetPayload = external_exports.object({
+  reason: external_exports.enum(["provider-snapshot", "recovery"]),
+  blocks: external_exports.array(external_exports.object({
+    kind: external_exports.enum(["text", "tool", "thinking", "user"]),
+    text: external_exports.string().max(12e4)
+  }).strict()).max(80).optional()
+}).passthrough();
 var QuestionOption = external_exports.object({
   label: external_exports.string().min(1),
   description: external_exports.string().default(""),
@@ -5606,6 +5690,7 @@ function event(type, payload) {
 var SessionEventSchema = external_exports.discriminatedUnion("type", [
   event("session.started", sessionStartedPayload),
   event("session.status", sessionStatusPayload),
+  event("session.transcript.reset", transcriptResetPayload),
   event("stream.delta", streamDeltaPayload),
   event("approval.requested", approvalRequestedPayload),
   event("approval.decided", approvalDecidedPayload),
@@ -5709,6 +5794,20 @@ var takeOverMessage = external_exports.object({
   sessionId: external_exports.string().min(1),
   text: external_exports.string().min(1)
 }).passthrough();
+var reclaimSessionMessage = external_exports.object({
+  ...clientBase,
+  type: external_exports.literal("reclaimSession"),
+  sessionId: external_exports.string().min(1)
+}).passthrough();
+var renameSessionMessage = external_exports.object({
+  ...clientBase,
+  type: external_exports.literal("renameSession"),
+  sessionId: external_exports.string().min(1),
+  title: external_exports.string().trim().min(1).max(80).refine(
+    (value) => value.replace(/[\u0000-\u001f\u007f]/g, "").trim().length > 0,
+    "A session name needs visible text."
+  )
+}).passthrough();
 var previewDelegationMessage = external_exports.object({
   ...clientBase,
   type: external_exports.literal("previewDelegation"),
@@ -5851,6 +5950,8 @@ var ClientMessageSchema = external_exports.discriminatedUnion("type", [
   pushUnsubscribeMessage,
   pushTestMessage,
   takeOverMessage,
+  reclaimSessionMessage,
+  renameSessionMessage,
   setGateMessage,
   previewDelegationMessage,
   startDelegationMessage,
@@ -5884,7 +5985,12 @@ var EventLog = class {
         type TEXT NOT NULL,
         payload TEXT NOT NULL,
         PRIMARY KEY (session_id, seq)
-      )
+      );
+      CREATE TABLE IF NOT EXISTS session_aliases (
+        session_id TEXT PRIMARY KEY,
+        title TEXT NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
     `);
     this.now = opts.now ?? Date.now;
     this.insertStmt = this.rawDb.prepare(
@@ -5956,6 +6062,16 @@ var EventLog = class {
   latestTimestamp(sessionId) {
     return this.latestTsStmt.get(sessionId).ts;
   }
+  aliasFor(sessionId) {
+    const row = this.rawDb.prepare("SELECT title FROM session_aliases WHERE session_id = ?").get(sessionId);
+    return row?.title;
+  }
+  setAlias(sessionId, title) {
+    this.rawDb.prepare(
+      `INSERT INTO session_aliases (session_id, title, updated_at) VALUES (?, ?, ?)
+         ON CONFLICT(session_id) DO UPDATE SET title = excluded.title, updated_at = excluded.updated_at`
+    ).run(sessionId, title, this.now());
+  }
   pruneBefore(sessionId, uptoExclusive) {
     this.pruneStmt.run(sessionId, uptoExclusive);
   }
@@ -5998,6 +6114,13 @@ var completePairingInput = external_exports.object({
   deviceName: external_exports.string().min(1).max(64),
   publicKey: external_exports.string().min(1).optional()
 });
+var beginVerifiedInput = external_exports.object({
+  v: external_exports.literal(2),
+  challengeId: external_exports.string().min(1).max(128),
+  secret: PairingNonce,
+  deviceName: PairingDeviceName,
+  phoneNonce: PairingNonce
+}).strict();
 var id = (prefix) => `${prefix}_${randomBytes(12).toString("base64url")}`;
 var sha256Hex = (value) => createHash("sha256").update(value).digest("hex");
 var hashesMatch = (a, b) => timingSafeEqual(Buffer.from(a, "hex"), Buffer.from(b, "hex"));
@@ -6007,6 +6130,7 @@ var DeviceRegistry = class {
   challengeTtlMs;
   // Ephemeral by design: a daemon restart voids pending pairing QR codes.
   challenges = /* @__PURE__ */ new Map();
+  pairingResults = /* @__PURE__ */ new Map();
   revokedListeners = /* @__PURE__ */ new Set();
   pairedListeners = /* @__PURE__ */ new Set();
   constructor(path, opts = {}) {
@@ -6029,17 +6153,22 @@ var DeviceRegistry = class {
     this.now = opts.now ?? Date.now;
     this.challengeTtlMs = opts.challengeTtlMs ?? DEFAULT_CHALLENGE_TTL_MS;
   }
-  createPairingChallenge() {
+  createPairingChallenge(opts = {}) {
     this.sweepExpiredChallenges();
+    const version = opts.version ?? PAIRING_QR_VERSION;
+    if (version !== 1 && version !== 2) throw new PairingError("invalid-input", "Unsupported pairing version");
+    if (version === 2 && [...this.challenges.values()].filter((c) => c.version === 2).length >= 8) {
+      throw new PairingError("pending-limit", "Too many pending verifications \u2014 finish or wait for expiry");
+    }
     const challengeId = id("chl");
     const secret = randomBytes(32).toString("base64url");
     const expiresAt = this.now() + this.challengeTtlMs;
-    this.challenges.set(challengeId, { secretHash: sha256Hex(secret), expiresAt });
+    this.challenges.set(challengeId, { secretHash: sha256Hex(secret), expiresAt, version });
     return {
       challengeId,
       secret,
       expiresAt,
-      qrPayload: JSON.stringify({ v: PAIRING_QR_VERSION, challengeId, secret })
+      qrPayload: JSON.stringify({ v: version, challengeId, secret })
     };
   }
   completePairing(raw) {
@@ -6048,24 +6177,114 @@ var DeviceRegistry = class {
       throw new PairingError("invalid-input", parsed.error.message);
     }
     const input = parsed.data;
-    const challenge = this.challenges.get(input.challengeId);
-    if (!challenge) {
-      throw new PairingError("unknown-challenge", "Unknown or already-used pairing challenge");
+    const challenge = this.authorizeChallenge(input.challengeId, input.secret);
+    if (challenge.version !== 1) {
+      throw new PairingError("verification-required", "This QR requires verification on the phone and laptop");
     }
-    if (this.now() > challenge.expiresAt) {
+    this.challenges.delete(input.challengeId);
+    return this.commitDevice(input.deviceName, input.publicKey);
+  }
+  /** Foundation only: transport adapters must authenticate/decrypt BEFORE calling this. */
+  beginVerifiedPairing(raw, owner) {
+    const parsed = beginVerifiedInput.safeParse(raw);
+    if (!parsed.success) throw new PairingError("invalid-input", "Invalid v2 pairing request");
+    const input = parsed.data;
+    const challenge = this.authorizeChallenge(input.challengeId, input.secret);
+    if (challenge.version !== 2) {
+      throw new PairingError("update-required", "Update LongLeash and generate a new verified QR code");
+    }
+    if (challenge.pending) {
+      const previous = challenge.pending.transcript;
+      if (challenge.pending.owner === owner && previous.phoneNonce === input.phoneNonce && previous.deviceName === input.deviceName) {
+        return { ...previous };
+      }
       this.challenges.delete(input.challengeId);
+      throw new PairingError("competing-attempt", "A competing pairing attempt was detected \u2014 generate a new QR code");
+    }
+    const transcript = {
+      v: 2,
+      challengeId: input.challengeId,
+      attemptId: randomBytes(32).toString("base64url"),
+      phoneNonce: input.phoneNonce,
+      daemonNonce: randomBytes(32).toString("base64url"),
+      deviceName: input.deviceName,
+      expiresAt: challenge.expiresAt
+    };
+    const { code } = deriveVerifiedPairing(input.secret, transcript);
+    challenge.pending = { transcript, code, localConfirmed: false, ...owner ? { owner } : {} };
+    return { ...transcript };
+  }
+  getPairingResult(challengeId) {
+    this.sweepExpiredChallenges();
+    const result = this.pairingResults.get(challengeId);
+    return result ? { deviceId: result.deviceId } : null;
+  }
+  hasPairingChallenge(challengeId) {
+    this.sweepExpiredChallenges();
+    return this.challenges.has(challengeId);
+  }
+  /** Local operator cancellation also works before a phone has connected. */
+  cancelPairingChallenge(challengeId) {
+    this.challenges.delete(challengeId);
+  }
+  /** LOCAL ONLY. Never expose the laptop display code through a phone-facing route. */
+  getPairingVerification(challengeId) {
+    this.sweepExpiredChallenges();
+    const pending = this.challenges.get(challengeId)?.pending;
+    if (!pending) return null;
+    const { attemptId, deviceName, expiresAt } = pending.transcript;
+    return { attemptId, code: pending.code, deviceName, expiresAt };
+  }
+  /** LOCAL ONLY: a secret-authenticated loopback/CLI action, never a remote message. */
+  confirmPairingLocally(challengeId, attemptId) {
+    this.requireAttempt(challengeId, attemptId).localConfirmed = true;
+  }
+  /** Call only for an explicit phone 'Codes match' on this attempt's encrypted channel. */
+  finishVerifiedPairing(challengeId, attemptId) {
+    const pending = this.requireAttempt(challengeId, attemptId);
+    if (!pending.localConfirmed) {
+      throw new PairingError("local-confirmation-required", "Compare and confirm the code on your laptop first");
+    }
+    this.challenges.delete(challengeId);
+    const result = this.commitDevice(pending.transcript.deviceName);
+    this.pairingResults.set(challengeId, { deviceId: result.device.deviceId, expiresAt: this.now() + 6e4 });
+    return result;
+  }
+  /** Rejection and transport disconnect share the same terminal transition. */
+  cancelVerifiedPairing(challengeId, attemptId) {
+    this.requireAttempt(challengeId, attemptId);
+    this.challenges.delete(challengeId);
+  }
+  requireAttempt(challengeId, attemptId) {
+    const challenge = this.requireChallenge(challengeId);
+    if (!challenge.pending || challenge.pending.transcript.attemptId !== attemptId) {
+      throw new PairingError("unknown-attempt", "Unknown pairing attempt");
+    }
+    return challenge.pending;
+  }
+  requireChallenge(challengeId) {
+    const challenge = this.challenges.get(challengeId);
+    if (!challenge) throw new PairingError("unknown-challenge", "Unknown or already-used pairing challenge");
+    if (this.now() >= challenge.expiresAt) {
+      this.challenges.delete(challengeId);
       throw new PairingError("expired", "Pairing challenge expired \u2014 generate a new QR code");
     }
-    if (!hashesMatch(sha256Hex(input.secret), challenge.secretHash)) {
+    return challenge;
+  }
+  authorizeChallenge(challengeId, secret) {
+    const challenge = this.requireChallenge(challengeId);
+    if (!hashesMatch(sha256Hex(secret), challenge.secretHash)) {
       throw new PairingError("bad-secret", "Wrong pairing secret");
     }
-    this.challenges.delete(input.challengeId);
+    return challenge;
+  }
+  commitDevice(deviceName, publicKey) {
     const token = `llt_${randomBytes(32).toString("base64url")}`;
     const relaySecret = randomBytes(32).toString("base64url");
     const device = {
       deviceId: id("dev"),
-      name: input.deviceName,
-      publicKey: input.publicKey ?? null,
+      name: deviceName,
+      publicKey: publicKey ?? null,
       createdAt: this.now(),
       lastSeenAt: null,
       revokedAt: null
@@ -6133,12 +6352,15 @@ var DeviceRegistry = class {
     return rows.map((row) => this.toDevice(row));
   }
   close() {
+    this.challenges.clear();
+    this.pairingResults.clear();
     this.rawDb.close();
   }
   sweepExpiredChallenges() {
     const now = this.now();
+    for (const [id2, result] of this.pairingResults) if (now >= result.expiresAt) this.pairingResults.delete(id2);
     for (const [challengeId, challenge] of this.challenges) {
-      if (now > challenge.expiresAt) this.challenges.delete(challengeId);
+      if (now >= challenge.expiresAt) this.challenges.delete(challengeId);
     }
   }
   toDevice(row) {
@@ -7109,6 +7331,26 @@ var SessionManager = class {
       };
     });
   }
+  /** Find the stable LongLeash card that already owns this provider conversation id. */
+  sessionIdForAgentSession(agentSessionId) {
+    const row = this.approvals.rawDb.prepare("SELECT session_id FROM sessions WHERE agent_session_id = ? ORDER BY started_at DESC LIMIT 1").get(agentSessionId);
+    return row?.session_id;
+  }
+  /** Persist a human label independently of whatever title a provider derives later. */
+  renameSession(sessionId, title, emit = true) {
+    const changed = this.approvals.rawDb.prepare("UPDATE sessions SET title = ? WHERE session_id = ?").run(title, sessionId).changes;
+    if (changed === 0) return false;
+    const live = this.sessions.get(sessionId);
+    if (live !== void 0) live.title = title;
+    this.eventLog.setAlias(sessionId, title);
+    if (emit) {
+      this.emit(sessionId, {
+        type: "session.status",
+        payload: { status: live?.status ?? "waiting", live: live !== void 0, title }
+      });
+    }
+    return true;
+  }
   /**
    * Adopt a finished TERMINAL session so a phone reply can wake it: the
    * conversation lives in Claude Code's own storage, keyed by its resume id,
@@ -7821,7 +8063,7 @@ import { join as join2 } from "node:path";
 import Fastify from "fastify";
 import fastifyStatic from "@fastify/static";
 import websocket from "@fastify/websocket";
-import { randomBytes as randomBytes5, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+import { randomBytes as randomBytes6, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 
 // ../daemon/src/external.ts
 import { closeSync, existsSync, openSync, readSync, statSync } from "node:fs";
@@ -7880,6 +8122,7 @@ var ExternalSessions = class {
   stopTimeoutMs;
   onEnded;
   workspace;
+  resolveSessionId;
   unsubscribeWorkspace;
   constructor(opts) {
     this.eventLog = opts.eventLog;
@@ -7899,6 +8142,7 @@ var ExternalSessions = class {
     this.waitForExit = opts.waitForExit ?? ((pid, timeoutMs) => this.pollForExit(pid, timeoutMs));
     this.onEnded = opts.onEnded;
     this.workspace = opts.workspace;
+    this.resolveSessionId = opts.resolveSessionId;
     this.unsubscribeWorkspace = this.workspace?.subscribe(() => this.reconcileWorkspace());
     for (const orphan of this.approvals.closeOrphans(
       "The daemon restarted; this was answered in the terminal."
@@ -7922,6 +8166,38 @@ var ExternalSessions = class {
   hasLiveSession(sessionId) {
     return [...this.sessions.values()].some((session) => session.sessionId === sessionId);
   }
+  renameSession(sessionId, title) {
+    const entry = [...this.sessions.entries()].find(([, session2]) => session2.sessionId === sessionId);
+    if (entry === void 0) return false;
+    const [agentSessionId, session] = entry;
+    session.title = title;
+    session.named = true;
+    this.eventLog.setAlias(sessionId, title);
+    this.persist(agentSessionId, session);
+    this.emit(sessionId, {
+      type: "session.status",
+      payload: {
+        status: session.status,
+        live: true,
+        title,
+        controller: "external",
+        control: session.observedOnly ? "observe" : "full",
+        surface: session.surface
+      }
+    });
+    return true;
+  }
+  /**
+   * End a native writer so the same conversation can be parked on the phone.
+   * Observation-only sessions have no authenticated PID and are never remotely terminated.
+   */
+  async reclaimToPhone(externalSessionId, decidedBy) {
+    const session = [...this.sessions.values()].find((item) => item.sessionId === externalSessionId);
+    if (session === void 0) return "not-found";
+    if (session.observedOnly) return "observe-only";
+    if (session.pid === null) return "unverified";
+    return await this.stop(externalSessionId, decidedBy) ? "reclaimed" : "unverified";
+  }
   /**
    * Take back the sessions a previous run was watching.
    *
@@ -7950,7 +8226,7 @@ var ExternalSessions = class {
         transcriptPath: row.transcriptPath,
         status: "running",
         startedAt: row.startedAt,
-        title: row.title,
+        title: this.eventLog.aliasFor(row.sessionId) ?? row.title,
         pid: row.pid,
         named: true,
         permissionMode: null,
@@ -7968,7 +8244,13 @@ var ExternalSessions = class {
       session.timer.unref?.();
       this.emit(session.sessionId, {
         type: "session.status",
-        payload: { status: "running", live: true }
+        payload: {
+          status: "running",
+          live: true,
+          controller: "external",
+          control: "full",
+          surface: session.surface
+        }
       });
     }
   }
@@ -7984,22 +8266,35 @@ var ExternalSessions = class {
   /** Adopt a Codex transcript observed after startup, including sessions older than the hooks. */
   observeCodexSession(info) {
     const session = this.ensure(info.sessionId, info.cwd, info.transcriptPath, "codex", info.surface, true);
-    if (info.title !== void 0 && info.title !== session.title) {
+    const alias = this.eventLog.aliasFor(session.sessionId);
+    const nextTitle = alias ?? info.title;
+    if (nextTitle !== void 0 && nextTitle !== session.title) {
       session.named = true;
-      session.title = info.title;
+      session.title = nextTitle;
       this.persist(info.sessionId, session);
     }
+    if (session.observedOnly && session.observedFingerprint === void 0) {
+      session.observedFingerprint = JSON.stringify(info.snapshot);
+      this.emit(session.sessionId, {
+        type: "session.transcript.reset",
+        payload: { reason: "provider-snapshot", blocks: info.snapshot }
+      });
+    }
     this.emit(session.sessionId, {
       type: "session.status",
       payload: {
         status: session.status,
         live: true,
         controller: "external",
-        control: "observe",
-        ...info.title === void 0 ? {} : { title: info.title }
+        control: session.observedOnly ? "observe" : "full",
+        ...nextTitle === void 0 ? {} : { title: nextTitle }
       }
     });
-    this.claimWorkspace(session);
+    if (session.observedOnly) {
+      if (session.workspaceConflict !== void 0) delete session.workspaceConflict;
+    } else {
+      this.claimWorkspace(session);
+    }
   }
   /**
    * Stop a terminal session from the phone — for real. The recorded pid is only
@@ -8415,14 +8710,26 @@ var ExternalSessions = class {
         this.persist(claudeSessionId, existing);
         this.emit(existing.sessionId, {
           type: "session.status",
-          payload: { status: existing.status, live: true, controller: "external", control: "full" }
+          payload: {
+            status: existing.status,
+            live: true,
+            controller: "external",
+            control: "full",
+            surface: existing.surface
+          }
         });
+        if (existing.timer === null) {
+          existing.timer = setInterval(() => this.drain(existing), this.pollMs);
+          existing.timer.unref?.();
+          this.drain(existing);
+        }
       }
       return existing;
     }
-    const sessionId = `ext_${claudeSessionId}`;
+    const sessionId = this.resolveSessionId?.(claudeSessionId) ?? `ext_${claudeSessionId}`;
     const replay = this.eventLog.replay(sessionId, 0);
     const hasHistory = replay.gap === false ? replay.events.length > 0 : true;
+    const alias = this.eventLog.aliasFor(sessionId);
     const session = {
       sessionId,
       agent,
@@ -8431,9 +8738,9 @@ var ExternalSessions = class {
       transcriptPath,
       status: "running",
       startedAt: this.now(),
-      title: `${basename3(cwd)} \u2014 ${surface === "vscode" ? "VS Code" : AGENT_LABEL[agent]}`,
+      title: alias ?? `${basename3(cwd)} \u2014 ${surface === "vscode" ? "VS Code" : AGENT_LABEL[agent]}`,
       pid: null,
-      named: false,
+      named: alias !== void 0,
       permissionMode: null,
       gate: "ask",
       offset: (tailOnly || hasHistory) && existsSync(transcriptPath) ? statSync(transcriptPath).size : 0,
@@ -8454,6 +8761,7 @@ var ExternalSessions = class {
           origin: surface,
           controller: "external",
           control: tailOnly ? "observe" : "full",
+          surface,
           resumeId: claudeSessionId
         }
       });
@@ -8464,7 +8772,8 @@ var ExternalSessions = class {
         status: "running",
         live: true,
         controller: "external",
-        control: tailOnly ? "observe" : "full"
+        control: tailOnly ? "observe" : "full",
+        surface
       }
     });
     session.timer = setInterval(() => this.drain(session), this.pollMs);
@@ -8474,7 +8783,9 @@ var ExternalSessions = class {
   }
   /** Retry claims after startup reconciliation released dead managed-session ownership. */
   reconcileWorkspace() {
-    for (const session of this.sessions.values()) this.claimWorkspace(session);
+    for (const session of this.sessions.values()) {
+      if (!session.observedOnly) this.claimWorkspace(session);
+    }
   }
   claimWorkspace(session) {
     if (this.workspace === void 0 || session.cwd.trim() === "") return;
@@ -8674,6 +8985,139 @@ function transcriptDeltas(line) {
   return out;
 }
 
+// ../daemon/src/pairing-session.ts
+import { randomBytes as randomBytes4 } from "node:crypto";
+function createPairingSession(opts) {
+  const owner = randomBytes4(32).toString("base64url");
+  const rendezvous = derivePairingIdentity(opts.challenge.secret);
+  let transcript = null;
+  let identity = null;
+  let confirmed = false;
+  let disposed = false;
+  let committed = false;
+  let lastSeen = Date.now();
+  let windowAt = Date.now();
+  let frames = 0;
+  let queued = 0;
+  let chain = Promise.resolve();
+  let closing;
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    clearInterval(timer);
+    clearTimeout(closing);
+    if (transcript && !committed) opts.registry.cancelPairingChallenge(opts.challenge.challengeId);
+    opts.close();
+  };
+  const send = async (body, key = identity) => {
+    const payload = await seal(key ?? await rendezvous, JSON.stringify(body));
+    if (!disposed) opts.send(payload);
+  };
+  const fail = async (reason) => {
+    await send({ v: 2, type: "pair-error", reason });
+    dispose();
+  };
+  const tick = async () => {
+    if (disposed || committed) return;
+    if (Date.now() >= opts.challenge.expiresAt) return fail("expired");
+    if (!opts.registry.hasPairingChallenge(opts.challenge.challengeId)) return fail("cancelled");
+    if (transcript && Date.now() - lastSeen > 3e4) return fail("disconnected");
+    if (!confirmed || !transcript) return;
+    try {
+      const { device, token, relaySecret } = opts.registry.finishVerifiedPairing(opts.challenge.challengeId, transcript.attemptId);
+      committed = true;
+      await send({ v: 2, type: "paired", attemptId: transcript.attemptId, deviceId: device.deviceId, token, relaySecret });
+      clearInterval(timer);
+      closing = setTimeout(dispose, 500);
+      closing.unref?.();
+    } catch (err) {
+      if (err instanceof PairingError && err.reason === "local-confirmation-required") return;
+      await fail("unavailable");
+    }
+  };
+  const processFrame = async (payload) => {
+    if (disposed || committed) return;
+    const text = await open(identity ?? await rendezvous, payload);
+    if (disposed || committed) return;
+    if (text === null) {
+      if (identity) {
+        const competing = await open(await rendezvous, payload);
+        if (competing !== null) {
+          try {
+            const begin = PairingBegin.safeParse(JSON.parse(competing));
+            if (begin.success && begin.data.challengeId === opts.challenge.challengeId) {
+              opts.registry.cancelPairingChallenge(opts.challenge.challengeId);
+              await fail("competing-attempt");
+            }
+          } catch {
+          }
+        }
+      }
+      return;
+    }
+    let raw;
+    try {
+      raw = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (!transcript) {
+      if (raw?.v === 1) {
+        await send({ v: 1, type: "pair-error", reason: "update-required" });
+        dispose();
+        return;
+      }
+      const parsed2 = PairingBegin.safeParse(raw);
+      if (!parsed2.success || parsed2.data.challengeId !== opts.challenge.challengeId) return;
+      try {
+        transcript = opts.registry.beginVerifiedPairing({
+          v: 2,
+          challengeId: parsed2.data.challengeId,
+          secret: opts.challenge.secret,
+          deviceName: parsed2.data.deviceName,
+          phoneNonce: parsed2.data.phoneNonce
+        }, owner);
+        await send({ v: 2, type: "pair-transcript", transcript, remainingMs: Math.max(1, Math.min(3e5, opts.challenge.expiresAt - Date.now())) }, await rendezvous);
+        identity = deriveVerifiedPairing(opts.challenge.secret, transcript).identity;
+        lastSeen = Date.now();
+      } catch (err) {
+        await fail(err instanceof PairingError && err.reason === "competing-attempt" ? "competing-attempt" : "unavailable");
+      }
+      return;
+    }
+    const parsed = PairingDecision.safeParse(raw);
+    if (!parsed.success || parsed.data.attemptId !== transcript.attemptId) return;
+    lastSeen = Date.now();
+    if (parsed.data.type === "pair-reject") return fail("cancelled");
+    if (parsed.data.type === "pair-confirm") {
+      confirmed = true;
+      await send({ v: 2, type: "pair-waiting", attemptId: transcript.attemptId });
+      await tick();
+    }
+  };
+  const receive = (payload) => {
+    if (disposed || committed) return Promise.resolve();
+    if (Date.now() - windowAt >= 6e4) {
+      windowAt = Date.now();
+      frames = 0;
+    }
+    if (payload.length > PAIRING_FRAME_LIMIT || ++frames > 60 || queued >= 8) {
+      dispose();
+      return Promise.resolve();
+    }
+    queued++;
+    chain = chain.then(() => processFrame(payload)).catch(() => dispose()).finally(() => {
+      queued--;
+    });
+    return chain;
+  };
+  const timer = setInterval(() => {
+    chain = chain.then(tick).catch(() => dispose());
+  }, 250);
+  timer.unref?.();
+  return { receive, dispose, tick };
+}
+
 // ../daemon/src/relay-link.ts
 import WebSocket from "ws";
 function withRoom(endpoint, roomTag, role) {
@@ -9038,7 +9482,7 @@ var BriefingBuilder = class {
 };
 
 // ../daemon/src/delegations.ts
-import { randomBytes as randomBytes4 } from "node:crypto";
+import { randomBytes as randomBytes5 } from "node:crypto";
 var DelegationError = class extends Error {
   constructor(reason, message) {
     super(message);
@@ -9048,7 +9492,7 @@ var DelegationError = class extends Error {
 };
 var TARGET_AGENTS = /* @__PURE__ */ new Set(["claude", "codex"]);
 var TERMINAL = /* @__PURE__ */ new Set(["returned", "cancelled", "failed"]);
-var newId3 = () => `del_${randomBytes4(9).toString("base64url")}`;
+var newId3 = () => `del_${randomBytes5(9).toString("base64url")}`;
 var DelegationStore = class {
   db;
   now;
@@ -10024,6 +10468,10 @@ var LongLeashServer = class {
   delegations = null;
   hookSecret = null;
   localPairing = null;
+  pairingChallenges = /* @__PURE__ */ new Map();
+  pairingSockets = /* @__PURE__ */ new Set();
+  pairingRequests = [];
+  pairingCleanups = /* @__PURE__ */ new Set();
   staticRoot;
   /** Captured at process start so updating files on disk cannot impersonate a daemon restart. */
   expectedBuild;
@@ -10050,6 +10498,7 @@ var LongLeashServer = class {
       ok: true,
       name: "longleash",
       protocol: PROTOCOL_VERSION,
+      pairingVersion: 2,
       // A version is not machine data. Exposing it turns "connection refused / is this old?"
       // from guesswork into a doctor check and prevents testing a daemon that never restarted.
       build: this.expectedBuild
@@ -10125,7 +10574,7 @@ var LongLeashServer = class {
     });
     const localOnly = (request) => {
       const presented = request.headers["x-longleash-hook"];
-      return this.hookSecret !== null && typeof presented === "string" && presented.length === this.hookSecret.length && timingSafeEqual2(Buffer.from(presented), Buffer.from(this.hookSecret));
+      return !request.headers.origin && this.hookSecret !== null && typeof presented === "string" && Buffer.byteLength(presented) === Buffer.byteLength(this.hookSecret) && timingSafeEqual2(Buffer.from(presented), Buffer.from(this.hookSecret));
     };
     this.app.get("/devices", async (request, reply) => {
       if (!localOnly(request)) return reply.code(401).send({ reason: "unauthorized" });
@@ -10153,13 +10602,82 @@ var LongLeashServer = class {
     });
     this.app.post("/local/pairing", async (request, reply) => {
       if (!localOnly(request)) return reply.code(401).send({ reason: "unauthorized" });
+      this.pairingRequests = this.pairingRequests.filter((at) => Date.now() - at < 6e4);
+      if (this.pairingRequests.length >= 10) return reply.code(429).send({ reason: "rate-limited" });
+      this.pairingRequests.push(Date.now());
       if (this.localPairing === null) return reply.code(503).send({ reason: "pairing-unavailable" });
       try {
-        return { url: this.localPairing() };
+        const url2 = this.localPairing();
+        const challengeId = new URLSearchParams(new URL(url2).hash.slice(1)).get("c");
+        const challenge = challengeId ? this.pairingChallenges.get(challengeId) : void 0;
+        return { url: url2, version: 2, challengeId, expiresAt: challenge?.expiresAt };
       } catch {
         return reply.code(503).send({ reason: "pairing-failed" });
       }
     });
+    const localPairingInput = external_exports.object({
+      challengeId: external_exports.string().min(1).max(128),
+      attemptId: external_exports.string().regex(/^[A-Za-z0-9_-]{43}$/).optional()
+    }).strict();
+    for (const action of ["status", "confirm", "cancel"]) {
+      this.app.post(`/local/pairing/${action}`, async (request, reply) => {
+        if (!localOnly(request)) return reply.code(401).send({ reason: "unauthorized" });
+        const input = localPairingInput.safeParse(request.body);
+        if (!input.success) return reply.code(400).send({ reason: "invalid-input" });
+        const { challengeId, attemptId } = input.data;
+        if (action === "cancel") {
+          this.registry.cancelPairingChallenge(challengeId);
+          return { cancelled: true };
+        }
+        const result = this.registry.getPairingResult(challengeId);
+        if (action === "status" && result) return { state: "paired", deviceId: result.deviceId };
+        if (!this.registry.hasPairingChallenge(challengeId)) return reply.code(410).send({ reason: "ended" });
+        if (action === "status") return { verification: this.registry.getPairingVerification(challengeId) };
+        if (!attemptId) return reply.code(400).send({ reason: "invalid-input" });
+        try {
+          this.registry.confirmPairingLocally(challengeId, attemptId);
+          return { confirmed: true };
+        } catch {
+          return reply.code(409).send({ reason: "attempt-ended" });
+        }
+      });
+    }
+    this.app.get("/pair/v2", { websocket: true }, (socket, request) => {
+      const challengeId = request.query.c ?? "";
+      const challenge = this.pairingChallenges.get(challengeId);
+      if (!challenge || !this.registry.hasPairingChallenge(challengeId) || this.pairingSockets.size >= 16) {
+        socket.close(4403, "Pairing unavailable; generate a fresh QR");
+        return;
+      }
+      this.pairingSockets.add(socket);
+      const session = createPairingSession({
+        registry: this.registry,
+        challenge,
+        send: (payload) => {
+          if (socket.readyState === socket.OPEN) socket.send(JSON.stringify({ v: 1, type: "frame", payload }));
+        },
+        close: () => socket.close()
+      });
+      this.pairingCleanups.add(session.dispose);
+      socket.on("message", (raw) => {
+        if (String(raw).length > 9e3) {
+          session.dispose();
+          return;
+        }
+        try {
+          const message = JSON.parse(String(raw));
+          if (message.type === "frame" && typeof message.payload === "string") void session.receive(message.payload);
+        } catch {
+        }
+      });
+      socket.on("close", () => {
+        session.dispose();
+        this.pairingSockets.delete(socket);
+        this.pairingCleanups.delete(session.dispose);
+      });
+      socket.on("error", session.dispose);
+      socket.send(JSON.stringify({ v: 2, type: "pair-ready" }));
+    });
     this.app.get("/pair", async (_request, reply) => reply.code(405).send({ reason: "use-post" }));
     this.app.post("/pair", async (request, reply) => {
       const query2 = request.query;
@@ -10265,7 +10783,7 @@ var LongLeashServer = class {
    */
   async rebind(host) {
     const wanted = this.boundPort;
-    await new Promise((resolve7) => this.app.server.close(() => resolve7()));
+    if (this.app.server.listening) await new Promise((resolve7) => this.app.server.close(() => resolve7()));
     const tryListen = (port) => new Promise((resolve7, reject) => {
       const onError = (err) => {
         this.app.server.removeListener("listening", onListening);
@@ -10302,6 +10820,21 @@ var LongLeashServer = class {
   attachLocalPairing(create) {
     this.localPairing = create;
   }
+  /** Only transient memory; URLs/secrets must never reach logs or the event database. */
+  registerPairingChallenge(challenge) {
+    for (const [id2, previous] of this.pairingChallenges) {
+      if (previous.expiresAt <= Date.now() || !this.registry.hasPairingChallenge(id2)) this.pairingChallenges.delete(id2);
+    }
+    this.pairingChallenges.set(challenge.challengeId, challenge);
+    const cleanup = () => {
+      clearTimeout(timer);
+      this.pairingChallenges.delete(challenge.challengeId);
+      this.pairingCleanups.delete(cleanup);
+    };
+    const timer = setTimeout(cleanup, Math.max(0, challenge.expiresAt - Date.now()));
+    timer.unref?.();
+    this.pairingCleanups.add(cleanup);
+  }
   /** Persist an event, then fan it out to every subscriber of that session. */
   publish(sessionId, input) {
     const event2 = this.eventLog.append(sessionId, input);
@@ -10322,6 +10855,9 @@ var LongLeashServer = class {
     return this.connections.size;
   }
   async close() {
+    for (const cleanup of this.pairingCleanups) cleanup();
+    for (const socket of this.pairingSockets) socket.terminate();
+    this.pairingChallenges.clear();
     if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
     this.heartbeatTimer = null;
     this.unsubscribeRevoked?.();
@@ -10412,6 +10948,9 @@ var LongLeashServer = class {
   }
   /** Tell the client what it may do, so it never has to guess a project path. */
   sendHello(connection) {
+    const bySession = new Map(
+      [...this.sessions?.listSessions() ?? [], ...this.external?.listSessions() ?? []].map((session) => [session.sessionId, session])
+    );
     this.sendTo(connection, {
       v: PROTOCOL_VERSION,
       type: "hello",
@@ -10419,8 +10958,9 @@ var LongLeashServer = class {
       roots: this.sessions?.listAllowedRoots() ?? [],
       // Everything the daemon knows about, so a reloaded phone rebuilds instead of showing
       // nothing — including sessions the human started in a terminal.
-      sessions: [...this.sessions?.listSessions() ?? [], ...this.external?.listSessions() ?? []].map((session) => ({
+      sessions: [...bySession.values()].map((session) => ({
         ...session,
+        title: this.eventLog.aliasFor(session.sessionId) ?? session.title,
         lastActivityAt: this.eventLog.latestTimestamp(session.sessionId) || session.startedAt
       })).sort((left, right) => left.startedAt - right.startedAt || left.sessionId.localeCompare(right.sessionId)),
       capabilities: {
@@ -10794,8 +11334,60 @@ var LongLeashServer = class {
       });
       return;
     }
+    if (message.type === "renameSession") {
+      const title = message.title.replace(/[\u0000-\u001f\u007f]/g, " ").replace(/\s+/g, " ").trim();
+      const externalRenamed = this.external?.renameSession(message.sessionId, title) === true;
+      const managedRenamed = this.sessions.renameSession(message.sessionId, title, !externalRenamed);
+      const renamed = externalRenamed || managedRenamed;
+      this.log(`rename ${message.sessionId} -> ${renamed ? "renamed" : "unknown"}`);
+      this.sendTo(connection, {
+        v: PROTOCOL_VERSION,
+        type: "ack",
+        of: "renameSession",
+        sessionId: message.sessionId,
+        outcome: renamed ? "renamed" : "unknown-session"
+      });
+      if (!renamed) {
+        this.sendTo(connection, {
+          v: PROTOCOL_VERSION,
+          type: "error",
+          code: "unknown-session",
+          message: "This conversation is no longer known to the laptop, so its name was not changed."
+        });
+      }
+      return;
+    }
+    if (message.type === "reclaimSession") {
+      const sessionManager = this.sessions;
+      void (async () => {
+        const outcome = await this.external?.reclaimToPhone(message.sessionId, connection.deviceId) ?? "not-found";
+        let reopened = false;
+        if (outcome === "reclaimed") {
+          reopened = await sessionManager.resumeSession(message.sessionId, connection.deviceId);
+        }
+        const success = outcome === "reclaimed" && reopened;
+        this.log(`reclaim ${message.sessionId} -> ${success ? "phone-ready" : outcome}`);
+        this.sendTo(connection, {
+          v: PROTOCOL_VERSION,
+          type: "ack",
+          of: "reclaimSession",
+          sessionId: message.sessionId,
+          outcome: success ? "phone-ready" : outcome
+        });
+        if (!success) {
+          const detail = outcome === "observe-only" ? "This VS Code conversation is visible, but its lifecycle hook has not provided a verified process handle. Stop it in VS Code; LongLeash will make the same conversation reopenable when SessionEnd arrives." : outcome === "unverified" ? "LongLeash could not verify that the Terminal or VS Code writer exited, so it kept control there. Nothing was started on the phone." : outcome === "reclaimed" ? "The native writer ended, but this provider did not expose a recoverable conversation point. Nothing new was started." : "This native session is no longer connected to the laptop daemon.";
+          this.sendTo(connection, {
+            v: PROTOCOL_VERSION,
+            type: "error",
+            code: "cannot-reclaim",
+            message: detail
+          });
+        }
+      })();
+      return;
+    }
     if (message.type === "setGate") {
-      const applied = this.external !== null && message.sessionId.startsWith("ext_") ? this.external.setGate(message.sessionId, message.gate) : false;
+      const applied = this.external !== null && this.external.hasLiveSession(message.sessionId) ? this.external.setGate(message.sessionId, message.gate) : false;
       this.log(`gate ${message.sessionId} -> ${message.gate}${applied ? "" : " (unknown session)"}`);
       this.sendTo(connection, {
         v: PROTOCOL_VERSION,
@@ -10873,7 +11465,7 @@ var LongLeashServer = class {
       return;
     }
     if (message.type === "takeOver") {
-      const reservationId = `takeover-${randomBytes5(9).toString("base64url")}`;
+      const reservationId = `takeover-${randomBytes6(9).toString("base64url")}`;
       const sessions = this.sessions;
       void (async () => {
         const conflict = this.workspaceConflictMessage(message.sessionId);
@@ -10933,7 +11525,7 @@ var LongLeashServer = class {
       return;
     }
     if (message.type === "stopSession") {
-      if (message.sessionId.startsWith("ext_") && this.external !== null) {
+      if (this.external?.hasLiveSession(message.sessionId) === true) {
         const sessions = this.sessions;
         void this.external.stop(message.sessionId, connection.deviceId).then((stopped) => {
           if (stopped) {
@@ -12325,8 +12917,11 @@ function inside(root, candidate) {
 }
 function inspectCodexTranscript(path, roots2, maxTailBytes = MAX_INITIAL_TAIL) {
   let size;
+  let activityAt;
   try {
-    size = statSync2(path).size;
+    const stats = statSync2(path);
+    size = stats.size;
+    activityAt = stats.mtimeMs;
   } catch {
     return null;
   }
@@ -12345,6 +12940,7 @@ function inspectCodexTranscript(path, roots2, maxTailBytes = MAX_INITIAL_TAIL) {
     const lines = tailText.split("\n");
     if (tailOffset > 0) lines.shift();
     let title;
+    const snapshot = [];
     for (let index = lines.length - 1; index >= 0; index -= 1) {
       const line = lines[index];
       if (!line?.includes('"role":"user"')) continue;
@@ -12359,8 +12955,31 @@ function inspectCodexTranscript(path, roots2, maxTailBytes = MAX_INITIAL_TAIL) {
       } catch {
       }
     }
+    for (const line of lines) {
+      if (line.length === 0 || line.length > 1e6) continue;
+      try {
+        for (const delta of transcriptDeltas(JSON.parse(line))) {
+          if (delta.type !== "stream.delta" || delta.payload.text.trim() === "") continue;
+          snapshot.push({ kind: delta.payload.kind, text: delta.payload.text });
+        }
+      } catch {
+      }
+    }
+    let retained = snapshot.slice(-80);
+    let characters = retained.reduce((sum, block) => sum + block.text.length, 0);
+    while (retained.length > 1 && characters > 12e4) {
+      characters -= retained.shift()?.text.length ?? 0;
+    }
     if (title === void 0) title = titleFrom(latestUserText(tailText) ?? "") ?? void 0;
-    return { sessionId, cwd, transcriptPath: path, surface, ...title === void 0 ? {} : { title } };
+    return {
+      sessionId,
+      cwd,
+      transcriptPath: path,
+      surface,
+      activityAt,
+      snapshot: retained,
+      ...title === void 0 ? {} : { title }
+    };
   } catch {
     return null;
   }
@@ -12384,7 +13003,7 @@ var CodexSessionWatcher = class {
     this.timer = null;
   }
   scan(initial = false) {
-    const root = this.options.sessionsRoot ?? join6(homedir3(), ".codex", "sessions");
+    const root = this.options.sessionsRoot ?? join6(process.env.CODEX_HOME || join6(homedir3(), ".codex"), "sessions");
     const now = this.options.now?.() ?? Date.now();
     let observed = 0;
     for (const path of jsonlFiles(root)) {
@@ -12396,7 +13015,7 @@ var CodexSessionWatcher = class {
       }
       const previous = this.mtimes.get(path);
       this.mtimes.set(path, modified);
-      const changed = previous !== void 0 && modified > previous;
+      const changed = previous === void 0 ? !initial : modified !== previous;
       const recentlyActive = initial && now - modified <= this.options.initialRecentMs;
       if (!changed && !recentlyActive) continue;
       const previousSession = this.known.get(path);
@@ -12593,6 +13212,7 @@ async function startDaemon(options) {
     registry: sessionRegistry,
     onEvent: mirror,
     workspace,
+    resolveSessionId: (agentSessionId) => sessions.sessionIdForAgentSession(agentSessionId),
     // A live socket means the app is open and can answer in seconds. A push REGISTRATION is
     // permanent and proves nothing about whether anyone is looking — treating it as presence
     // is what froze the keyboard for two minutes with the phone in a drawer.
@@ -12617,7 +13237,7 @@ async function startDaemon(options) {
   external.startSweeping();
   const delegationStore = new DelegationStore(approvals.rawDb);
   workspace.reconcile({
-    activeSessionIds: external.listSessions().map((session) => session.sessionId),
+    activeSessionIds: external.listSessions().filter((session) => session.control === "full").map((session) => session.sessionId),
     validReservationIds: delegationStore.list().filter((record) => record.status === "starting").map((record) => record.delegationId)
   });
   external.reconcileWorkspace();
@@ -12635,14 +13255,20 @@ async function startDaemon(options) {
     pauseSession: (session, actor, reason) => pauseCurrentSessionOwner(sessions, external, session, actor, reason)
   });
   server.attachDelegations(delegationManager);
-  const hookSecret = randomBytes6(24).toString("base64url");
+  const hookSecret = randomBytes7(24).toString("base64url");
   server.attachExternal(external, hookSecret);
   const { port } = await server.listen();
-  writeFileSync2(
-    join7(dataDir2, "hook-endpoint.json"),
-    JSON.stringify({ url: `http://${options.host}:${port}/hook`, secret: hookSecret }, null, 2) + "\n",
-    { mode: 384 }
-  );
+  const endpointPath = join7(dataDir2, "hook-endpoint.json");
+  const publishHookEndpoint = (host, boundPort) => {
+    const staged = `${endpointPath}.${randomBytes7(8).toString("hex")}.tmp`;
+    try {
+      writeFileSync2(staged, JSON.stringify({ url: `http://${host}:${boundPort}/hook`, secret: hookSecret }, null, 2) + "\n", { mode: 384 });
+      renameSync(staged, endpointPath);
+    } finally {
+      rmSync(staged, { force: true });
+    }
+  };
+  publishHookEndpoint(options.host, port);
   const stopMaintenance = sessions.startMaintenance();
   let bridge = null;
   if (options.relayUrl !== void 0) {
@@ -12652,6 +13278,11 @@ async function startDaemon(options) {
   }
   return {
     server,
+    rebindLocal: async (host) => {
+      const reboundPort = await server.rebind(host);
+      publishHookEndpoint(host, reboundPort);
+      return reboundPort;
+    },
     sessions,
     registry,
     eventLog,
@@ -12711,7 +13342,62 @@ function save(path, config) {
 }
 
 // ../daemon/src/pairing-host.ts
+import WebSocket3 from "ws";
+
+// ../daemon/src/pairing-relay-v2.ts
 import WebSocket2 from "ws";
+function hostVerifiedPairing(opts) {
+  let socket = null;
+  let session = null;
+  let disposed = false;
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    clearTimeout(deadline);
+    clearInterval(keepalive);
+    session?.dispose();
+    opts.registry.cancelPairingChallenge(opts.challenge.challengeId);
+    socket?.close();
+  };
+  const deadline = setTimeout(dispose, Math.max(0, opts.challenge.expiresAt - Date.now()));
+  deadline.unref?.();
+  const keepalive = setInterval(() => {
+    if (!opts.registry.hasPairingChallenge(opts.challenge.challengeId)) {
+      dispose();
+      return;
+    }
+    if (socket?.readyState === WebSocket2.OPEN) socket.send(JSON.stringify({ v: 1, type: "ping" }));
+  }, 1e4);
+  keepalive.unref?.();
+  void derivePairingIdentity(opts.challenge.secret).then((identity) => {
+    if (disposed) return;
+    const ws = new WebSocket2(withRoom(opts.relayUrl, identity.roomTag, "host"), { maxPayload: 1e4 });
+    socket = ws;
+    session = createPairingSession({
+      registry: opts.registry,
+      challenge: opts.challenge,
+      send: (payload) => {
+        if (ws.readyState === WebSocket2.OPEN) ws.send(JSON.stringify({ v: 1, type: "frame", payload }));
+      },
+      close: dispose
+    });
+    ws.on("open", () => ws.send(JSON.stringify({ v: 1, type: "join", room: identity.roomTag, role: "host" })));
+    ws.on("close", dispose);
+    ws.on("error", dispose);
+    ws.on("message", (raw) => {
+      if (disposed) return;
+      try {
+        const message = JSON.parse(String(raw));
+        if (message.type === "frame" && typeof message.payload === "string") void session?.receive(message.payload);
+        if (message.type === "peer" && message.role === "guest" && message.event === "left") dispose();
+      } catch {
+      }
+    });
+  }).catch(dispose);
+  return dispose;
+}
+
+// ../daemon/src/pairing-host.ts
 var CompletePairing = external_exports.object({
   v: external_exports.literal(1),
   type: external_exports.literal("completePairing"),
@@ -12720,6 +13406,7 @@ var CompletePairing = external_exports.object({
   deviceName: external_exports.string().min(1).max(64)
 });
 function hostPairing(opts) {
+  if (JSON.parse(opts.challenge.qrPayload).v === 2) return hostVerifiedPairing(opts);
   const log = opts.log ?? (() => {
   });
   let socket = null;
@@ -12738,7 +13425,7 @@ function hostPairing(opts) {
       return;
     }
     if (disposed) return;
-    const ws = new WebSocket2(withRoom(opts.relayUrl, identity.roomTag, "host"));
+    const ws = new WebSocket3(withRoom(opts.relayUrl, identity.roomTag, "host"));
     socket = ws;
     ws.on("open", () => {
       ws.send(JSON.stringify({ v: 1, type: "join", room: identity.roomTag, role: "host" }));
@@ -12781,7 +13468,7 @@ function hostPairing(opts) {
             reason: err instanceof PairingError ? err.reason : "error"
           };
         }
-        if (ws.readyState === WebSocket2.OPEN) {
+        if (ws.readyState === WebSocket3.OPEN) {
           ws.send(JSON.stringify({ v: 1, type: "frame", payload: await seal(identity, JSON.stringify(reply)) }));
         }
         if (succeeded) setTimeout(dispose, 500);
@@ -12794,10 +13481,10 @@ function hostPairing(opts) {
 }
 
 // ../daemon/src/pairing-url.ts
-function pairingUrl(appOrigin, challengeId, secret) {
+function pairingUrl(appOrigin, challengeId, secret, version = 1) {
   const url2 = new URL(appOrigin);
   url2.search = "";
-  url2.hash = new URLSearchParams({ c: challengeId, s: secret }).toString();
+  url2.hash = new URLSearchParams({ c: challengeId, s: secret, ...version === 2 ? { v: "2" } : {} }).toString();
   return url2.toString();
 }
 
@@ -12945,7 +13632,7 @@ function noAddressReason(interfaces = networkInterfaces()) {
 }
 
 // ../daemon/src/instance-lock.ts
-import { closeSync as closeSync3, lstatSync, mkdirSync as mkdirSync5, openSync as openSync3, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { closeSync as closeSync3, lstatSync, mkdirSync as mkdirSync5, openSync as openSync3, readFileSync as readFileSync5, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { join as join9 } from "node:path";
 var LOCK_NAME = "daemon.lock";
@@ -12979,7 +13666,7 @@ function acquireDaemonInstance(dataDir2) {
     if (processAlive(owner.pid)) {
       throw new Error(`LongLeash already owns this data directory in process ${owner.pid}. Use \`longleash service status\` before starting another instance.`);
     }
-    rmSync(path);
+    rmSync2(path);
     create();
   }
   let held = true;
@@ -12990,7 +13677,7 @@ function acquireDaemonInstance(dataDir2) {
       held = false;
       try {
         const owner = JSON.parse(readFileSync5(path, "utf8"));
-        if (owner.token === token) rmSync(path);
+        if (owner.token === token) rmSync2(path);
       } catch {
       }
     }
@@ -13141,20 +13828,61 @@ function relayAppOrigin(wsUrl) {
   parsed.pathname = "/";
   return parsed.toString();
 }
-function freshPairingUrl() {
-  const challenge = daemon.registry.createPairingChallenge();
+var foregroundChallenge = null;
+var displayedAttempt = null;
+var relayPairings = /* @__PURE__ */ new Set();
+function freshPairingUrl(foreground = false) {
+  if (foreground && foregroundChallenge) daemon.registry.cancelPairingChallenge(foregroundChallenge);
+  const challenge = daemon.registry.createPairingChallenge({ version: 2 });
+  daemon.server.registerPairingChallenge(challenge);
+  if (foreground) {
+    foregroundChallenge = challenge.challengeId;
+    displayedAttempt = null;
+  }
   if (relay !== null) {
-    hostPairing({ registry: daemon.registry, relayUrl: relay.url, challenge, log: (line) => daemonLog(`[pair] ${line}`) });
-    return pairingUrl(relayAppOrigin(relay.url), challenge.challengeId, challenge.secret);
+    const dispose = hostPairing({ registry: daemon.registry, relayUrl: relay.url, challenge });
+    relayPairings.add(dispose);
+    setTimeout(() => {
+      dispose();
+      relayPairings.delete(dispose);
+    }, Math.max(0, challenge.expiresAt - Date.now())).unref?.();
+    return pairingUrl(relayAppOrigin(relay.url), challenge.challengeId, challenge.secret, 2);
   }
   return pairingUrl(
     `http://${servingHost}:${servingPort}/`,
     challenge.challengeId,
-    challenge.secret
+    challenge.secret,
+    2
   );
 }
-daemon.server.attachLocalPairing(freshPairingUrl);
-var url = serviceMode ? null : freshPairingUrl();
+daemon.server.attachLocalPairing(() => freshPairingUrl());
+var interactivePairing = !serviceMode && Boolean(process.stdin.isTTY && process.stdout.isTTY);
+var url = interactivePairing ? freshPairingUrl(true) : null;
+var pairingWatch = setInterval(() => {
+  if (!foregroundChallenge) return;
+  const result = daemon.registry.getPairingResult(foregroundChallenge);
+  if (result) {
+    console.log(`Paired ${result.deviceId}. Keep the QR private.`);
+    foregroundChallenge = null;
+    displayedAttempt = null;
+    return;
+  }
+  if (!daemon.registry.hasPairingChallenge(foregroundChallenge)) {
+    console.log("Pairing ended. Press n + Enter for a fresh QR.");
+    foregroundChallenge = null;
+    displayedAttempt = null;
+    return;
+  }
+  const verification = daemon.registry.getPairingVerification(foregroundChallenge);
+  if (verification && verification.attemptId !== displayedAttempt) {
+    displayedAttempt = verification.attemptId;
+    console.log(`
+Compare with your phone:  ${verification.code}
+Type y + Enter only if every digit matches, or x + Enter to reject.
+`);
+  }
+}, 250);
+pairingWatch.unref?.();
 console.log("\n=== LongLeash ===\n");
 var warn = vpnWarning();
 if (warn) console.log(`!!! ${warn}
@@ -13198,23 +13926,28 @@ Listening on ${servedHost}:${daemon.port} (no local network \u2014 relay only)`
   console.log(
     relay !== null ? `Relay: ${relay.url} \u2014 your phone can reach this laptop from anywhere.` : "Relay: not configured (LAN only). Set LONGLEASH_RELAY_URL once to enable remote access \u2014 it is remembered."
   );
-  console.log("\nScan this with your phone, then add it to your home screen:\n");
-  console.log(terminalQr(url));
-  console.log(`
+  if (url) {
+    console.log("\nScan this with your phone, then compare both verification codes. Keep this terminal open:\n");
+    console.log(terminalQr(url));
+    console.log(`
   ${url}
 `);
-  if (relay !== null && servedOnLan) {
-    console.log(`(LAN fallback for pairing at home: http://${servedHost}:${daemon.port}/#c=\u2026&s=\u2026 \u2014 same code)`);
-  }
+    if (relay !== null && servedOnLan) {
+      console.log("Use this same QR for the encrypted relay pairing flow.");
+    }
+  } else console.log("Run longleash pair in an interactive terminal to pair. No QR is printed to redirected output.");
 }
 var NETWORK_WATCH_MS = 5e3;
+var networkRebindInFlight = false;
 var networkWatch = setInterval(() => {
+  if (networkRebindInFlight) return;
   const nextBest = findCandidates()[0];
   const nextHost = nextBest?.address ?? "127.0.0.1";
   if (nextHost === servingHost) return;
   const was = servingHost;
-  servingHost = nextHost;
-  void daemon.server.rebind(nextHost).then((port) => {
+  networkRebindInFlight = true;
+  void daemon.rebindLocal(nextHost).then((port) => {
+    servingHost = nextHost;
     servingPort = port;
     console.log(serviceMode ? "\nNetwork changed; the local listener recovered." : `
 Network changed: ${was} -> ${nextHost}. Now serving ${nextHost}:${port}.`);
@@ -13225,6 +13958,8 @@ Network changed: ${was} -> ${nextHost}. Now serving ${nextHost}:${port}.`);
     console.log(serviceMode ? "\nNetwork changed but local listener recovery failed; details omitted." : `
 Network changed but rebinding failed (${String(err)}).`);
     console.log(relay !== null ? "The relay is unaffected." : "Restart the daemon to recover.");
+  }).finally(() => {
+    networkRebindInFlight = false;
   });
 }, NETWORK_WATCH_MS);
 networkWatch.unref?.();
@@ -13232,20 +13967,38 @@ if (!serviceMode) console.log("Press n + Enter for a fresh pairing QR, r + Enter
 process.stdin.setEncoding("utf8");
 process.stdin.on("data", (chunk) => {
   const key = chunk.trim().toLowerCase();
-  if (key === "n" && !serviceMode) {
-    const next = freshPairingUrl();
+  if (key === "n" && interactivePairing) {
+    let next;
+    try {
+      next = freshPairingUrl(true);
+    } catch {
+      console.log("Too many pending QRs. Wait for expiry before trying again.");
+      return;
+    }
     console.log("\nScan this with your phone:\n");
     console.log(terminalQr(next));
     console.log(`
   ${next}
 `);
   }
+  if ((key === "y" || key === "x") && foregroundChallenge && displayedAttempt && interactivePairing) {
+    try {
+      if (key === "y") {
+        daemon.registry.confirmPairingLocally(foregroundChallenge, displayedAttempt);
+        console.log("Laptop confirmed. Choose Codes match on your phone to finish.");
+      } else daemon.registry.cancelPairingChallenge(foregroundChallenge);
+    } catch {
+      console.log("That pairing ended. Press n + Enter for a fresh QR.");
+    }
+  }
   if (key === "r") {
     const active = daemon.registry.listDevices().filter((d) => d.revokedAt === null);
     for (const device of active) daemon.registry.revokeDevice(device.deviceId);
     console.log(`>>> revoked ${active.length} device(s); their live connections are cut`);
   }
   if (key === "q") {
+    clearInterval(pairingWatch);
+    for (const dispose of relayPairings) dispose();
     clearInterval(networkWatch);
     void daemon.stop().then(() => {
       instanceLock.release();
@@ -13254,6 +14007,8 @@ process.stdin.on("data", (chunk) => {
   }
 });
 var shutdown = () => {
+  clearInterval(pairingWatch);
+  for (const dispose of relayPairings) dispose();
   clearInterval(networkWatch);
   void daemon.stop().then(() => {
     instanceLock.release();