pair-mode 0.3.0 → 0.3.3

package/dist/pi.js

@@ -7363,11 +7363,72 @@ var require_dist = __commonJS({
 // src/core/state/state.ts
 import { createHash } from "node:crypto";
 import { homedir } from "node:os";
-import { join, dirname, basename } from "node:path";
-import { existsSync, realpathSync, mkdirSync, writeFileSync, unlinkSync } from "node:fs";
+import { join as join2, dirname, basename } from "node:path";
+import { existsSync, realpathSync, mkdirSync, writeFileSync, unlinkSync as unlinkSync2 } from "node:fs";
+
+// src/helpers/isRecord.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/helpers/readFileOrEmpty.ts
+import { readFileSync } from "node:fs";
+function readFileOrEmpty(path) {
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return "";
+  }
+}
+
+// src/helpers/removeQuietly.ts
+import { unlinkSync } from "node:fs";
+function removeQuietly(path) {
+  try {
+    unlinkSync(path);
+  } catch {
+  }
+}
+
+// src/helpers/resolvesOnPath.ts
+import { spawnSync } from "node:child_process";
+var defaultResolvesOnPath = (command) => {
+  const result = spawnSync("which", [command], { stdio: "ignore" });
+  return result.status === 0;
+};
+
+// src/helpers/resultFilePath.ts
+import { randomBytes } from "node:crypto";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+var NAME_BYTES = 6;
+function resultFilePath() {
+  const name = `pair-result-${randomBytes(NAME_BYTES).toString("hex")}.json`;
+  return join(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"] || join(homedir(), ".local", "state");
-  return join(base, "pair-mode");
+  const base = process.env["XDG_STATE_HOME"] || join2(homedir(), ".local", "state");
+  return join2(base, "pair-mode");
 }
 function realpathLenient(path) {
   try {
@@ -7377,7 +7438,7 @@ function realpathLenient(path) {
     if (parent === path) {
       return path;
     }
-    return join(realpathLenient(parent), basename(path));
+    return join2(realpathLenient(parent), basename(path));
   }
 }
 var DIGEST_LENGTH = 16;
@@ -7386,16 +7447,23 @@ function digestFor(directory) {
   return createHash("sha1").update(real).digest("hex").slice(0, DIGEST_LENGTH);
 }
 function flagPath(directory) {
-  return join(stateDir(), `${digestFor(directory)}.on`);
+  return join2(stateDir(), `${digestFor(directory)}.on`);
 }
 function sessionsDir() {
-  return join(stateDir(), "sessions");
+  return join2(stateDir(), "sessions");
+}
+var OWNER_ONLY_DIR = 448;
+var OWNER_ONLY_FILE = 384;
+function makeSessionsDir() {
+  const path = sessionsDir();
+  mkdirSync(path, { recursive: true, mode: OWNER_ONLY_DIR });
+  return path;
 }
 function sessionSocketPath(directory) {
-  return join(sessionsDir(), `${digestFor(directory)}.sock`);
+  return join2(sessionsDir(), `${digestFor(directory)}.sock`);
 }
 function sessionUrlPath(directory) {
-  return join(sessionsDir(), `${digestFor(directory)}.url`);
+  return join2(sessionsDir(), `${digestFor(directory)}.url`);
 }
 function findSessionSocket(filePath) {
   let current = dirname(realpathLenient(filePath));
@@ -7411,7 +7479,13 @@ function findSessionSocket(filePath) {
     current = parent;
   }
 }
-function isEnabled(filePath) {
+function sessionFlagState(key) {
+  if (existsSync(sessionKeyOptOutPath(key))) {
+    return "off";
+  }
+  return existsSync(sessionKeyFlagPath(key)) ? "on" : "unset";
+}
+function directoryEnabled(filePath) {
   let current = dirname(realpathLenient(filePath));
   while (true) {
     if (existsSync(flagPath(current))) {
@@ -7424,6 +7498,29 @@ function isEnabled(filePath) {
     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));
+  writeFileSync(path, "", { mode: OWNER_ONLY_FILE });
+  return path;
+}
+function optOutSession(key) {
+  const path = sessionKeyOptOutPath(key);
+  makeSessionsDir();
+  removeQuietly(sessionKeyFlagPath(key));
+  writeFileSync(path, "", { mode: OWNER_ONLY_FILE });
+  return path;
+}
 function enable(directory) {
   const path = flagPath(directory);
   mkdirSync(dirname(path), { recursive: true });
@@ -7435,13 +7532,34 @@ function disable(directory) {
   if (!existsSync(path)) {
     return false;
   }
-  unlinkSync(path);
+  unlinkSync2(path);
   return true;
 }
-
-// src/helpers/isRecord.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+var SESSION_KEY_LENGTH = 8;
+function sessionKey(agentSessionId) {
+  const digest = createHash("sha1").update(agentSessionId).digest("hex");
+  return `s-${digest.slice(0, SESSION_KEY_LENGTH)}`;
+}
+function watchUrlPath(directory, key) {
+  return key ? sessionKeyUrlPath(key) : sessionUrlPath(directory);
+}
+function keyFor(agentSessionId) {
+  return agentSessionId === void 0 || agentSessionId === "" ? void 0 : sessionKey(agentSessionId);
+}
+function sessionKeyPath(key, extension) {
+  return join2(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/core/simulate/simulate.ts
@@ -7488,7 +7606,7 @@ function applyEdit(text, edit) {
   }
   return replaceFirst(text, old, next);
 }
-function simulate(tool, input, readFile) {
+function simulate(tool, input, readFile, sessionId) {
   if (!isRecord(input)) {
     return null;
   }
@@ -7500,7 +7618,7 @@ function simulate(tool, input, readFile) {
     const content = input["content"];
     const after = typeof content === "string" ? content : "";
     const before = readFile(filePath);
-    return { tool, filePath, before, after };
+    return { tool, filePath, before, after, sessionId };
   }
   if (tool === "Edit" || tool === "MultiEdit") {
     const editsRaw = input["edits"];
@@ -7515,71 +7633,19 @@ function simulate(tool, input, readFile) {
     if (after === null) {
       return null;
     }
-    return { tool, filePath, before, after };
+    return { tool, filePath, before, after, sessionId };
   }
   return null;
 }
 
 // src/cli/toggle.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, unlinkSync as unlinkSync3 } from "node:fs";
-
-// src/helpers/readFileOrEmpty.ts
-import { readFileSync } from "node:fs";
-function readFileOrEmpty(path) {
-  try {
-    return readFileSync(path, "utf-8");
-  } catch {
-    return "";
-  }
-}
-
-// src/helpers/removeQuietly.ts
-import { unlinkSync as unlinkSync2 } from "node:fs";
-function removeQuietly(path) {
-  try {
-    unlinkSync2(path);
-  } catch {
-  }
+import { join as join3 } from "node:path";
+function statusProbe(directory) {
+  return join3(directory, ".pair-mode-status-probe");
 }
-
-// src/helpers/resolvesOnPath.ts
-import { spawnSync } from "node:child_process";
-var defaultResolvesOnPath = (command) => {
-  const result = spawnSync("which", [command], { stdio: "ignore" });
-  return result.status === 0;
-};
-
-// src/helpers/resultFilePath.ts
-import { randomBytes } from "node:crypto";
-import { tmpdir } from "node:os";
-import { join as join2 } from "node:path";
-var NAME_BYTES = 6;
-function resultFilePath() {
-  const name = `pair-result-${randomBytes(NAME_BYTES).toString("hex")}.json`;
-  return join2(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/cli/toggle.ts
-function readLink(directory) {
-  const path = sessionUrlPath(directory);
+function readLink(directory, key) {
+  const path = watchUrlPath(directory, key);
   if (!existsSync2(path)) {
     return null;
   }
@@ -7593,8 +7659,8 @@ function readLink(directory) {
   }
   return null;
 }
-function stopLink(directory) {
-  const link = readLink(directory);
+function stopLink(directory, key) {
+  const link = readLink(directory, key);
   if (link === null) {
     return false;
   }
@@ -7603,24 +7669,37 @@ function stopLink(directory) {
   } catch {
   }
   try {
-    unlinkSync3(sessionUrlPath(directory));
+    unlinkSync3(watchUrlPath(directory, key));
   } catch {
   }
   return true;
 }
-function pairOn(directory) {
-  enable(directory);
-  return `pair mode ON for ${directory}`;
+function onHeadline(directory, key) {
+  return key ? `pair mode ON \xB7 ${key} \xB7 ${directory}` : `pair mode ON for ${directory}`;
 }
-function pairOff(directory) {
+function pairOn(directory, key) {
+  if (key) {
+    enableSession(key);
+  } else {
+    enable(directory);
+  }
+  return onHeadline(directory, key);
+}
+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}`;
 }
-function pairStatus(directory) {
-  const on = existsSync2(flagPath(directory));
-  const link = readLink(directory);
-  const state = `pair mode ${on ? "ON" : "OFF"} for ${directory}`;
+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}`;
 }
@@ -8049,7 +8128,7 @@ function parseNoteResult(text) {
 import { randomBytes as randomBytes3 } from "node:crypto";
 import { readFileSync as readFileSync5, writeFileSync as writeFileSync5, rmSync } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 
 // src/core/render/render.ts
 var HEADER_LEAD = [
@@ -8089,56 +8168,299 @@ function renderInline(input) {
 // src/editors/micro.ts
 var import_yaml = __toESM(require_dist(), 1);
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 
 // src/editors/languages.ts
-import { extname } from "node:path";
-var LANGS = {
+import { openSync, readSync, closeSync } from "node:fs";
+import { basename as basename2, extname } 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 = extname(sourcePath).toLowerCase();
-  return LANGS[ext] ?? null;
+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 line = firstLine(sourcePath);
+  if (line === null || !line.startsWith("#!")) {
+    return null;
+  }
+  return SHEBANGS.find((rule) => rule.pattern.test(line))?.id ?? null;
+}
+function detectLanguage(sourcePath) {
+  const name = basename2(sourcePath).toLowerCase();
+  const ext = extname(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",
+  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 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 VIM_FILETYPES[id] ?? id;
 }
 
 // src/editors/syntax-cache.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
-import { dirname as dirname2, join as join3 } from "node:path";
+import { dirname as dirname2, join as join4 } from "node:path";
 import { fileURLToPath } from "node:url";
 function defaultAssetsDir() {
   let dir = dirname2(fileURLToPath(import.meta.url));
   while (true) {
-    const candidate = join3(dir, "assets", "syntax");
+    const candidate = join4(dir, "assets", "syntax");
     if (existsSync3(candidate)) {
       return candidate;
     }
@@ -8153,7 +8475,7 @@ function syntaxSource(lang, assetsDir = defaultAssetsDir()) {
   if (assetsDir === null) {
     return null;
   }
-  const path = join3(assetsDir, `${lang}.yaml`);
+  const path = join4(assetsDir, `${lang}.yaml`);
   if (!existsSync3(path)) {
     return null;
   }
@@ -8190,7 +8512,7 @@ function bandRules() {
   ];
 }
 function writeColorScheme(configDir, theme) {
-  const dir = join4(configDir, "colorschemes");
+  const dir = join5(configDir, "colorschemes");
   mkdirSync2(dir, { recursive: true });
   const text = `include "monokai"
 
@@ -8198,7 +8520,7 @@ color-link pairadd "#d7ffd7,${theme.add}"
 color-link pairdel "#ffd7d7,${theme.del}"
 color-link pairskip "#6a6a6a,${theme.fold}"
 `;
-  writeFileSync2(join4(dir, "pair.micro"), text, "utf-8");
+  writeFileSync2(join5(dir, "pair.micro"), text, "utf-8");
 }
 function syntaxText(lang, source) {
   const parsed = (0, import_yaml.parse)(source);
@@ -8214,7 +8536,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;
   }
@@ -8226,9 +8548,9 @@ function writeSyntax(configDir, sourcePath) {
   if (text === null) {
     return;
   }
-  const dir = join4(configDir, "syntax");
+  const dir = join5(configDir, "syntax");
   mkdirSync2(dir, { recursive: true });
-  writeFileSync2(join4(dir, `pair-${lang}.yaml`), text, "utf-8");
+  writeFileSync2(join5(dir, `pair-${lang}.yaml`), text, "utf-8");
 }
 function createMicroEditor(resolvesOnPath = defaultResolvesOnPath) {
   return {
@@ -8241,7 +8563,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";
       }
@@ -8250,12 +8572,12 @@ function createMicroEditor(resolvesOnPath = defaultResolvesOnPath) {
     prepare(context) {
       mkdirSync2(context.configDir, { recursive: true });
       writeFileSync2(
-        join4(context.configDir, "bindings.json"),
+        join5(context.configDir, "bindings.json"),
         JSON.stringify(MICRO_BINDINGS, null, 2),
         "utf-8"
       );
       writeFileSync2(
-        join4(context.configDir, "settings.json"),
+        join5(context.configDir, "settings.json"),
         JSON.stringify(MICRO_SETTINGS, null, 2),
         "utf-8"
       );
@@ -8279,16 +8601,6 @@ function isHexColor(value) {
 }
 
 // src/editors/vim.ts
-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}`);
@@ -8343,7 +8655,7 @@ function vimEditor(name, resolvesOnPath = defaultResolvesOnPath) {
 
 // src/editors/nano.ts
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 function safeThemeColor2(value) {
   if (!isHexColor(value)) {
     throw new Error(`invalid theme colour for nano rcfile: ${value}`);
@@ -8355,7 +8667,7 @@ function writeNanorc(configDir, theme) {
 color ,${safeThemeColor2(theme.del)} "^\u258C\u258C-"
 color ,${safeThemeColor2(theme.fold)} "^\u22EF"
 `;
-  const path = join5(configDir, "pair.nanorc");
+  const path = join6(configDir, "pair.nanorc");
   writeFileSync3(path, text, "utf-8");
   return path;
 }
@@ -8385,12 +8697,12 @@ function createNanoEditor(resolvesOnPath = defaultResolvesOnPath) {
 
 // src/editors/pair.ts
 import { existsSync as existsSync5 } from "node:fs";
-import { dirname as dirname4, extname as extname3, join as join7 } from "node:path";
+import { dirname as dirname4, extname as extname3, join as join8 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/core/config/config.ts
 import { homedir as homedir2 } from "node:os";
-import { join as join6, dirname as dirname3 } from "node:path";
+import { join as join7, dirname as dirname3 } from "node:path";
 import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "node:fs";
 var EDITOR_NAMES = ["auto", "pair", "micro", "nvim", "vim", "nano"];
 var MULTIPLEXER_NAMES = ["auto", "zellij", "tmux", "none"];
@@ -8417,8 +8729,8 @@ var DEFAULT_CONFIG = {
   syntax: true
 };
 function configPath(homeDir) {
-  const base = process.env["XDG_CONFIG_HOME"] || join6(homeDir ?? homedir2(), ".config");
-  return join6(base, "pair-mode", "config.json");
+  const base = process.env["XDG_CONFIG_HOME"] || join7(homeDir ?? homedir2(), ".config");
+  return join7(base, "pair-mode", "config.json");
 }
 function isEditorName(value) {
   return typeof value === "string" && EDITOR_NAMES.includes(value);
@@ -8725,7 +9037,7 @@ function paintLayout(layout) {
 // src/editors/pair.ts
 var defaultResolveTuiEntry = () => {
   const here = dirname4(fileURLToPath2(import.meta.url));
-  return join7(here, "pair-tui.js");
+  return join8(here, "pair-tui.js");
 };
 var defaultCheckBundleExists = existsSync5;
 function createPairEditor(resolveTuiEntry = defaultResolveTuiEntry, checkBundleExists = defaultCheckBundleExists) {
@@ -8891,9 +9203,9 @@ function createTmuxMultiplexer(spawn = defaultSpawn, resolvesOnPath = defaultRes
 }
 
 // src/multiplexers/tty.ts
-import { openSync, closeSync } from "node:fs";
+import { openSync as openSync2, closeSync as closeSync2 } from "node:fs";
 import { spawnSync as spawnSync3 } from "node:child_process";
-var defaultOpen = () => openSync("/dev/tty", "r+");
+var defaultOpen = () => openSync2("/dev/tty", "r+");
 var defaultRunner = (command, args, fd) => {
   const result = spawnSync3(command, args, { stdio: [fd, fd, fd] });
   const detail = result.status === 0 ? "" : String(result.error?.message ?? result.stderr ?? "");
@@ -8901,7 +9213,7 @@ var defaultRunner = (command, args, fd) => {
 };
 function closeQuietly(fd) {
   try {
-    closeSync(fd);
+    closeSync2(fd);
   } catch {
   }
 }
@@ -8965,7 +9277,7 @@ function splitCommand(value) {
 }
 function tempFile(prefix, suffix, content) {
   const name = `${prefix}${randomBytes3(NAME_BYTES2).toString("hex")}${suffix}`;
-  const path = join8(tmpdir2(), name);
+  const path = join9(tmpdir2(), name);
   writeFileSync5(path, content, "utf-8");
   return path;
 }
@@ -8976,7 +9288,7 @@ function removeTreeQuietly(path) {
   }
 }
 function reviewConfigDir() {
-  return join8(stateDir(), "editor", randomBytes3(NAME_BYTES2).toString("hex"));
+  return join9(stateDir(), "editor", randomBytes3(NAME_BYTES2).toString("hex"));
 }
 function withEnvPrefix(argv, env) {
   const assignments = Object.entries(env).map(([key, value]) => `${key}=${value}`);
@@ -9056,6 +9368,7 @@ function createPaneTransport(deps = {}) {
 
 // src/transports/session/client.ts
 import { createConnection } from "node:net";
+import { existsSync as existsSync6 } from "node:fs";
 
 // src/transports/session/wire.ts
 var CLIENT_KINDS = ["tui", "web"];
@@ -9070,11 +9383,11 @@ function createLineReader() {
     return parts.filter((line) => line.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)) {
@@ -9082,16 +9395,16 @@ function isQuestion(value) {
   }
   const line = value["line"];
   const lineOk = line === null || typeof line === "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 {
@@ -9107,7 +9420,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 {
@@ -9120,13 +9433,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(line) {
   let parsed;
@@ -9154,11 +9485,18 @@ function decodeLine(line) {
   if (type === "cancel") {
     return toCancel(parsed);
   }
+  if (type === "status") {
+    return { type: "status" };
+  }
+  if (type === "state") {
+    return toState(parsed);
+  }
   return null;
 }
 
 // src/transports/session/client.ts
 var MS_PER_SECOND = 1e3;
+var NO_WATCHER = "no pair-mode watcher attached";
 function failOpen(detail) {
   return { reviewed: false, detail };
 }
@@ -9191,7 +9529,7 @@ function requestReview(request, options) {
     let lastError = "";
     socket.on("error", (error) => {
       if (isConnectionRefused(error)) {
-        settle(failOpen("no pair-mode watcher attached"));
+        settle(failOpen(NO_WATCHER));
         return;
       }
       lastError = error instanceof Error ? error.message : String(error);
@@ -9221,15 +9559,27 @@ function requestReview(request, options) {
     });
   });
 }
-function reviewInSession(request, config, socketPath) {
-  const path = socketPath ?? findSessionSocket(request.filePath);
-  if (path === null) {
-    return Promise.resolve(failOpen("no pair-mode watcher attached"));
+async function reviewInSession(request, config, socketPath) {
+  const timeoutMs = config.session.timeout * MS_PER_SECOND;
+  if (socketPath !== void 0) {
+    return await requestReview(request, { socketPath, timeoutMs });
   }
-  return requestReview(request, {
-    socketPath: path,
-    timeoutMs: config.session.timeout * MS_PER_SECOND
-  });
+  const key = keyFor(request.sessionId);
+  const sessionPath = key === void 0 ? null : sessionKeySocketPath(key);
+  if (sessionPath !== null && existsSync6(sessionPath)) {
+    const outcome = await requestReview(request, { socketPath: sessionPath, timeoutMs });
+    if (outcome.reviewed) {
+      return outcome;
+    }
+    if (outcome.detail !== NO_WATCHER) {
+      return outcome;
+    }
+  }
+  const directoryPath = findSessionSocket(request.filePath);
+  if (directoryPath === null) {
+    return failOpen(NO_WATCHER);
+  }
+  return await requestReview(request, { socketPath: directoryPath, timeoutMs });
 }
 function createSessionTransport(socketPath) {
   return {
@@ -9250,7 +9600,8 @@ async function runPair(request, config, deps = {}) {
   if (request.before === request.after) {
     return { decision: "allow", reviewed: false };
   }
-  if (!isEnabled(request.filePath)) {
+  const key = keyFor(request.sessionId);
+  if (!isEnabled(request.filePath, key)) {
     return { decision: "allow", reviewed: false };
   }
   const transport = deps.transport ?? resolveTransport(config, deps);
@@ -9308,10 +9659,12 @@ async function handleToolCall(event, runPair2 = runPair) {
     if (call === null) {
       return { block: false };
     }
-    if (!isEnabled(call.filePath)) {
+    const sessionId = event.sessionId === "" ? void 0 : event.sessionId;
+    const key = keyFor(sessionId);
+    if (!isEnabled(call.filePath, key)) {
       return { block: false };
     }
-    const request = simulate(call.tool, call.input, readFileOrEmpty);
+    const request = simulate(call.tool, call.input, readFileOrEmpty, sessionId);
     if (request === null) {
       return { block: false };
     }