pair-mode 0.3.0 → 0.3.3

package/dist/cli.js

@@ -7361,8 +7361,8 @@ var require_dist = __commonJS({
 });
 
 // src/cli/index.ts
-import { readFileSync as readFileSync8 } from "node:fs";
-import { join as join13, resolve as resolve2 } from "node:path";
+import { readFileSync as readFileSync10 } from "node:fs";
+import { join as join15, resolve as resolve2 } from "node:path";
 
 // src/cli/setup/setup.ts
 import { createInterface } from "node:readline/promises";
@@ -7886,18 +7886,65 @@ function describeEphemeralRoot(root) {
 }
 
 // src/cli/doctor/doctor.ts
-import { existsSync as existsSync8, openSync as openSync2, closeSync as closeSync2, readFileSync as readFileSync5, statSync } from "node:fs";
+import { existsSync as existsSync10, openSync as openSync3, closeSync as closeSync3, readFileSync as readFileSync7, statSync as statSync2 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { join as join12 } from "node:path";
+import { basename as basename6, join as join14 } from "node:path";
 
 // src/core/state/state.ts
 import { createHash } from "node:crypto";
 import { homedir as homedir3 } from "node:os";
-import { join as join5, dirname as dirname4, basename } from "node:path";
-import { existsSync as existsSync4, realpathSync, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, unlinkSync } from "node:fs";
+import { join as join6, dirname as dirname4, basename } from "node:path";
+import { existsSync as existsSync4, realpathSync, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2 } from "node:fs";
+
+// src/helpers/guards.ts
+function isString(value) {
+  return typeof value === "string";
+}
+function isNullableString(value) {
+  return value === null || isString(value);
+}
+
+// src/helpers/removeQuietly.ts
+import { unlinkSync } from "node:fs";
+function removeQuietly(path) {
+  try {
+    unlinkSync(path);
+  } catch {
+  }
+}
+
+// src/helpers/resultFilePath.ts
+import { randomBytes } from "node:crypto";
+import { tmpdir } from "node:os";
+import { join as join5 } from "node:path";
+var NAME_BYTES = 6;
+function resultFilePath() {
+  const name = `pair-result-${randomBytes(NAME_BYTES).toString("hex")}.json`;
+  return join5(tmpdir(), name);
+}
+
+// src/helpers/spawn.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+var defaultSpawn = (command, args) => {
+  const result = spawnSync2(command, args, { stdio: ["ignore", "ignore", "pipe"] });
+  const stderr = result.stderr ? result.stderr.toString("utf-8") : result.error?.message ?? "";
+  return { status: result.status, stderr };
+};
+
+// src/helpers/splitLines.ts
+function splitLines(text) {
+  const lines = text.split("\n");
+  const last = lines.at(-1);
+  if (last === "") {
+    lines.pop();
+  }
+  return lines;
+}
+
+// src/core/state/state.ts
 function stateDir() {
-  const base = process.env["XDG_STATE_HOME"] || join5(homedir3(), ".local", "state");
-  return join5(base, "pair-mode");
+  const base = process.env["XDG_STATE_HOME"] || join6(homedir3(), ".local", "state");
+  return join6(base, "pair-mode");
 }
 function realpathLenient(path) {
   try {
@@ -7907,7 +7954,7 @@ function realpathLenient(path) {
     if (parent === path) {
       return path;
     }
-    return join5(realpathLenient(parent), basename(path));
+    return join6(realpathLenient(parent), basename(path));
   }
 }
 var DIGEST_LENGTH = 16;
@@ -7916,16 +7963,88 @@ function digestFor(directory) {
   return createHash("sha1").update(real).digest("hex").slice(0, DIGEST_LENGTH);
 }
 function flagPath(directory) {
-  return join5(stateDir(), `${digestFor(directory)}.on`);
+  return join6(stateDir(), `${digestFor(directory)}.on`);
 }
 function sessionsDir() {
-  return join5(stateDir(), "sessions");
+  return join6(stateDir(), "sessions");
+}
+var OWNER_ONLY_DIR = 448;
+var OWNER_ONLY_FILE = 384;
+function makeSessionsDir() {
+  const path = sessionsDir();
+  mkdirSync2(path, { recursive: true, mode: OWNER_ONLY_DIR });
+  return path;
 }
 function sessionSocketPath(directory) {
-  return join5(sessionsDir(), `${digestFor(directory)}.sock`);
+  return join6(sessionsDir(), `${digestFor(directory)}.sock`);
 }
 function sessionUrlPath(directory) {
-  return join5(sessionsDir(), `${digestFor(directory)}.url`);
+  return join6(sessionsDir(), `${digestFor(directory)}.url`);
+}
+function findSessionSocket(filePath) {
+  let current = dirname4(realpathLenient(filePath));
+  while (true) {
+    const candidate = sessionSocketPath(current);
+    if (existsSync4(candidate)) {
+      return candidate;
+    }
+    const parent = dirname4(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function resolveSocketPath(filePath, key) {
+  if (key !== void 0) {
+    const candidate = sessionKeySocketPath(key);
+    if (existsSync4(candidate)) {
+      return candidate;
+    }
+  }
+  return findSessionSocket(filePath);
+}
+function sessionFlagState(key) {
+  if (existsSync4(sessionKeyOptOutPath(key))) {
+    return "off";
+  }
+  return existsSync4(sessionKeyFlagPath(key)) ? "on" : "unset";
+}
+function directoryEnabled(filePath) {
+  let current = dirname4(realpathLenient(filePath));
+  while (true) {
+    if (existsSync4(flagPath(current))) {
+      return true;
+    }
+    const parent = dirname4(current);
+    if (parent === current) {
+      return false;
+    }
+    current = parent;
+  }
+}
+function isEnabled(filePath, key) {
+  if (key !== void 0) {
+    const state = sessionFlagState(key);
+    if (state !== "unset") {
+      return state === "on";
+    }
+  }
+  return directoryEnabled(filePath);
+}
+function enableSession(key) {
+  const path = sessionKeyFlagPath(key);
+  makeSessionsDir();
+  removeQuietly(sessionKeyOptOutPath(key));
+  writeFileSync2(path, "", { mode: OWNER_ONLY_FILE });
+  return path;
+}
+function optOutSession(key) {
+  const path = sessionKeyOptOutPath(key);
+  makeSessionsDir();
+  removeQuietly(sessionKeyFlagPath(key));
+  writeFileSync2(path, "", { mode: OWNER_ONLY_FILE });
+  return path;
 }
 function enable(directory) {
   const path = flagPath(directory);
@@ -7938,46 +8057,80 @@ function disable(directory) {
   if (!existsSync4(path)) {
     return false;
   }
-  unlinkSync(path);
+  unlinkSync2(path);
   return true;
 }
-
-// src/helpers/removeQuietly.ts
-import { unlinkSync as unlinkSync2 } from "node:fs";
-function removeQuietly(path) {
-  try {
-    unlinkSync2(path);
-  } catch {
+var SESSION_KEY_LENGTH = 8;
+function sessionKey(agentSessionId2) {
+  const digest = createHash("sha1").update(agentSessionId2).digest("hex");
+  return `s-${digest.slice(0, SESSION_KEY_LENGTH)}`;
+}
+function watchSocketPath(directory, key, override) {
+  if (override !== void 0) {
+    return override;
   }
+  return key ? sessionKeySocketPath(key) : sessionSocketPath(directory);
 }
-
-// src/helpers/resultFilePath.ts
-import { randomBytes } from "node:crypto";
-import { tmpdir } from "node:os";
-import { join as join6 } from "node:path";
-var NAME_BYTES = 6;
-function resultFilePath() {
-  const name = `pair-result-${randomBytes(NAME_BYTES).toString("hex")}.json`;
-  return join6(tmpdir(), name);
+function watchUrlPath(directory, key) {
+  return key ? sessionKeyUrlPath(key) : sessionUrlPath(directory);
+}
+function keyFor(agentSessionId2) {
+  return agentSessionId2 === void 0 || agentSessionId2 === "" ? void 0 : sessionKey(agentSessionId2);
+}
+function sessionKeyPath(key, extension) {
+  return join6(sessionsDir(), `${key}${extension}`);
+}
+function sessionKeySocketPath(key) {
+  return sessionKeyPath(key, ".sock");
+}
+function sessionKeyFlagPath(key) {
+  return sessionKeyPath(key, ".on");
+}
+function sessionKeyOptOutPath(key) {
+  return sessionKeyPath(key, ".off");
+}
+function sessionKeyUrlPath(key) {
+  return sessionKeyPath(key, ".url");
 }
 
-// src/helpers/spawn.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
-var defaultSpawn = (command, args) => {
-  const result = spawnSync2(command, args, { stdio: ["ignore", "ignore", "pipe"] });
-  const stderr = result.stderr ? result.stderr.toString("utf-8") : result.error?.message ?? "";
-  return { status: result.status, stderr };
-};
-
-// src/helpers/splitLines.ts
-function splitLines(text) {
-  const lines = text.split("\n");
-  const last = lines.at(-1);
-  if (last === "") {
-    lines.pop();
+// src/core/state/record.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { basename as basename2 } from "node:path";
+var GIT_TIMEOUT_MS = 2e3;
+function currentBranch(directory) {
+  const result = spawnSync3("git", ["-C", directory, "rev-parse", "--abbrev-ref", "HEAD"], {
+    encoding: "utf-8",
+    timeout: GIT_TIMEOUT_MS
+  });
+  if (result.status !== 0) {
+    return null;
   }
-  return lines;
+  const branch = result.stdout.trim();
+  return branch === "" ? null : branch;
+}
+function sessionLabel(directory, branch) {
+  const name = basename2(directory);
+  return branch === null ? name : `${name}@${branch}`;
 }
+function buildSessionRecord(options, socketPath) {
+  const branch = currentBranch(options.directory);
+  const kind = options.sessionKey === void 0 ? "directory" : "session";
+  return {
+    id: options.sessionKey ?? basename2(socketPath, ".sock"),
+    kind,
+    label: sessionLabel(options.directory, branch),
+    directory: options.directory,
+    branch,
+    agentSessionId: options.agentSessionId ?? null,
+    agentKind: options.agentKind ?? null,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    pid: process.pid
+  };
+}
+
+// src/cli/sessions/sessions.ts
+import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
+import { basename as basename3, join as join7 } from "node:path";
 
 // src/transports/session/wire.ts
 var CLIENT_KINDS = ["tui", "web"];
@@ -7992,11 +8145,11 @@ function createLineReader() {
     return parts.filter((line2) => line2.trim() !== "");
   };
 }
-function isString(value) {
+function isString2(value) {
   return typeof value === "string";
 }
 function isClientKind(value) {
-  return isString(value) && CLIENT_KINDS.includes(value);
+  return isString2(value) && CLIENT_KINDS.includes(value);
 }
 function isQuestion(value) {
   if (!isRecord(value)) {
@@ -8004,16 +8157,16 @@ function isQuestion(value) {
   }
   const line2 = value["line"];
   const lineOk = line2 === null || typeof line2 === "number";
-  return lineOk && isString(value["code"]) && isString(value["text"]);
+  return lineOk && isString2(value["code"]) && isString2(value["text"]);
 }
 function isQuestionList(value) {
   return Array.isArray(value) && value.every(isQuestion);
 }
 function toSubmit(raw) {
-  if (!isString(raw["tool"]) || !isString(raw["path"])) {
+  if (!isString2(raw["tool"]) || !isString2(raw["path"])) {
     return null;
   }
-  if (!isString(raw["before"]) || !isString(raw["after"])) {
+  if (!isString2(raw["before"]) || !isString2(raw["after"])) {
     return null;
   }
   return {
@@ -8029,7 +8182,7 @@ function toAttach(raw) {
 }
 function toReview(raw) {
   const submit = toSubmit({ ...raw, type: "submit" });
-  if (submit === null || !isString(raw["id"])) {
+  if (submit === null || !isString2(raw["id"])) {
     return null;
   }
   return {
@@ -8042,13 +8195,31 @@ function toReview(raw) {
   };
 }
 function toVerdict(raw) {
-  if (!isString(raw["id"]) || !isQuestionList(raw["questions"])) {
+  if (!isString2(raw["id"]) || !isQuestionList(raw["questions"])) {
     return null;
   }
   return { type: "verdict", id: raw["id"], questions: raw["questions"] };
 }
 function toCancel(raw) {
-  return isString(raw["id"]) ? { type: "cancel", id: raw["id"] } : null;
+  return isString2(raw["id"]) ? { type: "cancel", id: raw["id"] } : null;
+}
+function isNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function toState(raw) {
+  const lastAttachAt = raw["lastAttachAt"];
+  if (lastAttachAt !== null && !isString2(lastAttachAt)) {
+    return null;
+  }
+  if (!isNumber(raw["clientCount"]) || !isNumber(raw["waitingDepth"])) {
+    return null;
+  }
+  return {
+    type: "state",
+    clientCount: raw["clientCount"],
+    waitingDepth: raw["waitingDepth"],
+    lastAttachAt
+  };
 }
 function decodeLine(line2) {
   let parsed;
@@ -8076,13 +8247,19 @@ function decodeLine(line2) {
   if (type === "cancel") {
     return toCancel(parsed);
   }
+  if (type === "status") {
+    return { type: "status" };
+  }
+  if (type === "state") {
+    return toState(parsed);
+  }
   return null;
 }
 
 // src/transports/session/server.ts
 import { createServer, createConnection } from "node:net";
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { chmodSync, mkdirSync as mkdirSync3 } from "node:fs";
+import { chmodSync, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
 import { dirname as dirname5 } from "node:path";
 
 // src/transports/session/queue.ts
@@ -8096,17 +8273,21 @@ function enqueue(state, id, request) {
 function findReview(state, id) {
   return state.reviews.find((review) => review.id === id) ?? null;
 }
+function offeredReviews(state) {
+  return state.reviews.filter((review) => review.status === "offered");
+}
 function waitingDepth(state) {
   return state.reviews.filter((review) => review.status === "waiting").length;
 }
-function takeNext(state) {
-  const next = state.reviews.find((review) => review.status === "waiting");
-  if (next === void 0) {
-    return { state, review: null };
+function offerAll(state) {
+  const waiting = state.reviews.filter((review) => review.status === "waiting");
+  if (waiting.length === 0) {
+    return { state, reviews: [] };
   }
-  const taken = { ...next, status: "inFlight" };
-  const reviews = state.reviews.map((review) => review.id === next.id ? taken : review);
-  return { state: { reviews }, review: taken };
+  const offered = waiting.map((review) => ({ ...review, status: "offered" }));
+  const byId = new Map(offered.map((review) => [review.id, review]));
+  const reviews = state.reviews.map((review) => byId.get(review.id) ?? review);
+  return { state: { reviews }, reviews: offered };
 }
 function complete(state, id) {
   return { reviews: state.reviews.filter((review) => review.id !== id) };
@@ -8120,8 +8301,9 @@ function release(state, id) {
 
 // src/transports/session/server.ts
 var ID_BYTES = 8;
-var OWNER_ONLY_DIR = 448;
+var OWNER_ONLY_DIR2 = 448;
 var OWNER_ONLY_SOCKET = 384;
+var OWNER_ONLY_RECORD = 384;
 var STALE_PROBE_TIMEOUT_MS = 250;
 function defaultGenerateId() {
   return randomBytes2(ID_BYTES).toString("hex");
@@ -8161,7 +8343,7 @@ function restrictToOwner(path) {
   }
 }
 async function bindSocket(server, path) {
-  mkdirSync3(dirname5(path), { recursive: true, mode: OWNER_ONLY_DIR });
+  mkdirSync3(dirname5(path), { recursive: true, mode: OWNER_ONLY_DIR2 });
   try {
     await listenOn(server, path);
     restrictToOwner(path);
@@ -8178,14 +8360,30 @@ async function bindSocket(server, path) {
   await listenOn(server, path);
   restrictToOwner(path);
 }
+function recordPathFor(socketPath) {
+  return socketPath.replace(/\.sock$/, ".json");
+}
+function writeRecord(socketPath, record) {
+  try {
+    writeFileSync3(recordPathFor(socketPath), JSON.stringify(record, null, 2) + "\n", {
+      encoding: "utf-8",
+      mode: OWNER_ONLY_RECORD
+    });
+  } catch {
+  }
+}
 async function startSessionServer(options) {
   const generateId = options.generateId ?? defaultGenerateId;
   const reportError = options.onError ?? defaultReportError;
   let queue = emptyQueue();
-  const agents = /* @__PURE__ */ new Map();
+  const agentByReview = /* @__PURE__ */ new Map();
   const clients = /* @__PURE__ */ new Map();
+  const clientBySocket = /* @__PURE__ */ new Map();
+  const clientsByReview = /* @__PURE__ */ new Map();
   const connections = /* @__PURE__ */ new Set();
   const changeHandlers = [];
+  let lastAttachAt = null;
+  let nextClientId = 0;
   function announce() {
     changeHandlers.forEach((handler) => handler());
   }
@@ -8194,81 +8392,102 @@ async function startSessionServer(options) {
       socket.write(encode(message));
     }
   }
-  function idleClient() {
-    const entry = [...clients.entries()].find(([, held]) => held === null);
-    return entry === void 0 ? null : entry[0];
-  }
-  function clientHolding(id) {
-    const entry = [...clients.entries()].find(([, held]) => held === id);
-    return entry === void 0 ? null : entry[0];
+  function reviewMessage(review) {
+    return {
+      type: "review",
+      id: review.id,
+      tool: review.request.tool,
+      path: review.request.filePath,
+      before: review.request.before,
+      after: review.request.after
+    };
   }
   function dispatch() {
-    let client = idleClient();
-    while (client !== null) {
-      const result = takeNext(queue);
-      if (result.review === null) {
-        break;
-      }
-      queue = result.state;
-      clients.set(client, result.review.id);
-      send(client, {
-        type: "review",
-        id: result.review.id,
-        tool: result.review.request.tool,
-        path: result.review.request.filePath,
-        before: result.review.request.before,
-        after: result.review.request.after
-      });
-      client = idleClient();
+    if (clients.size === 0) {
+      announce();
+      return;
     }
+    const result = offerAll(queue);
+    queue = result.state;
+    result.reviews.forEach((review) => {
+      clientsByReview.set(review.id, new Map(clients));
+      clients.forEach((client) => send(client.socket, reviewMessage(review)));
+    });
     announce();
   }
   function handleSubmit(socket, request) {
     const id = generateId();
     queue = enqueue(queue, id, request);
-    agents.set(id, socket);
+    agentByReview.set(id, socket);
     dispatch();
   }
   function handleAttach(socket) {
-    clients.set(socket, null);
+    if (clientBySocket.has(socket)) {
+      return;
+    }
+    nextClientId += 1;
+    const client = { id: `c${nextClientId}`, socket };
+    clients.set(client.id, client);
+    clientBySocket.set(socket, client);
+    lastAttachAt = (/* @__PURE__ */ new Date()).toISOString();
+    offeredReviews(queue).forEach((review) => {
+      const viewers = clientsByReview.get(review.id) ?? /* @__PURE__ */ new Map();
+      viewers.set(client.id, client);
+      clientsByReview.set(review.id, viewers);
+      send(socket, reviewMessage(review));
+    });
     dispatch();
   }
   function handleVerdict(socket, message) {
-    const agent = agents.get(message.id);
-    if (agent !== void 0) {
+    const answering = clientBySocket.get(socket);
+    if (!answering) {
+      return;
+    }
+    const viewers = clientsByReview.get(message.id);
+    if (!viewers?.has(answering.id)) {
+      return;
+    }
+    const agent = agentByReview.get(message.id);
+    if (agent) {
       send(agent, message);
-      agents.delete(message.id);
+      agentByReview.delete(message.id);
     }
+    viewers.forEach((viewer) => {
+      if (viewer.id !== answering.id) {
+        send(viewer.socket, { type: "cancel", id: message.id });
+      }
+    });
+    clientsByReview.delete(message.id);
     queue = complete(queue, message.id);
-    if (clients.get(socket) === message.id) {
-      clients.set(socket, null);
-    }
     dispatch();
   }
   function dropAgent(socket) {
-    const owned = [...agents.entries()].filter(([, agentSocket]) => agentSocket === socket);
+    const owned = [...agentByReview.entries()].filter(([, agentSocket]) => agentSocket === socket);
+    if (owned.length === 0) {
+      return;
+    }
     owned.forEach(([id]) => {
-      agents.delete(id);
-      const holder = clientHolding(id);
-      if (holder !== null) {
-        send(holder, { type: "cancel", id });
-        clients.set(holder, null);
-      }
+      agentByReview.delete(id);
+      clientsByReview.get(id)?.forEach((viewer) => send(viewer.socket, { type: "cancel", id }));
+      clientsByReview.delete(id);
       queue = complete(queue, id);
     });
-    if (owned.length > 0) {
-      dispatch();
-    }
+    dispatch();
   }
   function dropClient(socket) {
-    const held = clients.get(socket);
-    if (held === void 0) {
+    const leaving = clientBySocket.get(socket);
+    if (!leaving) {
       return;
     }
-    clients.delete(socket);
-    if (held !== null && findReview(queue, held) !== null) {
-      queue = release(queue, held);
-    }
+    clientBySocket.delete(socket);
+    clients.delete(leaving.id);
+    clientsByReview.forEach((viewers, id) => {
+      viewers.delete(leaving.id);
+      if (viewers.size === 0 && findReview(queue, id) !== null) {
+        queue = release(queue, id);
+        clientsByReview.delete(id);
+      }
+    });
     dispatch();
   }
   function handleLine(socket, line2) {
@@ -8289,6 +8508,15 @@ async function startSessionServer(options) {
       handleAttach(socket);
       return;
     }
+    if (message.type === "status") {
+      send(socket, {
+        type: "state",
+        clientCount: clients.size,
+        waitingDepth: waitingDepth(queue),
+        lastAttachAt
+      });
+      return;
+    }
     if (message.type === "verdict") {
       handleVerdict(socket, message);
     }
@@ -8307,102 +8535,883 @@ async function startSessionServer(options) {
       dropClient(socket);
     });
   }
-  const server = createServer(handleConnection);
-  await bindSocket(server, options.socketPath);
-  server.on("error", reportError);
-  return {
-    socketPath: options.socketPath,
-    clientCount() {
-      return clients.size;
-    },
-    waitingDepth() {
-      return waitingDepth(queue);
-    },
-    onChange(handler) {
-      changeHandlers.push(handler);
-    },
-    close() {
-      return new Promise((resolve3) => {
-        [...connections].forEach((socket) => socket.destroy());
-        server.close(() => {
-          removeQuietly(options.socketPath);
-          resolve3();
-        });
-      });
-    }
-  };
+  const server = createServer(handleConnection);
+  await bindSocket(server, options.socketPath);
+  if (options.record !== void 0) {
+    writeRecord(options.socketPath, options.record);
+  }
+  server.on("error", reportError);
+  return {
+    socketPath: options.socketPath,
+    clientCount() {
+      return clients.size;
+    },
+    lastAttachAt() {
+      return lastAttachAt;
+    },
+    waitingDepth() {
+      return waitingDepth(queue);
+    },
+    onChange(handler) {
+      changeHandlers.push(handler);
+    },
+    close() {
+      return new Promise((resolve3) => {
+        [...connections].forEach((socket) => socket.destroy());
+        server.close(() => {
+          removeQuietly(options.socketPath);
+          removeQuietly(recordPathFor(options.socketPath));
+          resolve3();
+        });
+      });
+    }
+  };
+}
+
+// src/transports/session/host.ts
+import { createConnection as createConnection2 } from "node:net";
+function connect(socketPath) {
+  return new Promise((resolve3, reject) => {
+    const socket = createConnection2(socketPath);
+    socket.setEncoding("utf-8");
+    socket.once("error", reject);
+    socket.once("connect", () => resolve3(socket));
+  });
+}
+function emptyHandlers() {
+  return { review: [], cancel: [], change: [], bufferedReviews: [], bufferedCancels: [] };
+}
+function addReviewHandler(handlers, handler) {
+  handlers.review.push(handler);
+  handlers.bufferedReviews.splice(0).forEach((review) => handler(review));
+}
+function addCancelHandler(handlers, handler) {
+  handlers.cancel.push(handler);
+  handlers.bufferedCancels.splice(0).forEach((id) => handler(id));
+}
+async function attach(socketPath, client, handlers, onState) {
+  const socket = await connect(socketPath);
+  const readLines = createLineReader();
+  socket.on("data", (chunk) => {
+    readLines(chunk).forEach((line2) => {
+      const message = decodeLine(line2);
+      if (message?.type === "review") {
+        if (handlers.review.length === 0) {
+          handlers.bufferedReviews.push(message);
+          return;
+        }
+        handlers.review.forEach((handler) => handler(message));
+        return;
+      }
+      if (message?.type === "cancel") {
+        if (handlers.cancel.length === 0) {
+          handlers.bufferedCancels.push(message.id);
+          return;
+        }
+        handlers.cancel.forEach((handler) => handler(message.id));
+        return;
+      }
+      if (message?.type === "state") {
+        onState(message);
+      }
+    });
+  });
+  socket.write(encode({ type: "attach", client }));
+  return socket;
+}
+async function ownerHost(options) {
+  const handlers = emptyHandlers();
+  const server = await startSessionServer({
+    socketPath: options.socketPath,
+    record: options.record,
+    onError: options.onError
+  });
+  server.onChange(() => handlers.change.forEach((handler) => handler()));
+  const socket = await attach(options.socketPath, options.client, handlers, () => {
+  });
+  return {
+    socketPath: options.socketPath,
+    owns: true,
+    counts() {
+      return { clients: server.clientCount(), waiting: server.waitingDepth() };
+    },
+    // The server holds the counts in process, so nothing needs asking.
+    refreshCounts() {
+    },
+    verdict(id, questions) {
+      socket.write(encode({ type: "verdict", id, questions }));
+    },
+    onReview(handler) {
+      addReviewHandler(handlers, handler);
+    },
+    onCancel(handler) {
+      addCancelHandler(handlers, handler);
+    },
+    onChange(handler) {
+      handlers.change.push(handler);
+    },
+    async close() {
+      socket.destroy();
+      await server.close();
+    }
+  };
+}
+async function viewerHost(options) {
+  const handlers = emptyHandlers();
+  let remote = null;
+  const socket = await attach(options.socketPath, options.client, handlers, (state) => {
+    remote = state;
+    handlers.change.forEach((handler) => handler());
+  });
+  return {
+    socketPath: options.socketPath,
+    owns: false,
+    counts() {
+      return { clients: remote?.clientCount ?? 0, waiting: remote?.waitingDepth ?? 0 };
+    },
+    refreshCounts() {
+      socket.write(encode({ type: "status" }));
+    },
+    verdict(id, questions) {
+      socket.write(encode({ type: "verdict", id, questions }));
+    },
+    onReview(handler) {
+      addReviewHandler(handlers, handler);
+    },
+    onCancel(handler) {
+      addCancelHandler(handlers, handler);
+    },
+    onChange(handler) {
+      handlers.change.push(handler);
+    },
+    close() {
+      socket.destroy();
+      return Promise.resolve();
+    }
+  };
+}
+
+// src/transports/session/probe.ts
+import { createConnection as createConnection3 } from "node:net";
+var STATUS_TIMEOUT_MS = 250;
+var ABANDONED_CODES = ["ECONNREFUSED", "ENOENT", "ENOTSOCK", "ENOTDIR"];
+function probeSession(socketPath) {
+  return new Promise((resolve3) => {
+    let settled = false;
+    let connected = false;
+    const settle = (probe) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      resolve3(probe);
+    };
+    const timer = setTimeout(() => settle({ status: "silent" }), STATUS_TIMEOUT_MS);
+    const socket = createConnection3(socketPath);
+    socket.setEncoding("utf-8");
+    const readLines = createLineReader();
+    socket.on("error", (error) => {
+      const code2 = "code" in error ? error.code : null;
+      const abandoned = !connected && isString(code2) && ABANDONED_CODES.includes(code2);
+      settle(abandoned ? { status: "refused" } : { status: "silent" });
+    });
+    socket.on("close", () => settle({ status: "silent" }));
+    socket.on("data", (chunk) => {
+      readLines(chunk).forEach((line2) => {
+        const message = decodeLine(line2);
+        if (message?.type !== "state") {
+          return;
+        }
+        settle({ status: "answered", state: message });
+      });
+    });
+    socket.on("connect", () => {
+      connected = true;
+      socket.write(encode({ type: "status" }));
+    });
+  });
+}
+
+// src/cli/sessions/sessions.ts
+var UNKNOWN_LABEL = "unknown";
+var UNKNOWN_AGE = "-";
+var UNKNOWN_COUNT = "?";
+var SESSION_KINDS = ["session", "directory"];
+var SECOND_MS = 1e3;
+var MINUTE_MS = 60 * SECOND_MS;
+var HOUR_MS = 60 * MINUTE_MS;
+var DAY_MS = 24 * HOUR_MS;
+function isSessionKind(value) {
+  return isString(value) && SESSION_KINDS.includes(value);
+}
+function isSessionRecord(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  if (!isString(value["id"]) || !isSessionKind(value["kind"])) {
+    return false;
+  }
+  if (!isString(value["label"]) || !isString(value["directory"])) {
+    return false;
+  }
+  if (!isNullableString(value["branch"]) || !isNullableString(value["agentSessionId"])) {
+    return false;
+  }
+  if (!isNullableString(value["agentKind"]) || !isString(value["createdAt"])) {
+    return false;
+  }
+  return typeof value["pid"] === "number";
+}
+function readRecord(id) {
+  const path = join7(sessionsDir(), `${id}.json`);
+  if (!existsSync5(path)) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf-8"));
+    return isSessionRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function sessionIds() {
+  try {
+    return readdirSync(sessionsDir()).filter((name) => name.endsWith(".sock")).map((name) => basename3(name, ".sock")).sort();
+  } catch {
+    return [];
+  }
+}
+function removeSession(id) {
+  [".sock", ".json", ".url"].forEach(
+    (extension) => removeQuietly(join7(sessionsDir(), `${id}${extension}`))
+  );
+}
+var FLAG_EXTENSIONS = [".on", ".off"];
+var FLAG_EXPIRY_MS = 14 * DAY_MS;
+function flagFiles() {
+  try {
+    return readdirSync(sessionsDir()).filter((name) => FLAG_EXTENSIONS.some((extension) => name.endsWith(extension))).filter((name) => name.startsWith("s-")).sort();
+  } catch {
+    return [];
+  }
+}
+function ageOf(path, now) {
+  try {
+    return now - statSync(path).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function sweepExpiredFlags(now = Date.now()) {
+  const expired = [];
+  flagFiles().forEach((name) => {
+    const id = name.replace(/\.(on|off)$/, "");
+    if (existsSync5(join7(sessionsDir(), `${id}.sock`))) {
+      return;
+    }
+    const path = join7(sessionsDir(), name);
+    const age = ageOf(path, now);
+    if (age === null || age < FLAG_EXPIRY_MS) {
+      return;
+    }
+    removeQuietly(path);
+    expired.push(name);
+  });
+  return expired;
+}
+function kindOf(id, record) {
+  if (record !== null) {
+    return record.kind;
+  }
+  return id.startsWith("s-") ? "session" : "directory";
+}
+function toListing(id, probe) {
+  const record = readRecord(id);
+  const state = probe.status === "answered" ? probe.state : null;
+  return {
+    id,
+    kind: kindOf(id, record),
+    label: record?.label ?? UNKNOWN_LABEL,
+    directory: record?.directory ?? "",
+    clients: state?.clientCount ?? null,
+    waiting: state?.waitingDepth ?? null,
+    createdAt: record?.createdAt ?? "",
+    alive: true
+  };
+}
+async function scan() {
+  const ids = sessionIds();
+  const probes = await Promise.all(
+    ids.map((id) => probeSession(join7(sessionsDir(), `${id}.sock`)))
+  );
+  const listings = [];
+  const swept = [];
+  ids.forEach((id, index) => {
+    const probe = probes[index];
+    if (probe === void 0 || probe.status === "refused") {
+      removeSession(id);
+      swept.push(id);
+      return;
+    }
+    listings.push(toListing(id, probe));
+  });
+  return { listings, swept, expired: sweepExpiredFlags() };
+}
+function formatAge(createdAt, now) {
+  const started = Date.parse(createdAt);
+  if (Number.isNaN(started)) {
+    return UNKNOWN_AGE;
+  }
+  const elapsed = Math.max(0, now - started);
+  if (elapsed >= DAY_MS) {
+    return `${Math.floor(elapsed / DAY_MS)}d`;
+  }
+  if (elapsed >= HOUR_MS) {
+    return `${Math.floor(elapsed / HOUR_MS)}h`;
+  }
+  if (elapsed >= MINUTE_MS) {
+    return `${Math.floor(elapsed / MINUTE_MS)}m`;
+  }
+  return `${Math.floor(elapsed / SECOND_MS)}s`;
+}
+function formatCount(count) {
+  return count === null ? UNKNOWN_COUNT : String(count);
+}
+function formatTable(listings, now) {
+  const header = ["ID", "LABEL", "KIND", "WATCHERS", "QUEUED", "AGE"];
+  const rows = listings.map((entry) => [
+    entry.id,
+    entry.label,
+    entry.kind,
+    formatCount(entry.clients),
+    formatCount(entry.waiting),
+    formatAge(entry.createdAt, now)
+  ]);
+  const widths = header.map(
+    (name, column) => Math.max(name.length, ...rows.map((row) => row[column]?.length ?? 0))
+  );
+  const line2 = (cells) => cells.map((cell, column) => cell.padEnd(widths[column] ?? 0)).join("  ").trimEnd();
+  return [line2(header), ...rows.map(line2)].join("\n");
+}
+function sweptLine(swept) {
+  const noun = swept.length === 1 ? "session" : "sessions";
+  return `swept ${swept.length} dead ${noun}`;
+}
+function expiredLine(expired) {
+  const noun = expired.length === 1 ? "flag" : "flags";
+  return `expired ${expired.length} stale session ${noun}`;
+}
+async function listSessions() {
+  const { listings, swept, expired } = await scan();
+  const table = listings.length === 0 ? "no pair-mode sessions" : formatTable(listings, Date.now());
+  const notes = [
+    ...swept.length === 0 ? [] : [sweptLine(swept)],
+    ...expired.length === 0 ? [] : [expiredLine(expired)]
+  ];
+  const text = notes.length === 0 ? table : `${table}
+
+${notes.join("\n")}`;
+  return { listings, swept, expired, text, exitCode: 0 };
+}
+async function sweepDeadSessions() {
+  const { swept } = await scan();
+  return swept;
+}
+
+// src/cli/sessions/connect.ts
+var CLEAR_SCREEN = "\x1B[2J\x1B[H";
+var DOWN_KEYS = ["j", "\x1B[B"];
+var UP_KEYS = ["k", "\x1B[A"];
+var SELECT_KEYS = ["\r", "\n"];
+var QUIT_KEYS = ["q", ""];
+var HELP = "j/k move, Enter watches, q quits";
+function watchers(entry) {
+  return entry.clients === null ? "?" : String(entry.clients);
+}
+function paint(io, listings, cursor) {
+  const rows = listings.map((entry, index) => {
+    const marker = index === cursor ? ">" : " ";
+    return `${marker} ${entry.id}  ${entry.label}  ${watchers(entry)} watching`;
+  });
+  io.write(`${CLEAR_SCREEN}pair mode sessions\r
+\r
+${rows.join("\r\n")}\r
+\r
+${HELP}\r
+`);
+}
+function pick(io, listings) {
+  return new Promise((resolve3) => {
+    let cursor = 0;
+    io.onKey((key) => {
+      if (QUIT_KEYS.includes(key)) {
+        resolve3({ selected: null, exitCode: 0 });
+        return;
+      }
+      if (SELECT_KEYS.includes(key)) {
+        resolve3({ selected: listings[cursor] ?? null, exitCode: 0 });
+        return;
+      }
+      if (DOWN_KEYS.includes(key)) {
+        cursor = Math.min(cursor + 1, listings.length - 1);
+      }
+      if (UP_KEYS.includes(key)) {
+        cursor = Math.max(cursor - 1, 0);
+      }
+      paint(io, listings, cursor);
+    });
+    paint(io, listings, cursor);
+  });
+}
+async function runConnect(io) {
+  try {
+    if (!io.isTty()) {
+      io.write("connect needs a terminal; run pair-mode sessions instead\n");
+      return { selected: null, exitCode: 1 };
+    }
+    const { listings } = await listSessions();
+    if (listings.length === 0) {
+      io.write("no pair-mode sessions\n");
+      return { selected: null, exitCode: 0 };
+    }
+    return await pick(io, listings);
+  } finally {
+    io.shutdown();
+  }
+}
+
+// src/cli/toggle.ts
+import { spawn } from "node:child_process";
+import { existsSync as existsSync6, readFileSync as readFileSync3, unlinkSync as unlinkSync3 } from "node:fs";
+import { join as join8 } from "node:path";
+var POLL_MS = 100;
+var POLL_ATTEMPTS = 60;
+var SESSION_ENV_VARS = ["CLAUDE_CODE_SESSION_ID", "CODEX_SESSION_ID", "CODEX_THREAD_ID"];
+function agentSessionId(env) {
+  const found = SESSION_ENV_VARS.map((name) => env[name]).find(
+    (value) => typeof value === "string" && value !== ""
+  );
+  return found ?? null;
+}
+function currentSessionKey() {
+  return keyFor(agentSessionId(process.env) ?? void 0);
+}
+function statusProbe(directory) {
+  return join8(directory, ".pair-mode-status-probe");
+}
+function sleep(ms) {
+  return new Promise((done) => setTimeout(done, ms));
+}
+function readLink(directory, key) {
+  const path = watchUrlPath(directory, key);
+  if (!existsSync6(path)) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync3(path, "utf-8"));
+    if (isRecord(parsed) && typeof parsed["url"] === "string" && typeof parsed["pid"] === "number") {
+      return { url: parsed["url"], pid: parsed["pid"] };
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+async function waitForLink(directory, key) {
+  const attempts = Array.from({ length: POLL_ATTEMPTS }, (_, index) => index);
+  for (const _attempt of attempts) {
+    const link = readLink(directory, key);
+    if (link !== null) {
+      return link;
+    }
+    await sleep(POLL_MS);
+  }
+  return null;
+}
+function stopLink(directory, key) {
+  const link = readLink(directory, key);
+  if (link === null) {
+    return false;
+  }
+  try {
+    process.kill(link.pid, "SIGTERM");
+  } catch {
+  }
+  try {
+    unlinkSync3(watchUrlPath(directory, key));
+  } catch {
+  }
+  return true;
+}
+function onHeadline(directory, key) {
+  return key ? `pair mode ON \xB7 ${key} \xB7 ${directory}` : `pair mode ON for ${directory}`;
+}
+function pairOn(directory, key) {
+  if (key) {
+    enableSession(key);
+  } else {
+    enable(directory);
+  }
+  return onHeadline(directory, key);
+}
+async function pairOnWeb(directory, cliPath, key) {
+  const headline = onHeadline(directory, key);
+  if (key) {
+    enableSession(key);
+  } else {
+    enable(directory);
+  }
+  const existing = readLink(directory, key);
+  if (existing !== null) {
+    return `${headline}
+${existing.url}`;
+  }
+  const target = key ?? directory;
+  const child = spawn(process.execPath, [cliPath, "watch", "--web", target], {
+    cwd: directory,
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  const link = await waitForLink(directory, key);
+  if (link === null) {
+    return `${headline}
+the web watcher did not report a link`;
+  }
+  return `${headline}
+${link.url}`;
+}
+function pairOff(directory, key) {
+  if (key) {
+    optOutSession(key);
+    const stopped2 = stopLink(directory, key);
+    return stopped2 ? `pair mode OFF \xB7 ${key} (web watcher stopped)` : `pair mode OFF \xB7 ${key}`;
+  }
+  disable(directory);
+  const stopped = stopLink(directory);
+  return stopped ? `pair mode OFF for ${directory} (web watcher stopped)` : `pair mode OFF for ${directory}`;
+}
+async function pairToggle(directory, cliPath, web, key) {
+  const on = key ? isEnabled(statusProbe(directory), key) : existsSync6(flagPath(directory));
+  if (on) {
+    return pairOff(directory, key);
+  }
+  if (web) {
+    return await pairOnWeb(directory, cliPath, key);
+  }
+  return pairOn(directory, key);
+}
+function pairStatus(directory, key) {
+  const on = isEnabled(statusProbe(directory), key);
+  const link = readLink(directory, key);
+  const scope = key ? `${key} \xB7 ${directory}` : directory;
+  const state = `pair mode ${on ? "ON" : "OFF"} for ${scope}`;
+  return link === null ? state : `${state}
+${link.url}`;
 }
 
 // src/editors/micro.ts
 var import_yaml = __toESM(require_dist(), 1);
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join8 } from "node:path";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join10 } from "node:path";
 
 // src/editors/languages.ts
-import { extname as extname2 } from "node:path";
-var LANGS = {
+import { openSync, readSync, closeSync } from "node:fs";
+import { basename as basename4, extname as extname2 } from "node:path";
+var EXTENSIONS = {
   ".go": "go",
   ".rb": "ruby",
   ".rake": "ruby",
+  ".gemspec": "ruby",
+  ".ru": "ruby",
+  ".erb": "erb",
+  ".haml": "haml",
   ".ts": "typescript",
-  ".tsx": "typescript",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".tsx": "tsx",
   ".js": "javascript",
-  ".jsx": "javascript",
   ".mjs": "javascript",
-  ".py": "python3",
+  ".cjs": "javascript",
+  ".jsx": "jsx",
+  ".vue": "vue",
+  ".svelte": "svelte",
+  ".astro": "astro",
+  ".py": "python",
+  ".pyi": "python",
   ".ex": "elixir",
   ".exs": "elixir",
+  ".heex": "elixir",
+  ".erl": "erlang",
+  ".hrl": "erlang",
   ".rs": "rust",
-  ".sh": "sh",
-  ".bash": "sh",
-  ".fish": "fish",
+  ".sh": "shellscript",
+  ".bash": "shellscript",
+  ".ksh": "shellscript",
   ".zsh": "zsh",
+  ".fish": "fish",
+  ".ps1": "powershell",
+  ".psm1": "powershell",
+  ".bat": "bat",
+  ".cmd": "bat",
   ".sql": "sql",
   ".json": "json",
+  ".jsonc": "jsonc",
+  ".json5": "json5",
   ".tf": "terraform",
+  ".tfvars": "terraform",
+  ".hcl": "hcl",
   ".proto": "proto",
-  ".dockerfile": "dockerfile",
+  ".dockerfile": "docker",
   ".toml": "toml",
   ".yaml": "yaml",
   ".yml": "yaml",
+  ".ini": "ini",
+  ".cfg": "ini",
+  ".properties": "properties",
+  ".env": "dotenv",
   ".md": "markdown",
+  ".markdown": "markdown",
+  ".mdx": "mdx",
   ".css": "css",
+  ".scss": "scss",
+  ".sass": "sass",
+  ".less": "less",
+  ".styl": "stylus",
   ".html": "html",
-  ".erb": "html",
+  ".htm": "html",
+  ".xml": "xml",
+  ".xsl": "xml",
+  ".svg": "xml",
   ".lua": "lua",
   ".c": "c",
-  ".h": "c"
+  ".h": "c",
+  ".cc": "cpp",
+  ".cpp": "cpp",
+  ".cxx": "cpp",
+  ".hpp": "cpp",
+  ".hh": "cpp",
+  ".cs": "csharp",
+  ".java": "java",
+  ".kt": "kotlin",
+  ".kts": "kotlin",
+  ".swift": "swift",
+  ".m": "objective-c",
+  ".mm": "objective-c",
+  ".php": "php",
+  ".pl": "perl",
+  ".pm": "perl",
+  ".scala": "scala",
+  ".sc": "scala",
+  ".clj": "clojure",
+  ".cljs": "clojure",
+  ".cljc": "clojure",
+  ".hs": "haskell",
+  ".nix": "nix",
+  ".r": "r",
+  ".jl": "julia",
+  ".zig": "zig",
+  ".nim": "nim",
+  ".dart": "dart",
+  ".groovy": "groovy",
+  ".gradle": "groovy",
+  ".cr": "crystal",
+  ".ml": "ocaml",
+  ".mli": "ocaml",
+  ".fs": "fsharp",
+  ".fsx": "fsharp",
+  ".elm": "elm",
+  ".graphql": "graphql",
+  ".gql": "graphql",
+  ".prisma": "prisma",
+  ".sol": "solidity",
+  ".vim": "viml",
+  ".diff": "diff",
+  ".patch": "diff",
+  ".tex": "latex",
+  ".wgsl": "wgsl",
+  ".glsl": "glsl",
+  ".cue": "cue"
+};
+var FILENAMES = {
+  gemfile: "ruby",
+  rakefile: "ruby",
+  capfile: "ruby",
+  vagrantfile: "ruby",
+  guardfile: "ruby",
+  podfile: "ruby",
+  fastfile: "ruby",
+  appfile: "ruby",
+  brewfile: "ruby",
+  "config.ru": "ruby",
+  dockerfile: "docker",
+  containerfile: "docker",
+  makefile: "make",
+  gnumakefile: "make",
+  "cmakelists.txt": "cmake",
+  "cargo.lock": "toml",
+  "gemfile.lock": "toml",
+  ".babelrc": "json",
+  ".eslintrc": "json",
+  ".prettierrc": "json",
+  ".env": "dotenv",
+  ".gitconfig": "ini",
+  ".editorconfig": "ini",
+  "nginx.conf": "nginx",
+  "pnpm-workspace.yaml": "yaml"
 };
-function syntaxName(sourcePath) {
-  const ext = extname2(sourcePath).toLowerCase();
-  return LANGS[ext] ?? null;
-}
-var SHIKI_TRANSLATIONS = {
-  python3: "python",
-  sh: "shellscript",
-  zsh: "shellscript",
+var SHEBANGS = [
+  { pattern: /^#!.*\/(env\s+)?ruby(\s|$)/, id: "ruby" },
+  { pattern: /^#!.*\/(env\s+)?python[\d.]*(\s|$)/, id: "python" },
+  { pattern: /^#!.*\/(env\s+)?(node|bun|deno)(\s|$)/, id: "javascript" },
+  { pattern: /^#!.*\/(env\s+)?(bash|sh|ksh|dash)(\s|$)/, id: "shellscript" },
+  { pattern: /^#!.*\/(env\s+)?zsh(\s|$)/, id: "zsh" },
+  { pattern: /^#!.*\/(env\s+)?fish(\s|$)/, id: "fish" },
+  { pattern: /^#!.*\/(env\s+)?perl(\s|$)/, id: "perl" },
+  { pattern: /^#!.*\/(env\s+)?php(\s|$)/, id: "php" },
+  { pattern: /^#!.*\/(env\s+)?(elixir|iex)(\s|$)/, id: "elixir" },
+  { pattern: /^#!.*\/(env\s+)?lua(\s|$)/, id: "lua" },
+  { pattern: /^#!.*\/(env\s+)?Rscript(\s|$)/, id: "r" },
+  { pattern: /^#!.*\/(env\s+)?pwsh(\s|$)/, id: "powershell" }
+];
+var FIRST_LINE_BYTES = 256;
+function firstLine(sourcePath) {
+  let handle = null;
+  try {
+    handle = openSync(sourcePath, "r");
+    const buffer = Buffer.alloc(FIRST_LINE_BYTES);
+    const read = readSync(handle, buffer, 0, FIRST_LINE_BYTES, 0);
+    const text = buffer.toString("utf-8", 0, read);
+    const newline = text.indexOf("\n");
+    return newline === -1 ? text : text.slice(0, newline);
+  } catch {
+    return null;
+  } finally {
+    if (handle !== null) {
+      try {
+        closeSync(handle);
+      } catch {
+      }
+    }
+  }
+}
+function shebangLanguage(sourcePath) {
+  const line2 = firstLine(sourcePath);
+  if (line2 === null || !line2.startsWith("#!")) {
+    return null;
+  }
+  return SHEBANGS.find((rule) => rule.pattern.test(line2))?.id ?? null;
+}
+function detectLanguage(sourcePath) {
+  const name = basename4(sourcePath).toLowerCase();
+  const ext = extname2(name);
+  if (ext !== "" && EXTENSIONS[ext] !== void 0) {
+    return EXTENSIONS[ext];
+  }
+  if (FILENAMES[name] !== void 0) {
+    return FILENAMES[name];
+  }
+  return shebangLanguage(sourcePath);
+}
+var MICRO_SYNTAX = {
+  c: "c",
+  clojure: "clojure",
+  cmake: "cmake",
+  crystal: "crystal",
+  csharp: "csharp",
+  css: "css",
+  dart: "dart",
+  docker: "dockerfile",
+  elixir: "elixir",
+  elm: "elm",
+  erb: "erb",
+  erlang: "erlang",
   fish: "fish",
+  fsharp: "fsharp",
+  go: "go",
+  graphql: "graphql",
+  groovy: "groovy",
+  haml: "haml",
+  haskell: "haskell",
+  html: "html",
+  ini: "ini",
+  java: "java",
+  javascript: "javascript",
+  json: "json",
+  julia: "julia",
+  kotlin: "kotlin",
+  lua: "lua",
+  make: "makefile",
+  markdown: "markdown",
+  nginx: "nginx",
+  nim: "nim",
+  nix: "nix",
+  "objective-c": "objc",
+  ocaml: "ocaml",
+  perl: "perl",
+  php: "php",
   proto: "proto",
-  dockerfile: "docker",
-  terraform: "terraform"
+  python: "python3",
+  r: "r",
+  ruby: "ruby",
+  rust: "rust",
+  scala: "scala",
+  shellscript: "sh",
+  sql: "sql",
+  svelte: "svelte",
+  swift: "swift",
+  terraform: "terraform",
+  toml: "toml",
+  typescript: "typescript",
+  vue: "vue",
+  xml: "xml",
+  yaml: "yaml",
+  zig: "zig",
+  zsh: "zsh"
+};
+var VIM_FILETYPES = {
+  shellscript: "sh",
+  docker: "dockerfile",
+  csharp: "cs",
+  "objective-c": "objc",
+  bat: "dosbatch",
+  viml: "vim",
+  mdx: "markdown",
+  jsx: "javascriptreact",
+  tsx: "typescriptreact",
+  dotenv: "sh",
+  properties: "jproperties",
+  stylus: "stylus"
 };
 function shikiLanguage(sourcePath) {
-  const name = syntaxName(sourcePath);
-  if (name === null) {
+  return detectLanguage(sourcePath);
+}
+function microSyntaxName(sourcePath) {
+  const id = detectLanguage(sourcePath);
+  if (id === null) {
+    return null;
+  }
+  return MICRO_SYNTAX[id] ?? null;
+}
+function vimFiletype(sourcePath) {
+  const id = detectLanguage(sourcePath);
+  if (id === null) {
     return null;
   }
-  return SHIKI_TRANSLATIONS[name] ?? name;
+  return VIM_FILETYPES[id] ?? id;
 }
 
 // src/editors/syntax-cache.ts
-import { existsSync as existsSync5, readFileSync as readFileSync2 } from "node:fs";
-import { dirname as dirname6, join as join7 } from "node:path";
+import { existsSync as existsSync7, readFileSync as readFileSync4 } from "node:fs";
+import { dirname as dirname6, join as join9 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function defaultAssetsDir() {
   let dir = dirname6(fileURLToPath3(import.meta.url));
   while (true) {
-    const candidate = join7(dir, "assets", "syntax");
-    if (existsSync5(candidate)) {
+    const candidate = join9(dir, "assets", "syntax");
+    if (existsSync7(candidate)) {
       return candidate;
     }
     const parent = dirname6(dir);
@@ -8416,11 +9425,11 @@ function syntaxSource(lang, assetsDir = defaultAssetsDir()) {
   if (assetsDir === null) {
     return null;
   }
-  const path = join7(assetsDir, `${lang}.yaml`);
-  if (!existsSync5(path)) {
+  const path = join9(assetsDir, `${lang}.yaml`);
+  if (!existsSync7(path)) {
     return null;
   }
-  return readFileSync2(path, "utf-8");
+  return readFileSync4(path, "utf-8");
 }
 
 // src/editors/micro.ts
@@ -8453,7 +9462,7 @@ function bandRules() {
   ];
 }
 function writeColorScheme(configDir, theme2) {
-  const dir = join8(configDir, "colorschemes");
+  const dir = join10(configDir, "colorschemes");
   mkdirSync4(dir, { recursive: true });
   const text = `include "monokai"
 
@@ -8461,7 +9470,7 @@ color-link pairadd "#d7ffd7,${theme2.add}"
 color-link pairdel "#ffd7d7,${theme2.del}"
 color-link pairskip "#6a6a6a,${theme2.fold}"
 `;
-  writeFileSync3(join8(dir, "pair.micro"), text, "utf-8");
+  writeFileSync4(join10(dir, "pair.micro"), text, "utf-8");
 }
 function syntaxText(lang, source) {
   const parsed = (0, import_yaml.parse)(source);
@@ -8477,7 +9486,7 @@ function syntaxText(lang, source) {
   return (0, import_yaml.stringify)(file, { lineWidth: 0 });
 }
 function writeSyntax(configDir, sourcePath) {
-  const lang = syntaxName(sourcePath);
+  const lang = microSyntaxName(sourcePath);
   if (lang === null) {
     return;
   }
@@ -8489,9 +9498,9 @@ function writeSyntax(configDir, sourcePath) {
   if (text === null) {
     return;
   }
-  const dir = join8(configDir, "syntax");
+  const dir = join10(configDir, "syntax");
   mkdirSync4(dir, { recursive: true });
-  writeFileSync3(join8(dir, `pair-${lang}.yaml`), text, "utf-8");
+  writeFileSync4(join10(dir, `pair-${lang}.yaml`), text, "utf-8");
 }
 function createMicroEditor(resolvesOnPath = defaultResolvesOnPath) {
   return {
@@ -8504,7 +9513,7 @@ function createMicroEditor(resolvesOnPath = defaultResolvesOnPath) {
       return ["# F3 moves between panes. Ctrl+W or F2 sends and closes."];
     },
     bufferSuffix(sourcePath) {
-      const lang = syntaxName(sourcePath);
+      const lang = microSyntaxName(sourcePath);
       if (lang === null) {
         return ".diff";
       }
@@ -8512,13 +9521,13 @@ function createMicroEditor(resolvesOnPath = defaultResolvesOnPath) {
     },
     prepare(context) {
       mkdirSync4(context.configDir, { recursive: true });
-      writeFileSync3(
-        join8(context.configDir, "bindings.json"),
+      writeFileSync4(
+        join10(context.configDir, "bindings.json"),
         JSON.stringify(MICRO_BINDINGS, null, 2),
         "utf-8"
       );
-      writeFileSync3(
-        join8(context.configDir, "settings.json"),
+      writeFileSync4(
+        join10(context.configDir, "settings.json"),
         JSON.stringify(MICRO_SETTINGS, null, 2),
         "utf-8"
       );
@@ -8534,16 +9543,6 @@ function createMicroEditor(resolvesOnPath = defaultResolvesOnPath) {
 
 // src/editors/vim.ts
 import { extname as extname3 } from "node:path";
-var VIM_FILETYPE_OVERRIDES = {
-  python3: "python"
-};
-function vimFiletype(sourcePath) {
-  const lang = syntaxName(sourcePath);
-  if (lang === null) {
-    return null;
-  }
-  return VIM_FILETYPE_OVERRIDES[lang] ?? lang;
-}
 function safeThemeColor(value) {
   if (!isHexColor(value)) {
     throw new Error(`invalid theme colour for vim highlight: ${value}`);
@@ -8597,8 +9596,8 @@ function vimEditor(name, resolvesOnPath = defaultResolvesOnPath) {
 }
 
 // src/editors/nano.ts
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join9 } from "node:path";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join11 } from "node:path";
 function safeThemeColor2(value) {
   if (!isHexColor(value)) {
     throw new Error(`invalid theme colour for nano rcfile: ${value}`);
@@ -8610,8 +9609,8 @@ function writeNanorc(configDir, theme2) {
 color ,${safeThemeColor2(theme2.del)} "^\u258C\u258C-"
 color ,${safeThemeColor2(theme2.fold)} "^\u22EF"
 `;
-  const path = join9(configDir, "pair.nanorc");
-  writeFileSync4(path, text, "utf-8");
+  const path = join11(configDir, "pair.nanorc");
+  writeFileSync5(path, text, "utf-8");
   return path;
 }
 function createNanoEditor(resolvesOnPath = defaultResolvesOnPath) {
@@ -8755,17 +9754,17 @@ function createTmuxMultiplexer(spawn2 = defaultSpawn, resolvesOnPath = defaultRe
 }
 
 // src/multiplexers/tty.ts
-import { openSync, closeSync } from "node:fs";
-import { spawnSync as spawnSync3 } from "node:child_process";
-var defaultOpen = () => openSync("/dev/tty", "r+");
+import { openSync as openSync2, closeSync as closeSync2 } from "node:fs";
+import { spawnSync as spawnSync4 } from "node:child_process";
+var defaultOpen = () => openSync2("/dev/tty", "r+");
 var defaultRunner = (command, args, fd) => {
-  const result = spawnSync3(command, args, { stdio: [fd, fd, fd] });
+  const result = spawnSync4(command, args, { stdio: [fd, fd, fd] });
   const detail = result.status === 0 ? "" : String(result.error?.message ?? result.stderr ?? "");
   return { ok: result.status === 0, detail };
 };
 function closeQuietly(fd) {
   try {
-    closeSync(fd);
+    closeSync2(fd);
   } catch {
   }
 }
@@ -8823,8 +9822,8 @@ function detect(preference, adapters = {}) {
 }
 
 // src/cli/register/register.ts
-import { existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6, copyFileSync } from "node:fs";
-import { basename as basename2, dirname as dirname7, join as join10, sep as sep2 } from "node:path";
+import { existsSync as existsSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync6, mkdirSync as mkdirSync6, copyFileSync } from "node:fs";
+import { basename as basename5, dirname as dirname7, join as join12, sep as sep2 } from "node:path";
 var HOOK_TIMEOUT_SECONDS = 1800;
 function isHookEntry(value) {
   if (!isRecord(value)) {
@@ -8854,10 +9853,10 @@ function isHookGroup(value) {
   return value["hooks"].every(isHookEntry);
 }
 function readJsonObject(path) {
-  if (!existsSync6(path)) {
+  if (!existsSync8(path)) {
     return { ok: true, root: {} };
   }
-  const text = readFileSync3(path, "utf-8");
+  const text = readFileSync5(path, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(text);
@@ -8874,7 +9873,7 @@ function readJsonObject(path) {
 }
 var backedUpThisRun = /* @__PURE__ */ new Set();
 function backupIfPresent(path) {
-  if (!existsSync6(path)) {
+  if (!existsSync8(path)) {
     return null;
   }
   const backupPath = `${path}.pair-backup`;
@@ -8915,7 +9914,7 @@ function hasCommand(groups, command) {
   });
 }
 function matchesOurCommand(command) {
-  const suffix = sep2 + join10("dist", basename2(command));
+  const suffix = sep2 + join12("dist", basename5(command));
   return (entry) => entry.command === command || entry.command.endsWith(suffix);
 }
 function upsertHookGroup(groups, matcher, command, timeout) {
@@ -8947,7 +9946,7 @@ function upsertHookGroup(groups, matcher, command, timeout) {
 }
 function writeJsonObject(path, root) {
   mkdirSync6(dirname7(path), { recursive: true });
-  writeFileSync5(path, JSON.stringify(root, null, 2) + "\n", "utf-8");
+  writeFileSync6(path, JSON.stringify(root, null, 2) + "\n", "utf-8");
 }
 function registerPreToolUseHook(path, matcher, command, timeout) {
   const read = readJsonObject(path);
@@ -8971,7 +9970,7 @@ function registerPreToolUseHook(path, matcher, command, timeout) {
   return { path, changed: true, backupPath };
 }
 function isPreToolUseRegistered(path, command) {
-  if (!existsSync6(path)) {
+  if (!existsSync8(path)) {
     return false;
   }
   const read = readJsonObject(path);
@@ -8981,24 +9980,24 @@ function isPreToolUseRegistered(path, command) {
   return hasCommand(preToolUseGroups(read.root), command);
 }
 function claudeCodeSettingsPath(homeDir) {
-  return join10(homeDir, ".claude", "settings.json");
+  return join12(homeDir, ".claude", "settings.json");
 }
 function registerClaudeCode(homeDir, installRoot2) {
   const path = claudeCodeSettingsPath(homeDir);
-  const command = join10(installRoot2, "dist", "claude-code.js");
+  const command = join12(installRoot2, "dist", "claude-code.js");
   return registerPreToolUseHook(path, "Write|Edit|MultiEdit", command, HOOK_TIMEOUT_SECONDS);
 }
 function codexHooksPath(homeDir) {
-  return join10(homeDir, ".codex", "hooks.json");
+  return join12(homeDir, ".codex", "hooks.json");
 }
 function registerCodex(homeDir, installRoot2) {
   const path = codexHooksPath(homeDir);
-  const command = join10(installRoot2, "dist", "codex.js");
+  const command = join12(installRoot2, "dist", "codex.js");
   return registerPreToolUseHook(path, "apply_patch|Edit|Write", command, HOOK_TIMEOUT_SECONDS);
 }
 function findMultiEditMatchers(homeDir) {
   const path = codexHooksPath(homeDir);
-  if (!existsSync6(path)) {
+  if (!existsSync8(path)) {
     return [];
   }
   const read = readJsonObject(path);
@@ -9058,12 +10057,12 @@ function correctMultiEditMatchers(homeDir) {
   return { path, changed: true, backupPath, note };
 }
 function writeFileIfChanged(path, content) {
-  if (existsSync6(path) && readFileSync3(path, "utf-8") === content) {
+  if (existsSync8(path) && readFileSync5(path, "utf-8") === content) {
     return { path, changed: false, backupPath: null };
   }
   const backupPath = backupIfPresent(path);
   mkdirSync6(dirname7(path), { recursive: true });
-  writeFileSync5(path, content, "utf-8");
+  writeFileSync6(path, content, "utf-8");
   return { path, changed: true, backupPath };
 }
 function writeReExport(path, target) {
@@ -9076,29 +10075,29 @@ export { default } from "${target}";
 `;
 }
 function isReExportRegistered(path, target) {
-  if (!existsSync6(path)) {
+  if (!existsSync8(path)) {
     return false;
   }
-  return readFileSync3(path, "utf-8").includes(target);
+  return readFileSync5(path, "utf-8").includes(target);
 }
 function opencodePluginPath(homeDir) {
-  return join10(homeDir, ".config", "opencode", "plugin", "pair-mode.ts");
+  return join12(homeDir, ".config", "opencode", "plugin", "pair-mode.ts");
 }
 function registerOpencode(homeDir, installRoot2) {
-  const target = join10(installRoot2, "dist", "opencode.js");
+  const target = join12(installRoot2, "dist", "opencode.js");
   return writeReExport(opencodePluginPath(homeDir), target);
 }
 function piExtensionPath(homeDir) {
-  return join10(homeDir, ".pi", "agent", "extensions", "pair-mode.ts");
+  return join12(homeDir, ".pi", "agent", "extensions", "pair-mode.ts");
 }
 function registerPi(homeDir, installRoot2) {
-  const target = join10(installRoot2, "dist", "pi.js");
+  const target = join12(installRoot2, "dist", "pi.js");
   return writeFileIfChanged(piExtensionPath(homeDir), piExtensionSource(target));
 }
 
 // src/cli/register/commands.ts
-import { existsSync as existsSync7, readFileSync as readFileSync4 } from "node:fs";
-import { join as join11 } from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync6 } from "node:fs";
+import { join as join13 } from "node:path";
 var DESCRIPTION = "Toggle pair mode. Every proposed edit opens in the pair review pane for line annotation.";
 var INFER_ACTION = "Read the action from the user's message, then run `pair-mode <action>` and report the resulting state in one line.";
 var SPECS = {
@@ -9128,7 +10127,7 @@ var SPECS = {
   }
 };
 function pairCommandPath(homeDir, cli) {
-  return join11(homeDir, ...SPECS[cli].segments);
+  return join13(homeDir, ...SPECS[cli].segments);
 }
 function pairCommandSource(cli) {
   const spec = SPECS[cli];
@@ -9155,10 +10154,10 @@ function pairCommandSource(cli) {
 }
 function isPairCommandRegistered(homeDir, cli) {
   const path = pairCommandPath(homeDir, cli);
-  if (!existsSync7(path)) {
+  if (!existsSync9(path)) {
     return false;
   }
-  return readFileSync4(path, "utf-8") === pairCommandSource(cli);
+  return readFileSync6(path, "utf-8") === pairCommandSource(cli);
 }
 function registerPairCommand(homeDir, cli) {
   return writeFileIfChanged(pairCommandPath(homeDir, cli), pairCommandSource(cli));
@@ -9194,7 +10193,7 @@ function checkMultiplexer(config, adapters) {
 function checkControllingTerminal(openTty) {
   try {
     const fd = openTty();
-    closeSync2(fd);
+    closeSync3(fd);
     return { name: "controlling terminal", passed: true, detail: "/dev/tty opened" };
   } catch (error) {
     const name = error instanceof Error ? error.name : "Error";
@@ -9232,30 +10231,30 @@ function checkCommandOnPath(resolves) {
   };
 }
 function checkClis(home, root) {
-  const claudeCommand = join12(root, "dist", "claude-code.js");
-  const codexCommand = join12(root, "dist", "codex.js");
-  const opencodeTarget = join12(root, "dist", "opencode.js");
-  const piTarget = join12(root, "dist", "pi.js");
+  const claudeCommand = join14(root, "dist", "claude-code.js");
+  const codexCommand = join14(root, "dist", "codex.js");
+  const opencodeTarget = join14(root, "dist", "opencode.js");
+  const piTarget = join14(root, "dist", "pi.js");
   const specs = [
     {
       cli: "claude-code",
       registered: isPreToolUseRegistered(claudeCodeSettingsPath(home), claudeCommand),
-      targetExists: existsSync8(claudeCommand)
+      targetExists: existsSync10(claudeCommand)
     },
     {
       cli: "codex",
       registered: isPreToolUseRegistered(codexHooksPath(home), codexCommand),
-      targetExists: existsSync8(codexCommand)
+      targetExists: existsSync10(codexCommand)
     },
     {
       cli: "opencode",
       registered: isReExportRegistered(opencodePluginPath(home), opencodeTarget),
-      targetExists: existsSync8(opencodeTarget)
+      targetExists: existsSync10(opencodeTarget)
     },
     {
       cli: "pi",
       registered: isReExportRegistered(piExtensionPath(home), piTarget),
-      targetExists: existsSync8(piTarget)
+      targetExists: existsSync10(piTarget)
     }
   ];
   const shown = specs.filter((spec) => isReleased(spec.cli) || spec.registered);
@@ -9265,14 +10264,14 @@ function checkClis(home, root) {
 var SHEBANG_LINE = "#!/usr/bin/env node\n";
 function isExecutable(path) {
   try {
-    return (statSync(path).mode & 73) !== 0;
+    return (statSync2(path).mode & 73) !== 0;
   } catch {
     return false;
   }
 }
 function hasShebang(path) {
   try {
-    return readFileSync5(path, "utf-8").startsWith(SHEBANG_LINE);
+    return readFileSync7(path, "utf-8").startsWith(SHEBANG_LINE);
   } catch {
     return false;
   }
@@ -9286,10 +10285,10 @@ function checkEntryPoints(root) {
     "pi.js",
     "pair-tui.js"
   ];
-  const missing = entryPoints.filter((entry) => !existsSync8(join12(root, "dist", entry)));
+  const missing = entryPoints.filter((entry) => !existsSync10(join14(root, "dist", entry)));
   const present = entryPoints.filter((entry) => !missing.includes(entry));
-  const notExecutable = present.filter((entry) => !isExecutable(join12(root, "dist", entry)));
-  const missingShebang = present.filter((entry) => !hasShebang(join12(root, "dist", entry)));
+  const notExecutable = present.filter((entry) => !isExecutable(join14(root, "dist", entry)));
+  const missingShebang = present.filter((entry) => !hasShebang(join14(root, "dist", entry)));
   const problems = [];
   if (missing.length > 0) {
     problems.push(`missing: ${missing.join(", ")}`);
@@ -9327,11 +10326,11 @@ function checkTrace(config) {
   if (!config.trace) {
     return null;
   }
-  const tracePath = join12(stateDir(), "trace.log");
-  if (!existsSync8(tracePath)) {
+  const tracePath = join14(stateDir(), "trace.log");
+  if (!existsSync10(tracePath)) {
     return { name: "trace log", passed: true, detail: "tracing is on; no log written yet" };
   }
-  const lines = readFileSync5(tracePath, "utf-8").split("\n").filter((line2) => line2 !== "");
+  const lines = readFileSync7(tracePath, "utf-8").split("\n").filter((line2) => line2 !== "");
   const tail = lines.slice(-10);
   return {
     name: "trace log",
@@ -9339,12 +10338,14 @@ function checkTrace(config) {
     detail: tail.length === 0 ? "empty" : tail.join(" | ")
   };
 }
-var defaultOpenTty = () => openSync2("/dev/tty", "r+");
+var defaultOpenTty = () => openSync3("/dev/tty", "r+");
+var PROBE_NAME = ".pair-mode-doctor-probe";
 async function checkSession(config, directory, probe) {
-  const path = sessionSocketPath(directory);
+  const probeFile = join14(directory, PROBE_NAME);
+  const path = resolveSocketPath(probeFile, currentSessionKey()) ?? sessionSocketPath(directory);
   const name = `session: ${path}`;
   const wanted = config.transport === "session";
-  if (!existsSync8(path)) {
+  if (!existsSync10(path)) {
     return {
       name,
       passed: !wanted,
@@ -9352,11 +10353,12 @@ async function checkSession(config, directory, probe) {
       warnOnly: !wanted
     };
   }
-  const alive = await (probe ?? probeSocket)(path);
-  if (alive) {
+  const result = await (probe ?? probeSession)(path);
+  if (result.status !== "refused") {
     return { name, passed: true, detail: "a watcher is attached" };
   }
-  return { name, passed: false, detail: `stale socket, remove it with: rm ${path}` };
+  removeSession(basename6(path, ".sock"));
+  return { name, passed: true, detail: "removed a stale socket", warnOnly: true };
 }
 async function runDoctor(options = {}) {
   const home = options.homeDir ?? homedir4();
@@ -9373,7 +10375,7 @@ async function runDoctor(options = {}) {
     ...checkClis(home, root),
     checkEntryPoints(root),
     checkShiki(options.resolvesShiki),
-    await checkSession(config, options.directory ?? process.cwd(), options.probeSocket)
+    await checkSession(config, options.directory ?? process.cwd(), options.probeSession)
   ];
   const traceCheck = checkTrace(config);
   if (traceCheck !== null) {
@@ -9593,95 +10595,6 @@ async function runSetup(options = {}) {
   }
 }
 
-// src/cli/toggle.ts
-import { spawn } from "node:child_process";
-import { existsSync as existsSync9, readFileSync as readFileSync6, unlinkSync as unlinkSync3 } from "node:fs";
-var POLL_MS = 100;
-var POLL_ATTEMPTS = 60;
-function sleep(ms) {
-  return new Promise((done) => setTimeout(done, ms));
-}
-function readLink(directory) {
-  const path = sessionUrlPath(directory);
-  if (!existsSync9(path)) {
-    return null;
-  }
-  try {
-    const parsed = JSON.parse(readFileSync6(path, "utf-8"));
-    if (isRecord(parsed) && typeof parsed["url"] === "string" && typeof parsed["pid"] === "number") {
-      return { url: parsed["url"], pid: parsed["pid"] };
-    }
-  } catch {
-    return null;
-  }
-  return null;
-}
-async function waitForLink(directory) {
-  const attempts = Array.from({ length: POLL_ATTEMPTS }, (_, index) => index);
-  for (const _attempt of attempts) {
-    const link = readLink(directory);
-    if (link !== null) {
-      return link;
-    }
-    await sleep(POLL_MS);
-  }
-  return null;
-}
-function stopLink(directory) {
-  const link = readLink(directory);
-  if (link === null) {
-    return false;
-  }
-  try {
-    process.kill(link.pid, "SIGTERM");
-  } catch {
-  }
-  try {
-    unlinkSync3(sessionUrlPath(directory));
-  } catch {
-  }
-  return true;
-}
-function pairOn(directory) {
-  enable(directory);
-  return `pair mode ON for ${directory}`;
-}
-async function pairOnWeb(directory, cliPath) {
-  enable(directory);
-  const existing = readLink(directory);
-  if (existing !== null) {
-    return `pair mode ON for ${directory}
-${existing.url}`;
-  }
-  const child = spawn(process.execPath, [cliPath, "watch", "--web", directory], {
-    detached: true,
-    stdio: "ignore"
-  });
-  child.unref();
-  const link = await waitForLink(directory);
-  if (link === null) {
-    return `pair mode ON for ${directory}
-the web watcher did not report a link`;
-  }
-  return `pair mode ON for ${directory}
-${link.url}`;
-}
-function pairOff(directory) {
-  disable(directory);
-  const stopped = stopLink(directory);
-  return stopped ? `pair mode OFF for ${directory} (web watcher stopped)` : `pair mode OFF for ${directory}`;
-}
-function pairStatus(directory) {
-  const on = existsSync9(flagPath(directory));
-  const link = readLink(directory);
-  const state = `pair mode ${on ? "ON" : "OFF"} for ${directory}`;
-  return link === null ? state : `${state}
-${link.url}`;
-}
-
-// src/cli/watch/watch.ts
-import { createConnection as createConnection2 } from "node:net";
-
 // node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/diff/base.js
 var Diff = class {
   diff(oldStr, newStr, options = {}) {
@@ -10167,7 +11080,7 @@ function diffArrays(oldArr, newArr, options) {
 }
 
 // src/tui/paint/layout.ts
-import { basename as basename3 } from "node:path";
+import { basename as basename7 } from "node:path";
 
 // src/core/diff/diff.ts
 function mergeChangedPair(first, second, i, j) {
@@ -10227,7 +11140,7 @@ var TAB_WIDTH = 8;
 var CONTROL_BYTE_CEILING = 32;
 var CONTROL_BYTE_PLACEHOLDER = "?";
 function sanitizeLine(text) {
-  const scan = text.split("").reduce(
+  const scan2 = text.split("").reduce(
     (state, char) => {
       if (char === "	") {
         const width = TAB_WIDTH - state.column % TAB_WIDTH;
@@ -10243,7 +11156,7 @@ function sanitizeLine(text) {
     },
     { output: "", column: 0 }
   );
-  return scan.output;
+  return scan2.output;
 }
 function buildRows(before, after) {
   return opcodes(before, after).flatMap((opcode) => {
@@ -10890,7 +11803,7 @@ function paintFoldRow(fold2, width, truecolor, cursorRow) {
   return fg(color, truecolor) + " ".repeat(leftPadding) + label + " ".repeat(rightPadding) + RESET;
 }
 function paintHeader(path, addCount, delCount, width, truecolor) {
-  const prefix = `pair mode\u2502${basename3(path)}\u2502`;
+  const prefix = `pair mode\u2502${basename7(path)}\u2502`;
   const addText = `+${addCount}`;
   const delText = `-${delCount}`;
   const used = prefix.length + addText.length + HEADER_COUNT_GAP_WIDTH + delText.length;
@@ -11412,7 +12325,7 @@ function indentWidth(line2) {
 }
 function changedSpans(before, after) {
   const chunks = diffWordsWithSpace(before, after);
-  const scan = chunks.reduce(
+  const scan2 = chunks.reduce(
     (state, chunk) => {
       const length = chunk.value.length;
       if (chunk.removed === true) {
@@ -11438,7 +12351,7 @@ function changedSpans(before, after) {
     },
     { left: [], right: [], sharedLength: 0, leftCursor: 0, rightCursor: 0 }
   );
-  const { left, right, sharedLength } = scan;
+  const { left, right, sharedLength } = scan2;
   const indent = Math.min(indentWidth(before), indentWidth(after));
   const longer = Math.max(before.length, after.length) - indent;
   const sharedFraction = longer <= 0 ? 1 : (sharedLength - indent) / longer;
@@ -11461,7 +12374,7 @@ function decideLayout(options) {
 function layoutStatusMessage(options) {
   return decideLayout(options).overrideReason;
 }
-function paint(options) {
+function paint2(options) {
   const { layout } = decideLayout(options);
   return layout === "unified" ? paintUnified(options) : paintSplit(options);
 }
@@ -11671,7 +12584,7 @@ function splitInput(chunk) {
 }
 
 // src/tui/notes/notes.ts
-import { writeFileSync as writeFileSync6 } from "node:fs";
+import { writeFileSync as writeFileSync7 } from "node:fs";
 function rangeOf(selection) {
   const reversed = selection.anchorRow > selection.headRow || selection.anchorRow === selection.headRow && selection.anchorColumn > selection.headColumn;
   if (!reversed) {
@@ -11742,7 +12655,7 @@ function toQuestions(notes) {
 }
 function writeResult(path, notes) {
   try {
-    writeFileSync6(path, JSON.stringify({ questions: toQuestions(notes) }, null, 2), "utf-8");
+    writeFileSync7(path, JSON.stringify({ questions: toQuestions(notes) }, null, 2), "utf-8");
   } catch {
     return;
   }
@@ -12039,7 +12952,7 @@ function runTui(options, io, abort) {
     let finished = false;
     const repaint = () => {
       const { width, height } = io.size();
-      const result = paint({
+      const result = paint2({
         model: state.model,
         width,
         height,
@@ -12200,6 +13113,9 @@ function createWatchIo() {
   });
   process.stdout.on("resize", () => resizeHandler?.());
   return {
+    isTty() {
+      return process.stdin.isTTY === true;
+    },
     onKey(handler) {
       keyHandler = handler;
     },
@@ -12232,23 +13148,15 @@ function createWatchIo() {
 }
 
 // src/cli/watch/watch.ts
-var CLEAR_SCREEN = "\x1B[2J\x1B[H";
-var QUIT_KEYS = ["q", "", ""];
+var CLEAR_SCREEN2 = "\x1B[2J\x1B[H";
+var QUIT_KEYS2 = ["q", "", ""];
 function reportErrors(errors) {
   errors.forEach((error) => process.stderr.write(`pair-mode: ${error.message}
 `));
 }
 function paintIdle(io, status, truecolor) {
   const { width } = io.size();
-  io.write(CLEAR_SCREEN + renderIdle(status, width, truecolor).join("\r\n") + "\r\n");
-}
-function connectSelf(socketPath) {
-  return new Promise((resolve3, reject) => {
-    const socket = createConnection2(socketPath);
-    socket.setEncoding("utf-8");
-    socket.once("error", reject);
-    socket.once("connect", () => resolve3(socket));
-  });
+  io.write(CLEAR_SCREEN2 + renderIdle(status, width, truecolor).join("\r\n") + "\r\n");
 }
 async function optionsFor(review, config, io, resultFile) {
   const truecolor = supportsTruecolor(process.env);
@@ -12275,24 +13183,29 @@ async function optionsFor(review, config, io, resultFile) {
   };
 }
 async function runWatch(options, config) {
-  const socketPath = options.socketPath ?? sessionSocketPath(options.directory);
+  const socketPath = watchSocketPath(options.directory, options.sessionKey, options.socketPath);
   let errors = [];
-  const server = await startSessionServer({
+  const owns = (await probeSession(socketPath)).status === "refused";
+  const host = owns ? await ownerHost({
     socketPath,
+    client: "tui",
+    record: buildSessionRecord(options, socketPath),
     onError: (error) => {
       errors = [...errors, error];
     }
-  });
+  }) : await viewerHost({ socketPath, client: "tui" });
+  await sweepDeadSessions();
   const truecolor = supportsTruecolor(process.env);
   const io = options.io ?? createWatchIo();
-  const status = () => ({
-    directory: options.directory,
-    socketPath,
-    clients: server.clientCount(),
-    waiting: server.waitingDepth()
-  });
-  const client = await connectSelf(socketPath);
-  const readLines = createLineReader();
+  const status = () => {
+    const counts = host.counts();
+    return {
+      directory: options.directory,
+      socketPath,
+      clients: counts.clients,
+      waiting: counts.waiting
+    };
+  };
   const pending = [];
   const cancelled = /* @__PURE__ */ new Set();
   const aborts = /* @__PURE__ */ new Map();
@@ -12306,37 +13219,31 @@ async function runWatch(options, config) {
   };
   const listenIdle = () => {
     io.onKey((chunk) => {
-      if (QUIT_KEYS.includes(chunk)) {
+      if (QUIT_KEYS2.includes(chunk)) {
         quitting = true;
         nudge();
       }
     });
     io.onResize(() => paintIdle(io, status(), truecolor));
   };
-  client.on("data", (chunk) => {
-    readLines(chunk).forEach((line2) => {
-      const message = decodeLine(line2);
-      if (message?.type === "review") {
-        pending.push(message);
-        nudge();
-        return;
-      }
-      if (message?.type === "cancel") {
-        cancelled.add(message.id);
-        aborts.get(message.id)?.abort();
-        nudge();
-      }
-    });
+  host.onReview((review) => {
+    pending.push(review);
+    nudge();
+  });
+  host.onCancel((id) => {
+    cancelled.add(id);
+    aborts.get(id)?.abort();
+    nudge();
   });
-  server.onChange(() => {
+  host.onChange(() => {
     if (!busy && !quitting) {
       paintIdle(io, status(), truecolor);
     }
   });
-  client.write(encode({ type: "attach", client: "tui" }));
   while (!quitting) {
     const review = pending.shift();
     if (review === void 0) {
+      host.refreshCounts();
       listenIdle();
       paintIdle(io, status(), truecolor);
       await new Promise((resolve3) => {
@@ -12352,8 +13259,7 @@ async function runWatch(options, config) {
       const tuiOptions = await optionsFor(review, config, io, resultFile);
       const result = await runTui(tuiOptions, io, abort.signal);
       if (!cancelled.has(review.id)) {
-        const questions = result.quit === "send" ? result.questions : [];
-        client.write(encode({ type: "verdict", id: review.id, questions }));
+        host.verdict(review.id, result.quit === "send" ? result.questions : []);
       }
     } finally {
       aborts.delete(review.id);
@@ -12362,10 +13268,9 @@ async function runWatch(options, config) {
       busy = false;
     }
   }
-  io.write(CLEAR_SCREEN);
+  io.write(CLEAR_SCREEN2);
   io.shutdown();
-  client.destroy();
-  await server.close();
+  await host.close();
   reportErrors(errors);
   return 0;
 }
@@ -12601,7 +13506,7 @@ function runConfig(args, path) {
 // src/web/server.ts
 import { createServer as createServer2 } from "node:http";
 import { randomBytes as randomBytes4 } from "node:crypto";
-import { existsSync as existsSync10, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync8 } from "node:fs";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // src/web/client/bundle.ts
@@ -13668,7 +14573,7 @@ var MAX_BODY_BYTES = 1e6;
 function readAsset(name) {
   const bundled = fileURLToPath4(new URL(`../assets/${name}`, import.meta.url));
   const source = fileURLToPath4(new URL(`../../assets/${name}`, import.meta.url));
-  return readFileSync7(existsSync10(bundled) ? bundled : source);
+  return readFileSync8(existsSync11(bundled) ? bundled : source);
 }
 var IMAGES = {
   "favicon.png": readAsset("favicon.png"),
@@ -13751,7 +14656,7 @@ function startWebServer(options) {
   const token = options.token ?? defaultToken();
   const base = `/r/${token}`;
   const viewers = /* @__PURE__ */ new Set();
-  let current = null;
+  let pending = [];
   function sendEvent(response, event, data) {
     response.write(`event: ${event}
 data: ${data}
@@ -13768,14 +14673,30 @@ data: ${data}
     response.write(": open\n\n");
     viewers.add(response);
     response.on("close", () => viewers.delete(response));
-    if (current !== null) {
-      sendEvent(response, "review", JSON.stringify(current));
+    const open = pending[0];
+    if (!open) {
+      return;
     }
+    sendEvent(response, "review", JSON.stringify(open));
   }
   function broadcastCancel(id) {
     const data = JSON.stringify({ id });
     viewers.forEach((viewer) => sendEvent(viewer, "cancel", data));
   }
+  function broadcastReview(review) {
+    const data = JSON.stringify(review);
+    viewers.forEach((viewer) => sendEvent(viewer, "review", data));
+  }
+  function retire(id) {
+    const wasOpen = pending[0]?.id === id;
+    pending = pending.filter((review) => review.id !== id);
+    broadcastCancel(id);
+    const next = pending[0];
+    if (!wasOpen || !next) {
+      return;
+    }
+    broadcastReview(next);
+  }
   async function handleVerdict(request, response) {
     const result = await readBody(request);
     if (result.kind === "too-large") {
@@ -13791,13 +14712,12 @@ data: ${data}
       response.writeHead(BAD_REQUEST).end();
       return;
     }
-    const answered = current;
-    if (answered === null || answered.id !== verdict.id) {
+    const answered = pending[0];
+    if (!answered || answered.id !== verdict.id) {
       response.writeHead(CONFLICT, { "content-type": "application/json" }).end("{}");
       return;
     }
-    current = null;
-    broadcastCancel(verdict.id);
+    retire(verdict.id);
     options.onVerdict(verdict.id, webNotesToQuestions(answered, verdict.notes));
     response.writeHead(OK, { "content-type": "application/json" }).end("{}");
   }
@@ -13809,7 +14729,7 @@ data: ${data}
       return;
     }
     const image = url.startsWith(`${base}/`) ? IMAGES[url.slice(base.length + 1)] : void 0;
-    if (image !== void 0 && request.method === "GET") {
+    if (image && request.method === "GET") {
       response.writeHead(OK, { "content-type": "image/png" });
       response.end(image);
       return;
@@ -13838,21 +14758,20 @@ data: ${data}
           return viewers.size;
         },
         offer(review) {
-          current = review;
-          const data = JSON.stringify(review);
-          viewers.forEach((viewer) => sendEvent(viewer, "review", data));
+          pending = [...pending, review];
+          if (pending.length === 1) {
+            broadcastReview(review);
+          }
         },
         // A withdrawal for an older review must leave the one now open alone.
         withdraw(id) {
-          if (current?.id === id) {
-            current = null;
-          }
-          broadcastCancel(id);
+          retire(id);
         },
         close() {
           return new Promise((done) => {
             viewers.forEach((viewer) => viewer.end());
             viewers.clear();
+            pending = [];
             server.close(() => done());
           });
         }
@@ -13862,8 +14781,7 @@ data: ${data}
 }
 
 // src/web/watch.ts
-import { createConnection as createConnection3 } from "node:net";
-import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync7, readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "node:fs";
 import { dirname as dirname8 } from "node:path";
 
 // src/web/review.ts
@@ -13892,73 +14810,105 @@ async function toWebReview(review, config) {
 }
 
 // src/web/watch.ts
+var OWNER_ONLY_DIR3 = 448;
+var OWNER_ONLY_FILE2 = 384;
 function publishUrl(path, url) {
-  mkdirSync7(dirname8(path), { recursive: true });
-  writeFileSync7(path, JSON.stringify({ url, pid: process.pid }) + "\n", "utf-8");
-}
-function connectSelf2(socketPath) {
-  return new Promise((resolve3, reject) => {
-    const socket = createConnection3(socketPath);
-    socket.setEncoding("utf-8");
-    socket.once("error", reject);
-    socket.once("connect", () => resolve3(socket));
+  mkdirSync7(dirname8(path), { recursive: true, mode: OWNER_ONLY_DIR3 });
+  writeFileSync8(path, JSON.stringify({ url, pid: process.pid }) + "\n", {
+    encoding: "utf-8",
+    mode: OWNER_ONLY_FILE2
   });
 }
+function linkPid(path) {
+  try {
+    const parsed = JSON.parse(readFileSync9(path, "utf-8"));
+    return isRecord(parsed) && typeof parsed["pid"] === "number" ? parsed["pid"] : null;
+  } catch {
+    return null;
+  }
+}
 async function startWebWatch(options, config) {
-  const socketPath = options.socketPath ?? sessionSocketPath(options.directory);
-  const session = await startSessionServer({ socketPath });
-  const client = await connectSelf2(socketPath);
+  const socketPath = watchSocketPath(options.directory, options.sessionKey, options.socketPath);
+  const owns = (await probeSession(socketPath)).status === "refused";
+  const host = owns ? await ownerHost({
+    socketPath,
+    client: "web",
+    record: buildSessionRecord(options, socketPath)
+  }) : await viewerHost({ socketPath, client: "web" });
+  const ownedIds = /* @__PURE__ */ new Set();
   const web = await startWebServer({
     port: options.port,
     token: options.token,
     layout: config.layout,
     onVerdict(id, questions) {
-      client.write(encode({ type: "verdict", id, questions }));
+      ownedIds.delete(id);
+      host.verdict(id, questions);
     }
   });
-  const readLines = createLineReader();
-  let ownedId = null;
-  client.on("data", (chunk) => {
-    readLines(chunk).forEach((line2) => {
-      const message = decodeLine(line2);
-      if (message?.type === "review") {
-        const id = message.id;
-        ownedId = id;
-        void toWebReview(message, config).then((review) => {
-          if (ownedId === id) {
-            web.offer(review);
-          }
-        }).catch(() => {
-          if (ownedId === id) {
-            client.write(encode({ type: "verdict", id, questions: [] }));
-          }
-        });
-        return;
+  host.onReview((message) => {
+    const id = message.id;
+    ownedIds.add(id);
+    void toWebReview(message, config).then((review) => {
+      if (ownedIds.has(id)) {
+        web.offer(review);
       }
-      if (message?.type === "cancel") {
-        if (ownedId === message.id) {
-          ownedId = null;
-        }
-        web.withdraw(message.id);
+    }).catch(() => {
+      if (ownedIds.delete(id)) {
+        host.verdict(id, []);
       }
     });
   });
-  const urlPath = sessionUrlPath(options.directory);
-  publishUrl(urlPath, web.url);
-  client.write(encode({ type: "attach", client: "web" }));
+  host.onCancel((id) => {
+    ownedIds.delete(id);
+    web.withdraw(id);
+  });
+  const urlPath = watchUrlPath(options.directory, options.sessionKey);
+  const published = owns || !existsSync12(urlPath);
+  if (published) {
+    publishUrl(urlPath, web.url);
+  }
   return {
     url: web.url,
     socketPath,
     port: web.port,
+    owns,
     async close() {
-      removeQuietly(urlPath);
-      client.destroy();
+      if (published && linkPid(urlPath) === process.pid) {
+        removeQuietly(urlPath);
+      }
       await web.close();
-      await session.close();
+      await host.close();
     }
   };
 }
 
+// src/cli/watch-target.ts
+function usesWebWatcher(target, webEnabled) {
+  return target.web || webEnabled;
+}
+async function watchSession(target) {
+  const { directory, sessionKey: sessionKey2, socketPath } = target;
+  const { config, errors } = loadConfig();
+  errors.forEach((error) => console.error(`config ${error.path}: ${error.message}`));
+  if (!usesWebWatcher(target, config.web.enabled)) {
+    return await runWatch({ directory, sessionKey: sessionKey2, socketPath }, config);
+  }
+  const watcher = await startWebWatch(
+    { directory, sessionKey: sessionKey2, socketPath, port: config.web.port },
+    config
+  );
+  console.log(`pair mode is watching ${directory}`);
+  console.log(watcher.url);
+  await new Promise((done) => {
+    const stop = () => {
+      void watcher.close().then(done);
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+  });
+  return 0;
+}
+
 // src/cli/index.ts
 var USAGE = `pair-mode <command> [directory]
 
@@ -13971,16 +14921,21 @@ Commands:
   on [dir]             turn pair mode on for a directory (default: cwd)
   on --web [dir]       turn pair mode on and serve the review in a browser
   off [dir]            turn pair mode off for a directory (default: cwd)
+  toggle [dir]         flip pair mode for a directory (default: cwd)
+  toggle --web [dir]   flip pair mode, and serve the review in a browser when it turns on
   status [dir]         report pair mode status for a directory (default: cwd)
   watch [dir]          review edits in this terminal (default: cwd)
   watch --web [dir]    serve the review in a browser and print the link
+  watch <id>           review edits for one session (see: pair-mode sessions)
+  sessions             list every live pair mode session
+  connect              pick a session from a list and watch it
   --version            print the installed version
   --help               print this message
 `;
 function readVersion() {
-  const pkgPath = join13(installRoot(), "package.json");
+  const pkgPath = join15(installRoot(), "package.json");
   try {
-    const raw = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+    const raw = JSON.parse(readFileSync10(pkgPath, "utf-8"));
     if (isRecord(raw) && typeof raw["version"] === "string") {
       return raw["version"];
     }
@@ -14000,6 +14955,33 @@ function parseDirectoryArgs(args, allowedFlags) {
     unknownFlag: flags.find((flag) => !allowedFlags.includes(flag)) ?? null
   };
 }
+var SESSION_KEY_PATTERN = /^s-[0-9a-f]{8}$/;
+var SESSION_KEY_PREFIX = "s-";
+function parseWatchArgs(args) {
+  const flags = args.filter(isFlag);
+  const target = args.find((entry) => !isFlag(entry));
+  const looksLikeKey = target !== void 0 && target.startsWith(SESSION_KEY_PREFIX);
+  const isKey = looksLikeKey && SESSION_KEY_PATTERN.test(target);
+  return {
+    sessionKey: isKey ? target : void 0,
+    malformedKey: looksLikeKey && !isKey ? target : null,
+    directory: isKey ? process.cwd() : resolve2(target ?? process.cwd()),
+    web: flags.includes("--web"),
+    unknownFlag: flags.find((flag) => flag !== "--web") ?? null
+  };
+}
+function reportExtraArgs(command, args) {
+  const extra = args[0];
+  if (extra === void 0) {
+    return null;
+  }
+  if (isFlag(extra)) {
+    return reportUnknownFlag(command, extra);
+  }
+  console.error(`unexpected argument for ${command}: ${extra}`);
+  console.error(USAGE);
+  return 1;
+}
 function reportUnknownFlag(command, flag) {
   console.error(`unknown option for ${command}: ${flag}`);
   console.error(USAGE);
@@ -14034,11 +15016,13 @@ async function main() {
     if (parsed.unknownFlag !== null) {
       return reportUnknownFlag(command, parsed.unknownFlag);
     }
+    await sweepDeadSessions();
+    const key = currentSessionKey();
     if (parsed.web) {
-      console.log(await pairOnWeb(parsed.directory, process.argv[1] ?? ""));
+      console.log(await pairOnWeb(parsed.directory, process.argv[1] ?? "", key));
       return 0;
     }
-    console.log(pairOn(parsed.directory));
+    console.log(pairOn(parsed.directory, key));
     return 0;
   }
   if (command === "off") {
@@ -14046,7 +15030,17 @@ async function main() {
     if (parsed.unknownFlag !== null) {
       return reportUnknownFlag(command, parsed.unknownFlag);
     }
-    console.log(pairOff(parsed.directory));
+    console.log(pairOff(parsed.directory, currentSessionKey()));
+    return 0;
+  }
+  if (command === "toggle") {
+    const parsed = parseDirectoryArgs(process.argv.slice(3), ["--web"]);
+    if (parsed.unknownFlag !== null) {
+      return reportUnknownFlag(command, parsed.unknownFlag);
+    }
+    console.log(
+      await pairToggle(parsed.directory, process.argv[1] ?? "", parsed.web, currentSessionKey())
+    );
     return 0;
   }
   if (command === "status") {
@@ -14054,32 +15048,52 @@ async function main() {
     if (parsed.unknownFlag !== null) {
       return reportUnknownFlag(command, parsed.unknownFlag);
     }
-    console.log(pairStatus(parsed.directory));
+    console.log(pairStatus(parsed.directory, currentSessionKey()));
     return 0;
   }
   if (command === "watch") {
-    const parsed = parseDirectoryArgs(process.argv.slice(3), ["--web"]);
+    const parsed = parseWatchArgs(process.argv.slice(3));
     if (parsed.unknownFlag !== null) {
       return reportUnknownFlag(command, parsed.unknownFlag);
     }
-    const wantsWeb = parsed.web;
-    const directory = parsed.directory;
-    const { config, errors } = loadConfig();
-    errors.forEach((error) => console.error(`config ${error.path}: ${error.message}`));
-    if (!wantsWeb && !config.web.enabled) {
-      return runWatch({ directory }, config);
-    }
-    const watcher = await startWebWatch({ directory, port: config.web.port }, config);
-    console.log(`pair mode is watching ${directory}`);
-    console.log(watcher.url);
-    await new Promise((done) => {
-      const stop = () => {
-        void watcher.close().then(done);
-      };
-      process.once("SIGINT", stop);
-      process.once("SIGTERM", stop);
+    if (parsed.malformedKey !== null) {
+      console.error(`malformed session id: ${parsed.malformedKey}`);
+      console.error(
+        "an id is s- followed by eight hex characters; run pair-mode sessions to list them"
+      );
+      return 1;
+    }
+    return await watchSession({
+      directory: parsed.directory,
+      sessionKey: parsed.sessionKey,
+      web: parsed.web
+    });
+  }
+  if (command === "sessions") {
+    const rejected = reportExtraArgs(command, process.argv.slice(3));
+    if (rejected !== null) {
+      return rejected;
+    }
+    const result = await listSessions();
+    console.log(result.text);
+    return result.exitCode;
+  }
+  if (command === "connect") {
+    const rejected = reportExtraArgs(command, process.argv.slice(3));
+    if (rejected !== null) {
+      return rejected;
+    }
+    const result = await runConnect(createWatchIo());
+    const chosen = result.selected;
+    if (chosen === null) {
+      return result.exitCode;
+    }
+    return await watchSession({
+      directory: chosen.directory === "" ? process.cwd() : chosen.directory,
+      sessionKey: chosen.kind === "session" ? chosen.id : void 0,
+      socketPath: join15(sessionsDir(), `${chosen.id}.sock`),
+      web: false
     });
-    return 0;
   }
   console.error(`unknown command: ${command}`);
   console.error(USAGE);