seshmux 0.1.4 → 0.1.6

package/.next/standalone/seshmux-server.js

@@ -372,7 +372,9 @@ var init_needs_input = __esm({
 var workspaces_exports = {};
 __export(workspaces_exports, {
   create: () => create,
+  defaultBranch: () => defaultBranch,
   dirtyCount: () => dirtyCount,
+  git: () => git,
   list: () => list,
   listAll: () => listAll,
   reconcile: () => reconcile,
@@ -479,13 +481,24 @@ async function isGitRepo(repoPath) {
   }
 }
 async function defaultBranch(repoPath) {
+  const localExists = async (name) => {
+    try {
+      await git(repoPath, ["show-ref", "--verify", "--quiet", `refs/heads/${name}`]);
+      return true;
+    } catch {
+      return false;
+    }
+  };
   try {
     const out2 = await git(repoPath, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]);
     const ref = out2.trim().replace(/^origin\//, "");
-    if (ref) return ref;
+    if (ref) return await localExists(ref) ? ref : `origin/${ref}`;
   } catch {
   }
-  const out = await git(repoPath, ["rev-parse", "--abbrev-ref", "HEAD"]);
+  for (const name of ["main", "master"]) {
+    if (await localExists(name)) return name;
+  }
+  const out = await git(repoPath, ["rev-parse", "--abbrev-ref", "HEAD"]).catch(() => "");
   return out.trim() || "main";
 }
 function create(repoPath) {
@@ -753,10 +766,10 @@ function encodeProjectId(cwd) {
   return cwd.replace(/[^a-zA-Z0-9]/g, "-");
 }
 function decodeProjectDir(dir) {
-  const path9 = dir.replace(/-/g, "/");
-  const segments = path9.split("/").filter(Boolean);
+  const path10 = dir.replace(/-/g, "/");
+  const segments = path10.split("/").filter(Boolean);
   const name = segments[segments.length - 1] ?? dir;
-  return { path: path9, name };
+  return { path: path10, name };
 }
 function firstUserText(content) {
   if (typeof content === "string") return content;
@@ -908,28 +921,28 @@ async function computeRootScan(root, provider) {
         if (!newestFile || s.st.mtimeMs > newestFile.mtime) newestFile = { path: s.fp, mtime: s.st.mtimeMs };
       }
       if (createdAt === Number.MAX_SAFE_INTEGER) createdAt = updatedAt;
-      let path9 = decoded.path;
+      let path10 = decoded.path;
       let name = decoded.name;
       if (newestFile) {
         const head = await readHead(newestFile.path, Math.floor(newestFile.mtime));
         if (head.cwd) {
-          path9 = head.cwd;
+          path10 = head.cwd;
           name = head.cwd.split("/").filter(Boolean).pop() || decoded.name;
           dirCwds.push({ dirPath, cwd: head.cwd });
         }
       }
       let missing = false;
       try {
-        missing = !(await (0, import_promises2.stat)(path9)).isDirectory();
+        missing = !(await (0, import_promises2.stat)(path10)).isDirectory();
       } catch {
         missing = true;
       }
-      const parentPath = parentOf.get(path9);
+      const parentPath = parentOf.get(path10);
       return {
         id: d.name,
         provider,
         name,
-        path: parentPath ?? path9,
+        path: parentPath ?? path10,
         sessionCount: files.length,
         createdAt,
         updatedAt,
@@ -1128,8 +1141,8 @@ function rgSearch(root, q, limit) {
             continue;
           }
           if (ev.type !== "match") continue;
-          const path9 = ev.data?.path?.text ?? "";
-          const m = path9.match(/([^/]+)\.jsonl$/);
+          const path10 = ev.data?.path?.text ?? "";
+          const m = path10.match(/([^/]+)\.jsonl$/);
           if (!m) continue;
           out.push({ sessionId: m[1], line: ev.data?.lines?.text ?? "" });
           if (out.length >= limit) break;
@@ -1600,9 +1613,9 @@ function nodeFromSources(agentId, s) {
     jsonlPath
   };
 }
-async function readJsonSafe(path9) {
+async function readJsonSafe(path10) {
   try {
-    return JSON.parse(await (0, import_promises6.readFile)(path9, "utf8"));
+    return JSON.parse(await (0, import_promises6.readFile)(path10, "utf8"));
   } catch {
     return null;
   }
@@ -1985,20 +1998,20 @@ function ourVersion(command) {
   const m = command.match(new RegExp(`${MARKER}_V(\\d+)=1`));
   return m ? Number(m[1]) : null;
 }
-async function readJson2(path9) {
+async function readJson2(path10) {
   try {
-    const raw = await (0, import_promises8.readFile)(path9, "utf8");
+    const raw = await (0, import_promises8.readFile)(path10, "utf8");
     return JSON.parse(raw);
   } catch (err) {
     if (err instanceof Error && err.code === "ENOENT") return {};
     throw new Error(`settings.json is not valid JSON: ${err.message}`);
   }
 }
-async function atomicWrite(path9, content) {
-  await (0, import_promises8.mkdir)((0, import_node_path10.dirname)(path9), { recursive: true });
-  const tmp = (0, import_node_path10.join)((0, import_node_path10.dirname)(path9), `.${(0, import_node_crypto3.randomBytes)(6).toString("hex")}.tmp`);
+async function atomicWrite(path10, content) {
+  await (0, import_promises8.mkdir)((0, import_node_path10.dirname)(path10), { recursive: true });
+  const tmp = (0, import_node_path10.join)((0, import_node_path10.dirname)(path10), `.${(0, import_node_crypto3.randomBytes)(6).toString("hex")}.tmp`);
   await (0, import_promises8.writeFile)(tmp, content, "utf8");
-  await (0, import_promises8.rename)(tmp, path9);
+  await (0, import_promises8.rename)(tmp, path10);
 }
 function asHooksObject(cfg) {
   const h = cfg.hooks;
@@ -2687,15 +2700,15 @@ var init_codex2 = __esm({
         const projects = [];
         for (const [id, { cwd, count, createdAt, updatedAt }] of byProject) {
           const { name } = decodeProjectDir(id);
-          const path9 = cwd || id;
+          const path10 = cwd || id;
           const displayName = cwd ? cwd.split("/").filter(Boolean).pop() || name : name;
           let missing = false;
           try {
-            missing = !(await (0, import_promises11.stat)(path9)).isDirectory();
+            missing = !(await (0, import_promises11.stat)(path10)).isDirectory();
           } catch {
             missing = true;
           }
-          projects.push({ id, provider: this.id, name: displayName, path: path9, sessionCount: count, createdAt, updatedAt, missing });
+          projects.push({ id, provider: this.id, name: displayName, path: path10, sessionCount: count, createdAt, updatedAt, missing });
         }
         projects.sort((a, b) => a.name.localeCompare(b.name));
         return projects;
@@ -3032,8 +3045,8 @@ function startWatching(deps) {
       awaitWriteFinish: { stabilityThreshold: 250 },
       ignored: (p, stats) => !!stats?.isFile() && !p.endsWith(".jsonl")
     });
-    w.on("add", (path9) => schedule(path9, provider, config, "add"));
-    w.on("change", (path9) => schedule(path9, provider, config, "change"));
+    w.on("add", (path10) => schedule(path10, provider, config, "add"));
+    w.on("change", (path10) => schedule(path10, provider, config, "change"));
     w.on("error", (err) => console.error(`[watch] ${provider} watcher error:`, err));
     return w;
   });
@@ -3486,8 +3499,8 @@ function defaultRun(cmd, args) {
 async function which(run, bin) {
   try {
     const { stdout } = await run("which", [bin]);
-    const path9 = stdout.trim().split("\n")[0];
-    return path9 || void 0;
+    const path10 = stdout.trim().split("\n")[0];
+    return path10 || void 0;
   } catch {
     return void 0;
   }
@@ -3501,10 +3514,10 @@ async function version(run, bin, flag = "--version") {
   }
 }
 async function detectTool(run, bin, versionFlag = "--version") {
-  const path9 = await which(run, bin);
-  if (!path9) return { found: false };
+  const path10 = await which(run, bin);
+  if (!path10) return { found: false };
   const v = await version(run, bin, versionFlag);
-  return { found: true, path: path9, ...v ? { version: v } : {} };
+  return { found: true, path: path10, ...v ? { version: v } : {} };
 }
 async function detectEnv(deps) {
   const run = deps?.run ?? defaultRun;
@@ -3517,8 +3530,8 @@ async function detectEnv(deps) {
   async function agentEnv(id) {
     const provider = byId.get(id);
     const bin = provider.commands.fresh("")[0];
-    const path9 = await which(run, bin);
-    const v = path9 ? await version(run, bin) : void 0;
+    const path10 = await which(run, bin);
+    const v = path10 ? await version(run, bin) : void 0;
     let store = { found: false, projects: 0, bytes: 0 };
     try {
       const d = await provider.detect();
@@ -3526,7 +3539,7 @@ async function detectEnv(deps) {
       store = { found: projects > 0, projects, bytes: d.store?.bytes ?? 0 };
     } catch {
     }
-    return { found: !!path9, ...path9 ? { path: path9 } : {}, ...v ? { version: v } : {}, store };
+    return { found: !!path10, ...path10 ? { path: path10 } : {}, ...v ? { version: v } : {}, store };
   }
   const [claude, codex, tmux, rg] = await Promise.all([
     agentEnv("claude"),
@@ -4125,24 +4138,24 @@ function bridgeServerConfig() {
   if (process.env.SESHMUX_CONFIG_DIR) cfg.env = { SESHMUX_CONFIG_DIR: process.env.SESHMUX_CONFIG_DIR };
   return cfg;
 }
-async function atomicWrite2(path9, content) {
-  await (0, import_promises12.mkdir)((0, import_node_path16.dirname)(path9), { recursive: true });
-  const tmp = (0, import_node_path16.join)((0, import_node_path16.dirname)(path9), `.${(0, import_node_crypto5.randomBytes)(6).toString("hex")}.tmp`);
+async function atomicWrite2(path10, content) {
+  await (0, import_promises12.mkdir)((0, import_node_path16.dirname)(path10), { recursive: true });
+  const tmp = (0, import_node_path16.join)((0, import_node_path16.dirname)(path10), `.${(0, import_node_crypto5.randomBytes)(6).toString("hex")}.tmp`);
   await (0, import_promises12.writeFile)(tmp, content, "utf8");
-  await (0, import_promises12.rename)(tmp, path9);
+  await (0, import_promises12.rename)(tmp, path10);
 }
-async function readJson3(path9) {
+async function readJson3(path10) {
   try {
-    const raw = await (0, import_promises12.readFile)(path9, "utf8");
+    const raw = await (0, import_promises12.readFile)(path10, "utf8");
     return JSON.parse(raw);
   } catch {
     return {};
   }
 }
-async function registerClaude(path9) {
+async function registerClaude(path10) {
   let cfg = {};
   try {
-    const parsed = JSON.parse(await (0, import_promises12.readFile)(path9, "utf8"));
+    const parsed = JSON.parse(await (0, import_promises12.readFile)(path10, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       throw new Error("top-level JSON is not an object");
     }
@@ -4150,17 +4163,17 @@ async function registerClaude(path9) {
   } catch (e) {
     if (e.code !== "ENOENT") {
       throw new Error(
-        `refusing to modify ${path9}: it exists but is not valid JSON (${e.message}) \u2014 fix or move it, then re-register (nothing was written)`
+        `refusing to modify ${path10}: it exists but is not valid JSON (${e.message}) \u2014 fix or move it, then re-register (nothing was written)`
       );
     }
   }
   const mcpServers = cfg.mcpServers && typeof cfg.mcpServers === "object" ? cfg.mcpServers : {};
   mcpServers["seshmux-bridge"] = bridgeServerConfig();
   cfg.mcpServers = mcpServers;
-  await atomicWrite2(path9, JSON.stringify(cfg, null, 2) + "\n");
+  await atomicWrite2(path10, JSON.stringify(cfg, null, 2) + "\n");
 }
-async function isClaudeRegistered(path9) {
-  const cfg = await readJson3(path9);
+async function isClaudeRegistered(path10) {
+  const cfg = await readJson3(path10);
   const mcpServers = cfg.mcpServers;
   return !!(mcpServers && typeof mcpServers === "object" && "seshmux-bridge" in mcpServers);
 }
@@ -4180,10 +4193,10 @@ function codexTomlBlock() {
 function codexHasBridgeBlock(raw) {
   return /^\[mcp_servers\.seshmux-bridge\]/m.test(raw);
 }
-async function registerCodex(path9) {
+async function registerCodex(path10) {
   let raw = "";
   try {
-    raw = await (0, import_promises12.readFile)(path9, "utf8");
+    raw = await (0, import_promises12.readFile)(path10, "utf8");
   } catch {
     raw = "";
   }
@@ -4192,17 +4205,17 @@ async function registerCodex(path9) {
       /\[mcp_servers\.seshmux-bridge\][\s\S]*?(?=\n\[|$)/,
       codexTomlBlock().trimEnd() + "\n"
     );
-    if (replaced !== raw) await atomicWrite2(path9, replaced);
+    if (replaced !== raw) await atomicWrite2(path10, replaced);
     return;
   }
   const needsSep = raw.length > 0 && !raw.endsWith("\n\n");
   const sep = raw.length === 0 ? "" : needsSep ? raw.endsWith("\n") ? "\n" : "\n\n" : "";
   const next2 = raw + sep + codexTomlBlock();
-  await atomicWrite2(path9, next2);
+  await atomicWrite2(path10, next2);
 }
-async function isCodexRegistered(path9) {
+async function isCodexRegistered(path10) {
   try {
-    const raw = await (0, import_promises12.readFile)(path9, "utf8");
+    const raw = await (0, import_promises12.readFile)(path10, "utf8");
     return codexHasBridgeBlock(raw);
   } catch {
     return false;
@@ -4273,28 +4286,28 @@ __export(bridge_exports, {
 function providerName2(p) {
   return p === "codex" ? "Codex" : "Claude";
 }
-async function isDir(path9) {
+async function isDir(path10) {
   try {
-    return (await (0, import_promises13.stat)(path9)).isDirectory();
+    return (await (0, import_promises13.stat)(path10)).isDirectory();
   } catch {
     return false;
   }
 }
-async function atomicWrite3(path9, content) {
-  const dir = (0, import_node_path17.join)(path9, "..");
+async function atomicWrite3(path10, content) {
+  const dir = (0, import_node_path17.join)(path10, "..");
   await (0, import_promises13.mkdir)(dir, { recursive: true });
   const tmp = (0, import_node_path17.join)(dir, `.${(0, import_node_crypto6.randomBytes)(6).toString("hex")}.tmp`);
   await (0, import_promises13.writeFile)(tmp, content, "utf8");
-  await (0, import_promises13.rename)(tmp, path9);
+  await (0, import_promises13.rename)(tmp, path10);
 }
 async function appendScratchpad(repo, text) {
-  const path9 = (0, import_node_path17.join)(repo, ".seshmux", "handoff.md");
+  const path10 = (0, import_node_path17.join)(repo, ".seshmux", "handoff.md");
   let existing = "";
   try {
-    existing = await (0, import_promises13.readFile)(path9, "utf8");
+    existing = await (0, import_promises13.readFile)(path10, "utf8");
   } catch {
   }
-  await atomicWrite3(path9, existing + (existing && !existing.endsWith("\n") ? "\n" : "") + text + "\n");
+  await atomicWrite3(path10, existing + (existing && !existing.endsWith("\n") ? "\n" : "") + text + "\n");
 }
 async function defaultResolveProvider(projectId, sessionId) {
   const providers = await getProviders();
@@ -4341,7 +4354,7 @@ async function bridgeRoutes(f, deps) {
   const resolveProvider = deps.resolveSessionProvider ?? defaultResolveProvider;
   const brief = deps.composeBrief ? (p, s) => deps.composeBrief(p, s) : (p, s) => composeBrief(p, s);
   const review = deps.composeDiffReview ? (p, s) => deps.composeDiffReview(p, s) : (p, s, repo) => composeDiffReview(p, s, {}, repo);
-  const planoff = deps.runPlanoff ?? ((path9, task) => runPlanoff(path9, task));
+  const planoff = deps.runPlanoff ?? ((path10, task) => runPlanoff(path10, task));
   const registerBridge2 = deps.registerBridge ?? (() => registerBridge());
   const bridgeStatus2 = deps.bridgeStatus ?? (() => bridgeStatus());
   const listLivePtys = deps.listLivePtys ?? defaultListLivePtys;
@@ -4535,8 +4548,8 @@ var projects_exports = {};
 __export(projects_exports, {
   default: () => projectsRoutes
 });
-function isTmpProject(path9) {
-  const p = path9.endsWith("/") ? path9 : path9 + "/";
+function isTmpProject(path10) {
+  const p = path10.endsWith("/") ? path10 : path10 + "/";
   return TMP_ROOTS.some((root) => p.startsWith(root));
 }
 async function projectsRoutes(f) {
@@ -4835,14 +4848,17 @@ var env_exports = {};
 __export(env_exports, {
   default: () => envRoutes
 });
-async function realDaemonVersion() {
+async function realDaemonInfo() {
   let conn = null;
   try {
     conn = await dial();
-    const { version: version2 } = await conn.hello();
-    return version2 || null;
+    const [{ version: version2 }, { ptys }] = await Promise.all([conn.hello(), conn.list()]);
+    return {
+      version: version2 || null,
+      plainPtys: ptys.filter((p) => p.alive !== false && !p.tmuxName).length
+    };
   } catch {
-    return null;
+    return { version: null, plainPtys: 0 };
   } finally {
     conn?.close();
   }
@@ -4857,15 +4873,16 @@ function commandPreview(commands) {
 }
 async function envRoutes(f, deps = {}) {
   const bridgeStatus2 = deps.bridgeStatus ?? (() => bridgeStatus());
-  const daemonVersion = deps.daemonVersion ?? realDaemonVersion;
+  const daemonInfo = deps.daemonInfo ?? realDaemonInfo;
   const serverVersion = deps.serverVersion ?? (() => process.env.SESHMUX_VERSION ?? "");
   f.get("/api/env", async () => {
-    const [env, bridge, providers, dVersion] = await Promise.all([
+    const [env, bridge, providers, dInfo] = await Promise.all([
       detectEnv(),
       bridgeStatus2().catch(() => ({ claude: false, codex: false })),
       getProviders(),
-      daemonVersion().catch(() => null)
+      daemonInfo().catch(() => ({ version: null, plainPtys: 0 }))
     ]);
+    const dVersion = dInfo.version;
     const sVersion = serverVersion();
     const commands = {};
     const teams = {};
@@ -4881,12 +4898,14 @@ async function envRoutes(f, deps = {}) {
       },
       commands,
       teams,
-      // The daemon outlives server updates by design — tell the UI when it's older than us
-      // so the user can be nudged to fully restart. Never auto-restart: that kills live PTYs.
+      // The daemon outlives server updates by design, so it can be older than us. The NEXT update
+      // upgrades it automatically — unless plain (non-tmux) PTYs are live, which a restart would
+      // kill. plainPtys is what lets the UI tell those two states apart.
       daemon: {
         version: dVersion,
         serverVersion: sVersion || null,
-        stale: isDaemonStale(dVersion, sVersion)
+        stale: isDaemonStale(dVersion, sVersion),
+        plainPtys: dInfo.plainPtys
       }
     };
   });
@@ -5250,10 +5269,10 @@ var workspaces_exports2 = {};
 __export(workspaces_exports2, {
   default: () => workspaceRoutes
 });
-async function isDir2(path9) {
+async function isDir2(path10) {
   try {
-    const { stat: stat10 } = await import("node:fs/promises");
-    return (await stat10(path9)).isDirectory();
+    const { stat: stat11 } = await import("node:fs/promises");
+    return (await stat11(path10)).isDirectory();
   } catch {
     return false;
   }
@@ -5367,6 +5386,271 @@ var init_workspaces2 = __esm({
   }
 });
 
+// server/lib/git-stats.ts
+function parseNumstat(out) {
+  if (out.includes("\0")) return parseNumstatZ(out);
+  const rows = [];
+  for (const line of out.split("\n")) {
+    if (!line.trim()) continue;
+    const [a, r, ...rest] = line.split("	");
+    if (rest.length === 0) continue;
+    rows.push({ path: rest.join("	"), added: num(a), removed: num(r) });
+  }
+  return rows;
+}
+function parseNumstatZ(out) {
+  const tokens = out.split("\0");
+  const rows = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (!t) continue;
+    const tab1 = t.indexOf("	");
+    const tab2 = t.indexOf("	", tab1 + 1);
+    if (tab1 === -1 || tab2 === -1) continue;
+    const added = num(t.slice(0, tab1));
+    const removed = num(t.slice(tab1 + 1, tab2));
+    const rest = t.slice(tab2 + 1);
+    if (rest === "") {
+      const oldPath = tokens[++i];
+      const newPath = tokens[++i];
+      if (oldPath && newPath) rows.push({ path: newPath, added, removed, oldPath });
+    } else {
+      rows.push({ path: rest, added, removed });
+    }
+  }
+  return rows;
+}
+async function resolveMergeBase(dir, baseRef) {
+  if (!baseRef) return "HEAD";
+  try {
+    return (await git(dir, ["merge-base", baseRef, "HEAD"])).trim() || "HEAD";
+  } catch {
+    return "HEAD";
+  }
+}
+async function untrackedLines(abs) {
+  try {
+    const st = await (0, import_promises16.stat)(abs);
+    const hit = lineCache.get(abs);
+    if (hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size) return hit;
+    let lines = 0;
+    let read = 0;
+    let lastByte = 10;
+    let binary = false;
+    if (st.size > 0) {
+      const fh = await (0, import_promises16.open)(abs, "r");
+      try {
+        const buf = Buffer.alloc(64 * 1024);
+        const limit = Math.min(st.size, LINE_COUNT_CAP);
+        while (read < limit) {
+          const { bytesRead } = await fh.read(buf, 0, buf.length, read);
+          if (bytesRead <= 0) break;
+          if (read === 0 && buf.subarray(0, Math.min(bytesRead, 8192)).includes(0)) {
+            binary = true;
+            break;
+          }
+          for (let i = 0; i < bytesRead; i++) if (buf[i] === 10) lines++;
+          lastByte = buf[bytesRead - 1];
+          read += bytesRead;
+        }
+      } finally {
+        await fh.close();
+      }
+    }
+    const result = {
+      mtimeMs: st.mtimeMs,
+      size: st.size,
+      lines: binary || st.size === 0 ? 0 : lines + (lastByte !== 10 && read >= st.size ? 1 : 0),
+      approx: !binary && st.size > LINE_COUNT_CAP
+    };
+    if (lineCache.size > 1e4) lineCache.clear();
+    lineCache.set(abs, result);
+    return result;
+  } catch {
+    return { lines: 0, approx: false };
+  }
+}
+async function fileDiff(dir, baseRef, relPath) {
+  const empty = { diff: "", truncated: false };
+  try {
+    const abs = import_node_path20.default.resolve(dir, relPath);
+    if (!abs.startsWith(import_node_path20.default.resolve(dir) + import_node_path20.default.sep)) return empty;
+    const base = await resolveMergeBase(dir, baseRef);
+    const tracked = await git(dir, ["diff", "--no-renames", base, "--", relPath]);
+    if (tracked) return truncateDiff(tracked);
+    const untracked = splitZ(await git(dir, ["ls-files", "-o", "--exclude-standard", "-z", "--", relPath]));
+    if (untracked.length === 0) return empty;
+    try {
+      return truncateDiff(await git(dir, ["diff", "--no-index", "--", "/dev/null", abs]));
+    } catch (e) {
+      const out = e.stdout;
+      return typeof out === "string" ? truncateDiff(out) : empty;
+    }
+  } catch {
+    return empty;
+  }
+}
+function truncateDiff(diff) {
+  const lines = diff.split("\n");
+  if (lines.length <= MAX_DIFF_LINES) return { diff, truncated: false };
+  return { diff: lines.slice(0, MAX_DIFF_LINES).join("\n"), truncated: true };
+}
+function changes(dir, baseRef, wantTree) {
+  const key = `${dir}\0${baseRef ?? ""}\0${wantTree}`;
+  const hit = changesMemo.get(key);
+  if (hit && Date.now() - hit.at < CHANGES_TTL_MS) return hit.promise;
+  const promise = computeChanges(dir, baseRef, wantTree);
+  if (changesMemo.size > 200) changesMemo.clear();
+  changesMemo.set(key, { at: Date.now(), promise });
+  void promise.then((res) => {
+    if (res.degraded && changesMemo.get(key)?.promise === promise) changesMemo.delete(key);
+  });
+  return promise;
+}
+async function computeChanges(dir, baseRef, wantTree) {
+  try {
+    const base = await resolveMergeBase(dir, baseRef);
+    const [numstatOut, nameStatusOut, untrackedOut] = await Promise.all([
+      git(dir, ["diff", "--numstat", "-z", base]),
+      git(dir, ["diff", "--name-status", "-z", base]),
+      git(dir, ["ls-files", "-o", "--exclude-standard", "-z"])
+    ]);
+    const statusTokens = splitZ(nameStatusOut);
+    const statusByPath = /* @__PURE__ */ new Map();
+    for (let i = 0; i < statusTokens.length; ) {
+      const code = statusTokens[i++]?.charAt(0);
+      if (!code) continue;
+      if (code === "R" || code === "C") {
+        i++;
+        const newPath = statusTokens[i++];
+        if (newPath) statusByPath.set(newPath, code);
+      } else {
+        const p = statusTokens[i++];
+        if (p) statusByPath.set(p, code);
+      }
+    }
+    const files = [];
+    for (const f of parseNumstat(numstatOut)) {
+      if (f.oldPath) {
+        const code = statusByPath.get(f.path) ?? "R";
+        files.push({ path: f.path, added: f.added, removed: f.removed, status: code });
+        if (code !== "C") files.push({ path: f.oldPath, added: 0, removed: 0, status: "D" });
+      } else {
+        files.push({ path: f.path, added: f.added, removed: f.removed, status: statusByPath.get(f.path) ?? "M" });
+      }
+    }
+    const untracked = splitZ(untrackedOut);
+    for (let i = 0; i < untracked.length; i += 16) {
+      const batch = await Promise.all(
+        untracked.slice(i, i + 16).map(async (rel) => {
+          const { lines, approx } = await untrackedLines(import_node_path20.default.join(dir, rel));
+          return { path: rel, added: lines, removed: 0, status: "A", ...approx ? { approx: true } : {} };
+        })
+      );
+      files.push(...batch);
+    }
+    const result = {
+      added: files.reduce((n, f) => n + f.added, 0),
+      removed: files.reduce((n, f) => n + f.removed, 0),
+      files
+    };
+    if (wantTree) {
+      const tracked = splitZ(await git(dir, ["ls-files", "-z"]));
+      result.tree = [.../* @__PURE__ */ new Set([...tracked, ...untracked])].sort();
+    }
+    return result;
+  } catch {
+    return { added: 0, removed: 0, files: [], degraded: true };
+  }
+}
+var import_promises16, import_node_path20, num, LINE_COUNT_CAP, lineCache, splitZ, MAX_DIFF_LINES, changesMemo, CHANGES_TTL_MS;
+var init_git_stats = __esm({
+  "server/lib/git-stats.ts"() {
+    "use strict";
+    import_promises16 = require("node:fs/promises");
+    import_node_path20 = __toESM(require("node:path"));
+    init_workspaces();
+    num = (s) => s === "-" ? 0 : Number(s) || 0;
+    LINE_COUNT_CAP = 10 * 1024 * 1024;
+    lineCache = /* @__PURE__ */ new Map();
+    splitZ = (out) => out.split("\0").filter(Boolean);
+    MAX_DIFF_LINES = 5e3;
+    changesMemo = /* @__PURE__ */ new Map();
+    CHANGES_TTL_MS = 5e3;
+  }
+});
+
+// server/routes/git.ts
+var git_exports = {};
+__export(git_exports, {
+  default: () => gitRoutes
+});
+async function gitRoutes(f, deps = {}) {
+  const resolveRepo = deps.resolveRepo ?? defaultResolveRepo;
+  const listWorkspaces = deps.listWorkspaces ?? list;
+  const repoMemo = /* @__PURE__ */ new Map();
+  const REPO_TTL_MS = 6e4;
+  async function repoFor(projectId) {
+    const hit = repoMemo.get(projectId);
+    if (hit && Date.now() - hit.at < REPO_TTL_MS) return hit.path;
+    const path10 = await resolveRepo(projectId);
+    if (repoMemo.size > 500) repoMemo.clear();
+    if (path10) repoMemo.set(projectId, { at: Date.now(), path: path10 });
+    return path10;
+  }
+  async function resolveTarget(projectId, branch) {
+    const repo = await repoFor(projectId);
+    if (!repo) return null;
+    let dir = repo;
+    if (branch?.startsWith("agent/")) {
+      const rec = (await listWorkspaces(repo).catch(() => [])).find((r) => r.branch === branch);
+      if (rec) dir = rec.dir;
+    }
+    const base = await defaultBranch(repo).catch(() => null);
+    return { dir, base };
+  }
+  f.get(
+    "/api/git/changes",
+    async (req, reply) => {
+      const { project, branch, tree } = req.query;
+      if (!project) {
+        reply.code(400);
+        return { error: "project is required" };
+      }
+      const target = await resolveTarget(project, branch);
+      if (!target) {
+        reply.code(404);
+        return { error: "project not found" };
+      }
+      return changes(target.dir, target.base, tree === "1");
+    }
+  );
+  f.get(
+    "/api/git/changes/file",
+    async (req, reply) => {
+      const { project, branch, path: relPath } = req.query;
+      if (!project || !relPath) {
+        reply.code(400);
+        return { error: "project and path are required" };
+      }
+      const target = await resolveTarget(project, branch);
+      if (!target) {
+        reply.code(404);
+        return { error: "project not found" };
+      }
+      return fileDiff(target.dir, target.base, relPath);
+    }
+  );
+}
+var init_git = __esm({
+  "server/routes/git.ts"() {
+    "use strict";
+    init_git_stats();
+    init_workspaces();
+    init_bridge();
+  }
+});
+
 // server/lib/teams.ts
 function composeTeamPrompt(t, task) {
   const roster = t.members.map((m) => `  - ${oneLine(m.name)} \u2014 ${oneLine(m.role)}${m.model ? ` (${m.model})` : ""}`).join("\n");
@@ -5380,16 +5664,16 @@ function composeTeamPrompt(t, task) {
 }
 async function readAll2() {
   try {
-    return JSON.parse(await (0, import_promises16.readFile)(file(), "utf8"));
+    return JSON.parse(await (0, import_promises17.readFile)(file(), "utf8"));
   } catch {
     return [];
   }
 }
 async function writeAll2(list2) {
-  await (0, import_promises16.mkdir)(configDir(), { recursive: true });
-  const tmp = import_node_path20.default.join(configDir(), `.${(0, import_node_crypto8.randomBytes)(6).toString("hex")}.tmp`);
-  await (0, import_promises16.writeFile)(tmp, JSON.stringify(list2, null, 2), "utf8");
-  await (0, import_promises16.rename)(tmp, file());
+  await (0, import_promises17.mkdir)(configDir(), { recursive: true });
+  const tmp = import_node_path21.default.join(configDir(), `.${(0, import_node_crypto8.randomBytes)(6).toString("hex")}.tmp`);
+  await (0, import_promises17.writeFile)(tmp, JSON.stringify(list2, null, 2), "utf8");
+  await (0, import_promises17.rename)(tmp, file());
 }
 function update2(mutate) {
   const run = writeChain2.then(async () => {
@@ -5407,15 +5691,15 @@ async function saveTemplate(t) {
 async function deleteTemplate(name) {
   await update2((list2) => list2.filter((x) => x.name !== name));
 }
-var import_promises16, import_node_crypto8, import_node_path20, file, oneLine, writeChain2, listTemplates;
+var import_promises17, import_node_crypto8, import_node_path21, file, oneLine, writeChain2, listTemplates;
 var init_teams = __esm({
   "server/lib/teams.ts"() {
     "use strict";
-    import_promises16 = require("node:fs/promises");
+    import_promises17 = require("node:fs/promises");
     import_node_crypto8 = require("node:crypto");
-    import_node_path20 = __toESM(require("node:path"));
+    import_node_path21 = __toESM(require("node:path"));
     init_daemon_client();
-    file = () => import_node_path20.default.join(configDir(), "teams.json");
+    file = () => import_node_path21.default.join(configDir(), "teams.json");
     oneLine = (s) => s.replace(/[\r\n\t]+/g, " ").replace(/\s{2,}/g, " ").trim();
     writeChain2 = Promise.resolve();
     listTemplates = readAll2;
@@ -5427,10 +5711,10 @@ var teams_exports = {};
 __export(teams_exports, {
   default: () => teamRoutes
 });
-async function isDir3(path9) {
+async function isDir3(path10) {
   try {
-    const { stat: stat10 } = await import("node:fs/promises");
-    return (await stat10(path9)).isDirectory();
+    const { stat: stat11 } = await import("node:fs/promises");
+    return (await stat11(path10)).isDirectory();
   } catch {
     return false;
   }
@@ -5587,22 +5871,22 @@ var scratchpad_exports = {};
 __export(scratchpad_exports, {
   default: () => scratchpadRoutes
 });
-async function isDir4(path9) {
+async function isDir4(path10) {
   try {
-    return (await (0, import_promises17.stat)(path9)).isDirectory();
+    return (await (0, import_promises18.stat)(path10)).isDirectory();
   } catch {
     return false;
   }
 }
 function scratchpadPath(repo) {
-  return (0, import_node_path21.join)(repo, ".seshmux", "handoff.md");
+  return (0, import_node_path22.join)(repo, ".seshmux", "handoff.md");
 }
-async function atomicWrite4(path9, content) {
-  const dir = (0, import_node_path21.join)(path9, "..");
-  await (0, import_promises17.mkdir)(dir, { recursive: true });
-  const tmp = (0, import_node_path21.join)(dir, `.${(0, import_node_crypto9.randomBytes)(6).toString("hex")}.tmp`);
-  await (0, import_promises17.writeFile)(tmp, content, "utf8");
-  await (0, import_promises17.rename)(tmp, path9);
+async function atomicWrite4(path10, content) {
+  const dir = (0, import_node_path22.join)(path10, "..");
+  await (0, import_promises18.mkdir)(dir, { recursive: true });
+  const tmp = (0, import_node_path22.join)(dir, `.${(0, import_node_crypto9.randomBytes)(6).toString("hex")}.tmp`);
+  await (0, import_promises18.writeFile)(tmp, content, "utf8");
+  await (0, import_promises18.rename)(tmp, path10);
 }
 async function scratchpadRoutes(f, deps = {}) {
   const defaultResolveRepo2 = async (id) => {
@@ -5628,7 +5912,7 @@ async function scratchpadRoutes(f, deps = {}) {
     }
     deps.onOpen?.(req.params.projectId, repo);
     try {
-      const content = await (0, import_promises17.readFile)(scratchpadPath(repo), "utf8");
+      const content = await (0, import_promises18.readFile)(scratchpadPath(repo), "utf8");
       return { content };
     } catch {
       return { content: "" };
@@ -5642,25 +5926,25 @@ async function scratchpadRoutes(f, deps = {}) {
         reply.code(404);
         return { error: "project not found" };
       }
-      const path9 = scratchpadPath(repo);
+      const path10 = scratchpadPath(repo);
       let content = typeof req.body?.content === "string" ? req.body.content : "";
       try {
-        await (0, import_promises17.stat)(path9);
+        await (0, import_promises18.stat)(path10);
       } catch {
         if (!content.startsWith("# ")) content = TEMPLATE + content;
       }
-      await atomicWrite4(path9, content);
+      await atomicWrite4(path10, content);
       return { ok: true, content };
     }
   );
 }
-var import_node_crypto9, import_promises17, import_node_path21, TEMPLATE;
+var import_node_crypto9, import_promises18, import_node_path22, TEMPLATE;
 var init_scratchpad = __esm({
   "server/routes/scratchpad.ts"() {
     "use strict";
     import_node_crypto9 = require("node:crypto");
-    import_promises17 = require("node:fs/promises");
-    import_node_path21 = require("node:path");
+    import_promises18 = require("node:fs/promises");
+    import_node_path22 = require("node:path");
     init_scan();
     init_types();
     TEMPLATE = `# Shared scratchpad
@@ -5725,12 +6009,12 @@ __export(notify_exports, {
   default: () => notifyRoutes
 });
 function configPath2() {
-  const dir = process.env.SESHMUX_CONFIG_DIR || import_node_path22.default.join(import_node_os10.default.homedir(), ".config", "seshmux");
-  return import_node_path22.default.join(dir, "config.json");
+  const dir = process.env.SESHMUX_CONFIG_DIR || import_node_path23.default.join(import_node_os10.default.homedir(), ".config", "seshmux");
+  return import_node_path23.default.join(dir, "config.json");
 }
 async function macNotificationsEnabled() {
   try {
-    const raw = await (0, import_promises18.readFile)(configPath2(), "utf8");
+    const raw = await (0, import_promises19.readFile)(configPath2(), "utf8");
     const cfg = JSON.parse(raw);
     return cfg?.settings?.macNotifications !== false;
   } catch {
@@ -5766,13 +6050,13 @@ async function notifyRoutes(f) {
     return { ok: true, delivered: true };
   });
 }
-var import_node_child_process8, import_promises18, import_node_path22, import_node_os10;
+var import_node_child_process8, import_promises19, import_node_path23, import_node_os10;
 var init_notify = __esm({
   "server/routes/notify.ts"() {
     "use strict";
     import_node_child_process8 = require("node:child_process");
-    import_promises18 = require("node:fs/promises");
-    import_node_path22 = __toESM(require("node:path"));
+    import_promises19 = require("node:fs/promises");
+    import_node_path23 = __toESM(require("node:path"));
     import_node_os10 = __toESM(require("node:os"));
   }
 });
@@ -5986,6 +6270,7 @@ async function startServer({ port: port2 = 4700, dev = false } = {}) {
   await (await Promise.resolve().then(() => (init_workspaces(), workspaces_exports))).reconcile().catch(() => {
   });
   await f.register((await Promise.resolve().then(() => (init_workspaces2(), workspaces_exports2))).default);
+  await f.register((await Promise.resolve().then(() => (init_git(), git_exports))).default);
   await f.register((await Promise.resolve().then(() => (init_teams2(), teams_exports))).default, {
     onTeamWatch: (teamName, leadSessionId, configPath3) => hub.watchTeam(teamName, leadSessionId, configPath3)
   });