webmux 0.7.2 → 0.7.3

package/backend/dist/server.js

@@ -6905,7 +6905,7 @@ var require_public_api = __commonJS((exports) => {
 });
 
 // backend/src/server.ts
-import { join as join2, resolve } from "path";
+import { join as join5, resolve as resolve5 } from "path";
 import { networkInterfaces } from "os";
 
 // backend/src/lib/log.ts
@@ -6929,91 +6929,461 @@ var log = {
   }
 };
 
-// backend/src/workmux.ts
-var {$ } = globalThis.Bun;
-import { mkdir as mkdir2 } from "fs/promises";
-
-// backend/src/env.ts
-async function readEnvLocal(wtDir) {
+// backend/src/adapters/terminal.ts
+var textDecoder = new TextDecoder;
+var textEncoder = new TextEncoder;
+var DASH_PORT = Bun.env.BACKEND_PORT || "5111";
+var SESSION_PREFIX = `wm-dash-${DASH_PORT}-`;
+var MAX_SCROLLBACK_BYTES = 1 * 1024 * 1024;
+var TMUX_TIMEOUT_MS = 5000;
+var sessions = new Map;
+var sessionCounter = 0;
+function groupedName() {
+  return `${SESSION_PREFIX}${++sessionCounter}`;
+}
+function buildAttachCmd(opts) {
+  const paneTarget = `${opts.gName}:${opts.windowName}.${opts.initialPane ?? 0}`;
+  return [
+    `tmux new-session -d -s "${opts.gName}" -t "${opts.ownerSessionName}"`,
+    `tmux set-option -t "${opts.ownerSessionName}" window-size latest`,
+    `tmux set-option -t "${opts.gName}" mouse on`,
+    `tmux set-option -t "${opts.gName}" set-clipboard on`,
+    `tmux select-window -t "${opts.gName}:${opts.windowName}"`,
+    `if [ "$(tmux display-message -t '${opts.gName}:${opts.windowName}' -p '#{window_zoomed_flag}')" = "1" ]; then tmux resize-pane -Z -t '${opts.gName}:${opts.windowName}'; fi`,
+    `tmux select-pane -t "${paneTarget}"`,
+    ...opts.initialPane !== undefined ? [`tmux resize-pane -Z -t "${paneTarget}"`] : [],
+    `stty rows ${opts.rows} cols ${opts.cols}`,
+    `exec tmux attach-session -t "${opts.gName}"`
+  ].join(" && ");
+}
+async function tmuxExec(args, opts = {}) {
+  const proc = Bun.spawn(args, {
+    stdin: opts.stdin ?? "ignore",
+    stdout: "ignore",
+    stderr: "pipe"
+  });
+  const timeout = Bun.sleep(TMUX_TIMEOUT_MS).then(() => {
+    proc.kill();
+    return "timeout";
+  });
+  const result = await Promise.race([proc.exited, timeout]);
+  if (result === "timeout") {
+    return { exitCode: -1, stderr: `timed out after ${TMUX_TIMEOUT_MS}ms` };
+  }
+  const stderr = (await new Response(proc.stderr).text()).trim();
+  return { exitCode: result, stderr };
+}
+function cleanupStaleSessions() {
   try {
-    const text = (await Bun.file(`${wtDir}/.env.local`).text()).trim();
-    const env = {};
-    for (const line of text.split(`
-`)) {
-      const match = line.match(/^(\w+)=(.*)$/);
-      if (match) {
-        let val = match[2];
-        if (val.length >= 2 && val.startsWith("'") && val.endsWith("'")) {
-          val = val.slice(1, -1).replaceAll("'\\''", "'");
+    const result = Bun.spawnSync(["tmux", "list-sessions", "-F", "#{session_name}"], { stdout: "pipe", stderr: "pipe" });
+    if (result.exitCode !== 0)
+      return;
+    const lines = textDecoder.decode(result.stdout).trim().split(`
+`);
+    for (const name of lines) {
+      if (name.startsWith(SESSION_PREFIX)) {
+        Bun.spawnSync(["tmux", "kill-session", "-t", name]);
+      }
+    }
+  } catch {}
+}
+function killTmuxSession(name) {
+  const result = Bun.spawnSync(["tmux", "kill-session", "-t", name], { stderr: "pipe" });
+  if (result.exitCode !== 0) {
+    const stderr = textDecoder.decode(result.stderr).trim();
+    if (!stderr.includes("can't find session")) {
+      log.warn(`[term] killTmuxSession(${name}) exit=${result.exitCode} ${stderr}`);
+    }
+  }
+}
+async function attach(worktreeId, target, cols, rows, initialPane) {
+  log.debug(`[term] attach(${worktreeId}) cols=${cols} rows=${rows} existing=${sessions.has(worktreeId)}`);
+  if (sessions.has(worktreeId)) {
+    await detach(worktreeId);
+  }
+  const gName = groupedName();
+  log.debug(`[term] attach(${worktreeId}) ownerSession=${target.ownerSessionName} gName=${gName} window=${target.windowName}`);
+  killTmuxSession(gName);
+  const cmd = buildAttachCmd({
+    gName,
+    ownerSessionName: target.ownerSessionName,
+    windowName: target.windowName,
+    cols,
+    rows,
+    initialPane
+  });
+  const scriptArgs = process.platform === "darwin" ? ["python3", "-c", "import pty,sys;pty.spawn(sys.argv[1:])", "bash", "-c", cmd] : ["script", "-q", "-c", cmd, "/dev/null"];
+  const proc = Bun.spawn(scriptArgs, {
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...Bun.env, TERM: "xterm-256color" }
+  });
+  const session = {
+    proc,
+    groupedSessionName: gName,
+    windowName: target.windowName,
+    scrollback: [],
+    scrollbackBytes: 0,
+    onData: null,
+    onExit: null,
+    cancelled: false
+  };
+  sessions.set(worktreeId, session);
+  log.debug(`[term] attach(${worktreeId}) spawned pid=${proc.pid}`);
+  (async () => {
+    const reader = proc.stdout.getReader();
+    try {
+      while (true) {
+        if (session.cancelled)
+          break;
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        const str = textDecoder.decode(value);
+        session.scrollbackBytes += textEncoder.encode(str).byteLength;
+        session.scrollback.push(str);
+        while (session.scrollbackBytes > MAX_SCROLLBACK_BYTES && session.scrollback.length > 0) {
+          const removed = session.scrollback.shift();
+          session.scrollbackBytes -= textEncoder.encode(removed).byteLength;
         }
-        env[match[1]] = val;
+        session.onData?.(str);
+      }
+    } catch (err) {
+      if (!session.cancelled) {
+        log.error(`[term] stdout reader error(${worktreeId})`, err);
       }
     }
-    return env;
-  } catch {
-    return {};
+  })();
+  (async () => {
+    const reader = proc.stderr.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        log.debug(`[term] stderr(${worktreeId}): ${textDecoder.decode(value).trimEnd()}`);
+      }
+    } catch {}
+  })();
+  proc.exited.then((exitCode) => {
+    log.debug(`[term] proc exited(${worktreeId}) pid=${proc.pid} code=${exitCode}`);
+    if (sessions.get(worktreeId) === session) {
+      session.onExit?.(exitCode);
+      sessions.delete(worktreeId);
+    } else {
+      log.debug(`[term] proc exited(${worktreeId}) stale session, skipping cleanup`);
+    }
+    killTmuxSession(gName);
+  });
+}
+async function detach(worktreeId) {
+  const session = sessions.get(worktreeId);
+  if (!session) {
+    log.debug(`[term] detach(${worktreeId}) no session found`);
+    return;
   }
+  log.debug(`[term] detach(${worktreeId}) killing pid=${session.proc.pid} tmux=${session.groupedSessionName}`);
+  session.cancelled = true;
+  session.proc.kill();
+  sessions.delete(worktreeId);
+  killTmuxSession(session.groupedSessionName);
 }
-async function writeEnvLocal(wtDir, entries) {
-  const filePath = `${wtDir}/.env.local`;
-  let lines = [];
+function write(worktreeId, data) {
+  const session = sessions.get(worktreeId);
+  if (!session) {
+    log.warn(`[term] write(${worktreeId}) NO SESSION - input dropped (${data.length} bytes)`);
+    return;
+  }
   try {
-    const content = (await Bun.file(filePath).text()).trim();
-    if (content)
-      lines = content.split(`
-`);
-  } catch {}
-  for (const [key, value] of Object.entries(entries)) {
-    const needsQuoting = /[{}"\s$`\\!#|;&()<>']/.test(value);
-    const safe = needsQuoting ? `'${value.replaceAll("'", "'\\''")}'` : value;
-    const pattern = new RegExp(`^${key}=`);
-    const idx = lines.findIndex((l) => pattern.test(l));
-    if (idx >= 0) {
-      lines[idx] = `${key}=${safe}`;
-    } else {
-      lines.push(`${key}=${safe}`);
+    session.proc.stdin.write(textEncoder.encode(data));
+    session.proc.stdin.flush();
+  } catch (err) {
+    log.error(`[term] write(${worktreeId}) stdin closed`, err);
+  }
+}
+async function sendKeys(worktreeId, hexBytes) {
+  const session = sessions.get(worktreeId);
+  if (!session)
+    return;
+  const windowTarget = `${session.groupedSessionName}:${session.windowName}`;
+  await tmuxExec(["tmux", "send-keys", "-t", windowTarget, "-H", ...hexBytes]);
+}
+async function resize(worktreeId, cols, rows) {
+  const session = sessions.get(worktreeId);
+  if (!session)
+    return;
+  const windowTarget = `${session.groupedSessionName}:${session.windowName}`;
+  const result = await tmuxExec(["tmux", "resize-window", "-t", windowTarget, "-x", String(cols), "-y", String(rows)]);
+  if (result.exitCode !== 0)
+    log.warn(`[term] resize failed: ${result.stderr}`);
+}
+function getScrollback(worktreeId) {
+  return sessions.get(worktreeId)?.scrollback.join("") ?? "";
+}
+function setCallbacks(worktreeId, onData, onExit) {
+  const session = sessions.get(worktreeId);
+  if (session) {
+    session.onData = onData;
+    session.onExit = onExit;
+  }
+}
+async function selectPane(worktreeId, paneIndex) {
+  const session = sessions.get(worktreeId);
+  if (!session) {
+    log.debug(`[term] selectPane(${worktreeId}) no session found`);
+    return;
+  }
+  const target = `${session.groupedSessionName}:${session.windowName}.${paneIndex}`;
+  log.debug(`[term] selectPane(${worktreeId}) pane=${paneIndex} target=${target}`);
+  const [r1, r2] = await Promise.all([
+    tmuxExec(["tmux", "select-pane", "-t", target]),
+    tmuxExec(["tmux", "resize-pane", "-Z", "-t", target])
+  ]);
+  log.debug(`[term] selectPane(${worktreeId}) select=${r1.exitCode} zoom=${r2.exitCode}`);
+}
+function clearCallbacks(worktreeId) {
+  const session = sessions.get(worktreeId);
+  if (session) {
+    session.onData = null;
+    session.onExit = null;
+  }
+}
+async function sendPrompt(worktreeId, target, text, paneIndex = 0, preamble) {
+  const paneTarget = `${target.ownerSessionName}:${target.windowName}.${paneIndex}`;
+  log.debug(`[term] sendPrompt(${worktreeId}) target=${paneTarget} textBytes=${text.length}`);
+  if (preamble) {
+    const preambleResult = await tmuxExec(["tmux", "send-keys", "-t", paneTarget, "-l", "--", preamble]);
+    if (preambleResult.exitCode !== 0) {
+      return { ok: false, error: `send-keys preamble failed${preambleResult.stderr ? `: ${preambleResult.stderr}` : ""}` };
     }
   }
-  await Bun.write(filePath, lines.join(`
-`) + `
-`);
+  const cleaned = text.replace(/\0/g, "");
+  const bufferName = `wm-prompt-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+  const load = await tmuxExec(["tmux", "load-buffer", "-b", bufferName, "-"], {
+    stdin: new TextEncoder().encode(cleaned)
+  });
+  if (load.exitCode !== 0) {
+    return { ok: false, error: `load-buffer failed${load.stderr ? `: ${load.stderr}` : ""}` };
+  }
+  const paste = await tmuxExec(["tmux", "paste-buffer", "-b", bufferName, "-t", paneTarget, "-d"]);
+  if (paste.exitCode !== 0) {
+    return { ok: false, error: `paste-buffer failed${paste.stderr ? `: ${paste.stderr}` : ""}` };
+  }
+  return { ok: true };
 }
-function readAllWorktreeEnvs(worktreePaths, excludeDir) {
-  return Promise.all(worktreePaths.filter((p) => !excludeDir || p !== excludeDir).map((p) => readEnvLocal(p)));
+
+// backend/src/adapters/git.ts
+import { rmSync } from "fs";
+import { resolve } from "path";
+function runGit(args, cwd) {
+  const result = Bun.spawnSync(["git", ...args], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  if (result.exitCode !== 0) {
+    const stderr = new TextDecoder().decode(result.stderr).trim();
+    throw new Error(`git ${args.join(" ")} failed: ${stderr || `exit ${result.exitCode}`}`);
+  }
+  return new TextDecoder().decode(result.stdout).trim();
 }
-function allocatePorts(existingEnvs, services) {
-  const allocatable = services.filter((s) => s.portStart != null);
-  if (allocatable.length === 0)
-    return {};
-  const ref = allocatable[0];
-  const refStart = ref.portStart;
-  const refStep = ref.portStep ?? 1;
-  const occupied = new Set;
-  for (const env of existingEnvs) {
-    const raw = env[ref.portEnv];
-    if (raw == null)
+function tryRunGit(args, cwd) {
+  const result = Bun.spawnSync(["git", ...args], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  if (result.exitCode !== 0) {
+    return {
+      ok: false,
+      stderr: new TextDecoder().decode(result.stderr).trim()
+    };
+  }
+  return {
+    ok: true,
+    stdout: new TextDecoder().decode(result.stdout).trim()
+  };
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isRegisteredWorktree(entries, worktreePath) {
+  const resolvedPath = resolve(worktreePath);
+  return entries.some((entry) => resolve(entry.path) === resolvedPath);
+}
+function removeDirectory(path) {
+  rmSync(path, {
+    recursive: true,
+    force: true
+  });
+}
+function currentCheckoutRef(cwd) {
+  const symbolicRef = tryRunGit(["symbolic-ref", "--quiet", "--short", "HEAD"], cwd);
+  if (symbolicRef.ok && symbolicRef.stdout.length > 0) {
+    return {
+      ref: symbolicRef.stdout,
+      branch: symbolicRef.stdout
+    };
+  }
+  return {
+    ref: runGit(["rev-parse", "--verify", "HEAD"], cwd),
+    branch: null
+  };
+}
+function resolveWorktreeRoot(cwd) {
+  const output = runGit(["rev-parse", "--show-toplevel"], cwd);
+  return resolve(cwd, output);
+}
+function resolveWorktreeGitDir(cwd) {
+  const output = runGit(["rev-parse", "--git-dir"], cwd);
+  return resolve(cwd, output);
+}
+function parseGitWorktreePorcelain(output) {
+  const entries = [];
+  let current = null;
+  const flush = () => {
+    if (current?.path)
+      entries.push(current);
+    current = null;
+  };
+  for (const rawLine of output.split(`
+`)) {
+    const line = rawLine.trimEnd();
+    if (!line) {
+      flush();
+      continue;
+    }
+    if (line.startsWith("worktree ")) {
+      flush();
+      current = {
+        path: line.slice("worktree ".length),
+        branch: null,
+        head: null,
+        detached: false,
+        bare: false
+      };
+      continue;
+    }
+    if (!current)
+      continue;
+    if (line.startsWith("branch ")) {
+      current.branch = line.slice("branch ".length).replace(/^refs\/heads\//, "");
       continue;
-    const port = Number(raw);
-    if (!Number.isInteger(port) || port < refStart)
+    }
+    if (line.startsWith("HEAD ")) {
+      current.head = line.slice("HEAD ".length);
       continue;
-    const diff = port - refStart;
-    if (diff % refStep !== 0)
+    }
+    if (line === "detached") {
+      current.detached = true;
       continue;
-    occupied.add(diff / refStep);
+    }
+    if (line === "bare") {
+      current.bare = true;
+    }
   }
-  let slot = 1;
-  while (occupied.has(slot))
-    slot++;
-  const result = {};
-  for (const svc of allocatable) {
-    const start = svc.portStart;
-    const step = svc.portStep ?? 1;
-    result[svc.portEnv] = String(start + slot * step);
+  flush();
+  return entries;
+}
+function listGitWorktrees(cwd) {
+  const output = runGit(["worktree", "list", "--porcelain"], cwd);
+  return parseGitWorktreePorcelain(output);
+}
+function readGitWorktreeStatus(cwd) {
+  const dirtyOutput = runGit(["status", "--porcelain"], cwd);
+  const commit = tryRunGit(["rev-parse", "HEAD"], cwd);
+  const ahead = tryRunGit(["rev-list", "--count", "@{upstream}..HEAD"], cwd);
+  return {
+    dirty: dirtyOutput.length > 0,
+    aheadCount: ahead.ok ? parseInt(ahead.stdout, 10) || 0 : 0,
+    currentCommit: commit.ok && commit.stdout.length > 0 ? commit.stdout : null
+  };
+}
+function removeGitWorktree(opts, deps = {}) {
+  const args = ["worktree", "remove"];
+  if (opts.force)
+    args.push("--force");
+  args.push(opts.worktreePath);
+  const result = (deps.tryRunGit ?? tryRunGit)(args, opts.repoRoot);
+  if (result.ok) {
+    return;
+  }
+  const failure = `git ${args.join(" ")} failed: ${result.stderr || "exit 1"}`;
+  const remainingWorktrees = (deps.listWorktrees ?? listGitWorktrees)(opts.repoRoot);
+  if (isRegisteredWorktree(remainingWorktrees, opts.worktreePath)) {
+    throw new Error(failure);
+  }
+  try {
+    (deps.removeDirectory ?? removeDirectory)(opts.worktreePath);
+  } catch (error) {
+    throw new Error(`${failure}; cleanup failed: ${errorMessage(error)}`);
+  }
+}
+
+class BunGitGateway {
+  resolveWorktreeRoot(cwd) {
+    return resolveWorktreeRoot(cwd);
+  }
+  resolveWorktreeGitDir(cwd) {
+    return resolveWorktreeGitDir(cwd);
+  }
+  listWorktrees(cwd) {
+    return listGitWorktrees(cwd);
+  }
+  readWorktreeStatus(cwd) {
+    return readGitWorktreeStatus(cwd);
+  }
+  createWorktree(opts) {
+    const args = ["worktree", "add", "-b", opts.branch, opts.worktreePath];
+    if (opts.baseBranch)
+      args.push(opts.baseBranch);
+    runGit(args, opts.repoRoot);
+  }
+  removeWorktree(opts) {
+    removeGitWorktree(opts);
+  }
+  deleteBranch(repoRoot, branch, force = false) {
+    runGit(["branch", force ? "-D" : "-d", branch], repoRoot);
+  }
+  mergeBranch(opts) {
+    const current = currentCheckoutRef(opts.repoRoot);
+    const shouldRestore = current.branch !== opts.targetBranch;
+    if (shouldRestore) {
+      runGit(["checkout", opts.targetBranch], opts.repoRoot);
+    }
+    let mergeError = null;
+    const cleanupErrors = [];
+    try {
+      runGit(["merge", "--no-ff", "--no-edit", opts.sourceBranch], opts.repoRoot);
+    } catch (error) {
+      mergeError = errorMessage(error);
+      const abort = tryRunGit(["merge", "--abort"], opts.repoRoot);
+      if (!abort.ok && abort.stderr.length > 0 && !abort.stderr.includes("MERGE_HEAD missing")) {
+        cleanupErrors.push(`merge abort failed: ${abort.stderr}`);
+      }
+    }
+    if (shouldRestore) {
+      const restore = tryRunGit(["checkout", current.ref], opts.repoRoot);
+      if (!restore.ok) {
+        cleanupErrors.push(`restore checkout failed: ${restore.stderr}`);
+      }
+    }
+    if (mergeError) {
+      const suffix = cleanupErrors.length > 0 ? `; ${cleanupErrors.join("; ")}` : "";
+      throw new Error(`${mergeError}${suffix}`);
+    }
+    if (cleanupErrors.length > 0) {
+      throw new Error(cleanupErrors.join("; "));
+    }
+  }
+  currentBranch(repoRoot) {
+    return runGit(["branch", "--show-current"], repoRoot);
   }
-  return result;
 }
 
-// backend/src/config.ts
+// backend/src/adapters/config.ts
+import { readFileSync } from "fs";
 import { join } from "path";
 
 // node_modules/.bun/yaml@2.8.2/node_modules/yaml/dist/index.js
@@ -7062,70 +7432,221 @@ var $stringify = publicApi.stringify;
 var $visit = visit.visit;
 var $visitAsync = visit.visitAsync;
 
-// backend/src/config.ts
+// backend/src/adapters/config.ts
+var DEFAULT_PANES = [
+  { id: "agent", kind: "agent", focus: true },
+  { id: "shell", kind: "shell", split: "right", sizePct: 25 }
+];
 var DEFAULT_CONFIG = {
+  name: "Webmux",
+  workspace: {
+    mainBranch: "main",
+    worktreeRoot: "__worktrees",
+    defaultAgent: "claude"
+  },
+  profiles: {
+    default: {
+      runtime: "host",
+      envPassthrough: [],
+      panes: clonePanes(DEFAULT_PANES)
+    }
+  },
   services: [],
-  profiles: { default: { name: "default" } },
-  autoName: false,
-  linkedRepos: [],
-  startupEnvs: {}
+  startupEnvs: {},
+  integrations: {
+    github: { linkedRepos: [] },
+    linear: { enabled: true }
+  },
+  lifecycleHooks: {},
+  autoName: null
 };
-function hasAutoName(dir) {
-  try {
-    const filePath = join(gitRoot(dir), ".workmux.yaml");
-    const result = Bun.spawnSync(["cat", filePath], { stdout: "pipe", stderr: "pipe" });
-    const text = new TextDecoder().decode(result.stdout).trim();
-    if (!text)
-      return false;
-    const parsed = $parse(text);
-    const autoName = parsed.auto_name;
-    return !!autoName?.model;
-  } catch {
-    return false;
+function clonePanes(panes) {
+  return panes.map((pane) => ({ ...pane }));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function parseAgentKind(value) {
+  return value === "codex" ? "codex" : "claude";
+}
+function parsePanes(raw) {
+  if (!Array.isArray(raw))
+    return clonePanes(DEFAULT_PANES);
+  const panes = raw.map((entry, index) => parsePane(entry, index)).filter((pane) => pane !== null);
+  return panes.length > 0 ? panes : clonePanes(DEFAULT_PANES);
+}
+function parsePane(raw, index) {
+  if (!isRecord(raw))
+    return null;
+  if (raw.kind !== "agent" && raw.kind !== "shell" && raw.kind !== "command")
+    return null;
+  const pane = {
+    id: typeof raw.id === "string" && raw.id.trim() ? raw.id.trim() : `pane-${index + 1}`,
+    kind: raw.kind
+  };
+  if (raw.split === "right" || raw.split === "bottom")
+    pane.split = raw.split;
+  if (typeof raw.sizePct === "number" && Number.isFinite(raw.sizePct))
+    pane.sizePct = raw.sizePct;
+  if (raw.focus === true)
+    pane.focus = true;
+  if (raw.cwd === "repo" || raw.cwd === "worktree")
+    pane.cwd = raw.cwd;
+  if (raw.kind === "command") {
+    if (typeof raw.command !== "string" || !raw.command.trim())
+      return null;
+    pane.command = raw.command.trim();
+  }
+  return pane;
+}
+function parseMounts(raw) {
+  if (!Array.isArray(raw))
+    return;
+  const mounts = raw.filter(isRecord).filter((entry) => typeof entry.hostPath === "string" && entry.hostPath.length > 0).map((entry) => ({
+    hostPath: entry.hostPath,
+    ...typeof entry.guestPath === "string" && entry.guestPath.length > 0 ? { guestPath: entry.guestPath } : {},
+    ...typeof entry.writable === "boolean" ? { writable: entry.writable } : {}
+  }));
+  return mounts.length > 0 ? mounts : undefined;
+}
+function parseProfile(raw, fallbackRuntime) {
+  if (!isRecord(raw)) {
+    return {
+      runtime: fallbackRuntime,
+      envPassthrough: [],
+      panes: clonePanes(DEFAULT_PANES)
+    };
+  }
+  const runtime = raw.runtime === "docker" ? "docker" : fallbackRuntime;
+  const envPassthrough = isStringArray(raw.envPassthrough) ? raw.envPassthrough : [];
+  const panes = parsePanes(raw.panes);
+  const mounts = parseMounts(raw.mounts);
+  const image = typeof raw.image === "string" && raw.image.trim() ? raw.image.trim() : undefined;
+  return {
+    runtime,
+    envPassthrough,
+    ...raw.yolo === true ? { yolo: true } : {},
+    panes,
+    ...typeof raw.systemPrompt === "string" && raw.systemPrompt.length > 0 ? { systemPrompt: raw.systemPrompt } : {},
+    ...image ? { image } : {},
+    ...mounts ? { mounts } : {}
+  };
+}
+function parseProfiles(raw) {
+  if (!isRecord(raw))
+    return { default: { ...DEFAULT_CONFIG.profiles.default, panes: clonePanes(DEFAULT_CONFIG.profiles.default.panes) } };
+  const profiles = Object.entries(raw).reduce((acc, [name, value]) => {
+    const fallbackRuntime = name === "sandbox" ? "docker" : "host";
+    acc[name] = parseProfile(value, fallbackRuntime);
+    return acc;
+  }, {});
+  if (Object.keys(profiles).length === 0) {
+    return { default: { ...DEFAULT_CONFIG.profiles.default, panes: clonePanes(DEFAULT_CONFIG.profiles.default.panes) } };
+  }
+  return profiles;
+}
+function parseServices(raw) {
+  if (!Array.isArray(raw))
+    return [];
+  return raw.filter(isRecord).filter((entry) => typeof entry.name === "string" && typeof entry.portEnv === "string").map((entry) => ({
+    name: entry.name,
+    portEnv: entry.portEnv,
+    ...typeof entry.portStart === "number" && Number.isFinite(entry.portStart) ? { portStart: entry.portStart } : {},
+    ...typeof entry.portStep === "number" && Number.isFinite(entry.portStep) ? { portStep: entry.portStep } : {},
+    ...typeof entry.urlTemplate === "string" && entry.urlTemplate.length > 0 ? { urlTemplate: entry.urlTemplate } : {}
+  }));
+}
+function parseStartupEnvs(raw) {
+  if (!isRecord(raw))
+    return {};
+  const startupEnvs = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (typeof value === "boolean") {
+      startupEnvs[key] = value;
+    } else {
+      startupEnvs[key] = typeof value === "string" ? value : String(value);
+    }
+  }
+  return startupEnvs;
+}
+function parseLifecycleHooks(raw) {
+  if (!isRecord(raw))
+    return {};
+  const hooks = {};
+  if (typeof raw.postCreate === "string" && raw.postCreate.trim()) {
+    hooks.postCreate = raw.postCreate.trim();
   }
+  if (typeof raw.preRemove === "string" && raw.preRemove.trim()) {
+    hooks.preRemove = raw.preRemove.trim();
+  }
+  return hooks;
+}
+function parseAutoName(raw) {
+  if (!isRecord(raw))
+    return null;
+  if (typeof raw.model !== "string" || !raw.model.trim())
+    return null;
+  return {
+    model: raw.model.trim(),
+    ...typeof raw.system_prompt === "string" && raw.system_prompt.trim() ? { systemPrompt: raw.system_prompt.trim() } : {}
+  };
+}
+function parseLinkedRepos(raw) {
+  if (!Array.isArray(raw))
+    return [];
+  return raw.filter(isRecord).filter((entry) => typeof entry.repo === "string").map((entry) => ({
+    repo: entry.repo,
+    alias: typeof entry.alias === "string" ? entry.alias : entry.repo.split("/").pop() ?? "repo"
+  }));
+}
+function isDockerProfile(profile) {
+  return !!profile && profile.runtime === "docker" && typeof profile.image === "string" && profile.image.length > 0;
+}
+function getDefaultProfileName(config) {
+  if (config.profiles.default)
+    return "default";
+  return Object.keys(config.profiles)[0] ?? "default";
+}
+function readConfigFile(root) {
+  return readFileSync(join(root, ".webmux.yaml"), "utf8");
 }
 function gitRoot(dir) {
-  const result = Bun.spawnSync(["git", "rev-parse", "--show-toplevel"], { stdout: "pipe", cwd: dir });
-  return new TextDecoder().decode(result.stdout).trim() || dir;
+  const result = Bun.spawnSync(["git", "rev-parse", "--show-toplevel"], { stdout: "pipe", stderr: "pipe", cwd: dir });
+  if (result.exitCode !== 0)
+    return dir;
+  const root = new TextDecoder().decode(result.stdout).trim();
+  return root || dir;
 }
 function loadConfig(dir) {
   try {
     const root = gitRoot(dir);
-    const filePath = join(root, ".webmux.yaml");
-    const result = Bun.spawnSync(["cat", filePath], { stdout: "pipe" });
-    const text = new TextDecoder().decode(result.stdout).trim();
+    const text = readConfigFile(root).trim();
     if (!text)
       return DEFAULT_CONFIG;
     const parsed = $parse(text);
-    const profiles = parsed.profiles;
-    const defaultProfile = profiles?.default;
-    const sandboxProfile = profiles?.sandbox;
-    const autoName = hasAutoName(dir);
-    const linkedRepos = Array.isArray(parsed.linkedRepos) ? parsed.linkedRepos.filter((r) => typeof r === "object" && r !== null && typeof r.repo === "string").map((r) => ({
-      repo: r.repo,
-      alias: typeof r.alias === "string" ? r.alias : r.repo.split("/").pop()
-    })) : [];
-    let startupEnvs = {};
-    if (parsed.startupEnvs && typeof parsed.startupEnvs === "object" && !Array.isArray(parsed.startupEnvs)) {
-      const raw = parsed.startupEnvs;
-      for (const [k, v] of Object.entries(raw)) {
-        if (typeof v === "boolean") {
-          startupEnvs[k] = v;
-        } else {
-          startupEnvs[k] = typeof v === "string" ? v : String(v);
-        }
-      }
-    }
     return {
-      ...typeof parsed.name === "string" ? { name: parsed.name } : {},
-      services: Array.isArray(parsed.services) ? parsed.services : DEFAULT_CONFIG.services,
-      profiles: {
-        default: defaultProfile?.name ? defaultProfile : DEFAULT_CONFIG.profiles.default,
-        ...sandboxProfile?.name && sandboxProfile?.image ? { sandbox: sandboxProfile } : {}
+      name: typeof parsed.name === "string" && parsed.name.trim() ? parsed.name.trim() : DEFAULT_CONFIG.name,
+      workspace: {
+        mainBranch: isRecord(parsed.workspace) && typeof parsed.workspace.mainBranch === "string" ? parsed.workspace.mainBranch : DEFAULT_CONFIG.workspace.mainBranch,
+        worktreeRoot: isRecord(parsed.workspace) && typeof parsed.workspace.worktreeRoot === "string" ? parsed.workspace.worktreeRoot : DEFAULT_CONFIG.workspace.worktreeRoot,
+        defaultAgent: isRecord(parsed.workspace) ? parseAgentKind(parsed.workspace.defaultAgent) : DEFAULT_CONFIG.workspace.defaultAgent
+      },
+      profiles: parseProfiles(parsed.profiles),
+      services: parseServices(parsed.services),
+      startupEnvs: parseStartupEnvs(parsed.startupEnvs),
+      integrations: {
+        github: {
+          linkedRepos: isRecord(parsed.integrations) && isRecord(parsed.integrations.github) ? parseLinkedRepos(parsed.integrations.github.linkedRepos) : []
+        },
+        linear: {
+          enabled: isRecord(parsed.integrations) && isRecord(parsed.integrations.linear) && typeof parsed.integrations.linear.enabled === "boolean" ? parsed.integrations.linear.enabled : DEFAULT_CONFIG.integrations.linear.enabled
+        }
       },
-      autoName,
-      linkedRepos,
-      startupEnvs
+      lifecycleHooks: parseLifecycleHooks(parsed.lifecycleHooks),
+      autoName: parseAutoName(parsed.auto_name)
     };
   } catch {
     return DEFAULT_CONFIG;
@@ -7135,31 +7656,29 @@ function expandTemplate(template, env) {
   return template.replace(/\$\{(\w+)\}/g, (_, key) => env[key] ?? "");
 }
 
-// backend/src/docker.ts
-import { stat } from "fs/promises";
-
-// backend/src/rpc-secret.ts
+// backend/src/adapters/control-token.ts
 import { chmod, mkdir } from "fs/promises";
 import { dirname } from "path";
-var SECRET_PATH = `${Bun.env.HOME ?? "/root"}/.config/workmux/rpc-secret`;
-var cached = null;
-async function loadRpcSecret() {
-  if (cached)
-    return cached;
-  const file = Bun.file(SECRET_PATH);
+var CONTROL_TOKEN_PATH = `${Bun.env.HOME ?? "/root"}/.config/webmux/control-token`;
+var cachedToken = null;
+async function loadControlToken() {
+  if (cachedToken)
+    return cachedToken;
+  const file = Bun.file(CONTROL_TOKEN_PATH);
   if (await file.exists()) {
-    cached = (await file.text()).trim();
-    return cached;
-  }
-  const secret = crypto.randomUUID();
-  await mkdir(dirname(SECRET_PATH), { recursive: true });
-  await Bun.write(SECRET_PATH, secret);
-  await chmod(SECRET_PATH, 384);
-  cached = secret;
-  return secret;
+    cachedToken = (await file.text()).trim();
+    return cachedToken;
+  }
+  const controlToken = crypto.randomUUID();
+  await mkdir(dirname(CONTROL_TOKEN_PATH), { recursive: true });
+  await Bun.write(CONTROL_TOKEN_PATH, controlToken);
+  await chmod(CONTROL_TOKEN_PATH, 384);
+  cachedToken = controlToken;
+  return controlToken;
 }
 
-// backend/src/docker.ts
+// backend/src/adapters/docker.ts
+import { stat } from "fs/promises";
 var DOCKER_RUN_TIMEOUT_MS = 60000;
 async function pathExists(p) {
   try {
@@ -7183,39 +7702,17 @@ function isValidPort(s) {
 function isValidEnvKey(s) {
   return /^[A-Za-z_][A-Za-z0-9_]*$/.test(s);
 }
-function buildWorkmuxStub() {
-  return `#!/usr/bin/env python3
-import sys, json, os, urllib.request
-
-cmd = sys.argv[1] if len(sys.argv) > 1 else ""
-args = sys.argv[2:]
-host = os.environ.get("WORKMUX_RPC_HOST", "host.docker.internal")
-port = os.environ.get("WORKMUX_RPC_PORT", "5111")
-token = os.environ.get("WORKMUX_RPC_TOKEN", "")
-branch = os.environ.get("WORKMUX_BRANCH", "")
-
-payload = {"command": cmd, "args": args, "branch": branch}
-data = json.dumps(payload).encode()
-req = urllib.request.Request(
-    f"http://{host}:{port}/rpc/workmux",
-    data=data,
-    headers={"Content-Type": "application/json", "Authorization": f"Bearer {token}"}
-)
-try:
-    with urllib.request.urlopen(req, timeout=30) as resp:
-        result = json.loads(resp.read())
-        if result.get("ok"):
-            print(result.get("output", ""))
-        else:
-            print(result.get("error", "RPC failed"), file=sys.stderr)
-            sys.exit(1)
-except Exception as e:
-    print(f"workmux rpc error: {e}", file=sys.stderr)
-    sys.exit(1)
-`;
+
+class BunDockerGateway {
+  launchContainer(opts) {
+    return launchContainer(opts);
+  }
+  removeContainer(branch) {
+    return removeContainer(branch);
+  }
 }
-function buildDockerRunArgs(opts, existingPaths, home, name, rpcSecret, rpcPort, sshAuthSock, hostUid, hostGid) {
-  const { wtDir, mainRepoDir, sandboxConfig, services, env } = opts;
+function buildDockerRunArgs(opts, existingPaths, home, name, sshAuthSock, hostUid, hostGid) {
+  const { wtDir, mainRepoDir, sandboxConfig, services, runtimeEnv } = opts;
   const args = [
     "docker",
     "run",
@@ -7231,7 +7728,7 @@ function buildDockerRunArgs(opts, existingPaths, home, name, rpcSecret, rpcPort,
   ];
   const seenPorts = new Set;
   for (const svc of services) {
-    const port = env[svc.portEnv];
+    const port = runtimeEnv[svc.portEnv];
     if (!port)
       continue;
     if (!isValidPort(port)) {
@@ -7276,9 +7773,9 @@ function buildDockerRunArgs(opts, existingPaths, home, name, rpcSecret, rpcPort,
       }
     }
   }
-  for (const [key, val] of Object.entries(env)) {
+  for (const [key, val] of Object.entries(runtimeEnv)) {
     if (!isValidEnvKey(key)) {
-      log.warn(`[docker] skipping invalid .env.local key: ${JSON.stringify(key)}`);
+      log.warn(`[docker] skipping invalid runtime env key: ${JSON.stringify(key)}`);
       continue;
     }
     if (reservedKeys.has(key))
@@ -7292,8 +7789,8 @@ function buildDockerRunArgs(opts, existingPaths, home, name, rpcSecret, rpcPort,
   args.push("-v", `${home}/.claude.json:/root/.claude.json`);
   args.push("-v", `${home}/.codex:/root/.codex`);
   const extraMountGuestPaths = new Set;
-  if (sandboxConfig.extraMounts) {
-    for (const mount of sandboxConfig.extraMounts) {
+  if (sandboxConfig.mounts) {
+    for (const mount of sandboxConfig.mounts) {
       const hostPath = mount.hostPath.replace(/^~/, home);
       if (!hostPath.startsWith("/"))
         continue;
@@ -7316,11 +7813,11 @@ function buildDockerRunArgs(opts, existingPaths, home, name, rpcSecret, rpcPort,
     args.push("--mount", `type=bind,source=${sshAuthSock},target=${sshAuthSock}`);
     args.push("-e", `SSH_AUTH_SOCK=${sshAuthSock}`);
   }
-  if (sandboxConfig.extraMounts) {
-    for (const mount of sandboxConfig.extraMounts) {
+  if (sandboxConfig.mounts) {
+    for (const mount of sandboxConfig.mounts) {
       const hostPath = mount.hostPath.replace(/^~/, home);
       if (!hostPath.startsWith("/")) {
-        log.warn(`[docker] skipping extra mount with non-absolute host path: ${JSON.stringify(hostPath)}`);
+        log.warn(`[docker] skipping mount with non-absolute host path: ${JSON.stringify(hostPath)}`);
         continue;
       }
       const guestPath = mount.guestPath ?? hostPath;
@@ -7328,10 +7825,6 @@ function buildDockerRunArgs(opts, existingPaths, home, name, rpcSecret, rpcPort,
       args.push("-v", `${hostPath}:${guestPath}${suffix}`);
     }
   }
-  args.push("-e", `WORKMUX_RPC_HOST=host.docker.internal`);
-  args.push("-e", `WORKMUX_RPC_PORT=${rpcPort}`);
-  args.push("-e", `WORKMUX_RPC_TOKEN=${rpcSecret}`);
-  args.push("-e", `WORKMUX_BRANCH=${opts.branch}`);
   args.push(sandboxConfig.image, "sleep", "infinity");
   return args;
 }
@@ -7347,8 +7840,6 @@ async function launchContainer(opts) {
   }
   const name = containerName(branch);
   const home = Bun.env.HOME ?? "/root";
-  const rpcSecret = await loadRpcSecret();
-  const rpcPort = Bun.env.BACKEND_PORT ?? "5111";
   let sshAuthSock = Bun.env.SSH_AUTH_SOCK;
   if (sshAuthSock) {
     try {
@@ -7372,7 +7863,7 @@ async function launchContainer(opts) {
     if (await pathExists(p))
       existingPaths.add(p);
   }));
-  const args = buildDockerRunArgs(opts, existingPaths, home, name, rpcSecret, rpcPort, sshAuthSock, process.getuid(), process.getgid());
+  const args = buildDockerRunArgs(opts, existingPaths, home, name, sshAuthSock, process.getuid(), process.getgid());
   log.info(`[docker] launching container: ${name}`);
   const proc = Bun.spawn(args, { stdout: "pipe", stderr: "pipe" });
   const timeout = Bun.sleep(DOCKER_RUN_TIMEOUT_MS).then(() => {
@@ -7393,30 +7884,6 @@ async function launchContainer(opts) {
     throw new Error(`docker run failed (exit ${exitResult}): ${stderr}`);
   }
   log.info(`[docker] container ${name} ready (id=${containerId.trim().slice(0, 12)})`);
-  const stub = buildWorkmuxStub();
-  const injectProc = Bun.spawn([
-    "docker",
-    "exec",
-    "-u",
-    "root",
-    "-i",
-    name,
-    "sh",
-    "-c",
-    "cat > /usr/local/bin/workmux && chmod +x /usr/local/bin/workmux"
-  ], { stdin: "pipe", stdout: "pipe", stderr: "pipe" });
-  const { stdin } = injectProc;
-  if (stdin) {
-    stdin.write(stub);
-    stdin.end();
-  }
-  const injectExit = await injectProc.exited;
-  if (injectExit !== 0) {
-    const injectStderr = await new Response(injectProc.stderr).text();
-    log.warn(`[docker] workmux stub injection failed for ${name}: ${injectStderr}`);
-  } else {
-    log.debug(`[docker] workmux stub injected into ${name}`);
-  }
   return name;
 }
 async function findContainer(branch) {
@@ -7463,701 +7930,1807 @@ async function removeContainer(branch) {
   }));
 }
 
-// backend/src/workmux.ts
-var WORKTREE_HEADERS = ["BRANCH", "AGENT", "MUX", "UNMERGED", "PATH"];
-var STATUS_HEADERS = ["WORKTREE", "STATUS", "ELAPSED", "TITLE"];
-function parseTable(output, mapper, expectedHeaders) {
-  const lines = output.trim().split(`
-`).filter(Boolean);
-  if (lines.length < 2)
-    return [];
-  const headerLine = lines[0];
-  if (expectedHeaders) {
-    const actual = headerLine.trim().split(/\s+/).map((h) => h.toUpperCase());
-    const match = expectedHeaders.every((h, i) => actual[i] === h.toUpperCase());
-    if (!match) {
-      log.warn(`[parseTable] unexpected headers: got [${actual.join(", ")}], expected [${expectedHeaders.join(", ")}]`);
-    }
-  }
-  const colStarts = [];
-  let inSpace = true;
-  for (let i = 0;i < headerLine.length; i++) {
-    if (headerLine[i] !== " " && inSpace) {
-      colStarts.push(i);
-      inSpace = false;
-    } else if (headerLine[i] === " " && !inSpace) {
-      inSpace = true;
-    }
-  }
-  return lines.slice(1).map((line) => {
-    const cols = colStarts.map((start, idx) => {
-      const end = idx + 1 < colStarts.length ? colStarts[idx + 1] : line.length;
-      return line.slice(start, end).trim();
-    });
-    return mapper(cols);
-  });
-}
-function workmuxEnv() {
-  if (process.env.TMUX)
-    return process.env;
-  const tmpdir = process.env.TMUX_TMPDIR || "/tmp";
-  const uid = process.getuid?.() ?? 1000;
-  return { ...process.env, TMUX: `${tmpdir}/tmux-${uid}/default,0,0` };
-}
-function resolveDetachedBranch(branch, path) {
-  if (branch !== "(detached)" || !path)
-    return branch;
-  return path.split("/").pop() || branch;
+// backend/src/adapters/hooks.ts
+function buildErrorMessage(name, exitCode, stdout, stderr) {
+  const output = stderr.trim() || stdout.trim();
+  if (output) {
+    return `${name} hook failed (exit ${exitCode}): ${output}`;
+  }
+  return `${name} hook failed (exit ${exitCode})`;
 }
-async function listWorktrees() {
-  const proc = await $`workmux list`.env(workmuxEnv()).nothrow().quiet();
-  if (proc.exitCode !== 0) {
-    ensureTmux();
-    return [];
+
+class BunLifecycleHookRunner {
+  async run(input) {
+    const proc = Bun.spawn(["bash", "-lc", input.command], {
+      cwd: input.cwd,
+      env: {
+        ...Bun.env,
+        ...input.env
+      },
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const [exitCode, stdout, stderr] = await Promise.all([
+      proc.exited,
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text()
+    ]);
+    if (exitCode !== 0) {
+      throw new Error(buildErrorMessage(input.name, exitCode, stdout, stderr));
+    }
   }
-  return parseTable(proc.text(), (cols) => {
-    const branch = resolveDetachedBranch(cols[0] ?? "", cols[4] ?? "");
-    const path = cols[4] ?? "";
-    return { branch, agent: cols[1] ?? "", mux: cols[2] ?? "", unmerged: cols[3] ?? "", path };
-  }, WORKTREE_HEADERS);
 }
-async function getStatus() {
-  const proc = await $`workmux status`.env(workmuxEnv()).nothrow().quiet();
-  if (proc.exitCode !== 0) {
-    ensureTmux();
-    return [];
+
+// backend/src/adapters/port-probe.ts
+class BunPortProbe {
+  timeoutMs;
+  hostname;
+  constructor(timeoutMs = 300, hostname = "127.0.0.1") {
+    this.timeoutMs = timeoutMs;
+    this.hostname = hostname;
+  }
+  isListening(port) {
+    return new Promise((resolve2) => {
+      let settled = false;
+      const settle = (result) => {
+        if (settled)
+          return;
+        settled = true;
+        clearTimeout(timer);
+        resolve2(result);
+      };
+      const timer = setTimeout(() => settle(false), this.timeoutMs);
+      Bun.connect({
+        hostname: this.hostname,
+        port,
+        socket: {
+          open(socket) {
+            socket.end();
+            settle(true);
+          },
+          error() {
+            settle(false);
+          },
+          data() {}
+        }
+      }).catch(() => settle(false));
+    });
   }
-  return parseTable(proc.text(), (cols) => ({
-    worktree: cols[0] ?? "",
-    status: cols[1] ?? "",
-    elapsed: cols[2] ?? "",
-    title: cols[3] ?? ""
-  }), STATUS_HEADERS);
 }
-async function tryExec(args, env) {
-  const proc = Bun.spawn(args, {
+
+// backend/src/adapters/tmux.ts
+import { createHash } from "crypto";
+import { basename, resolve as resolve2 } from "path";
+function runTmux(args) {
+  const result = Bun.spawnSync(["tmux", ...args], {
     stdout: "pipe",
-    stderr: "pipe",
-    ...env ? { env: { ...Bun.env, ...env } } : {}
+    stderr: "pipe"
   });
-  const stdout = await new Response(proc.stdout).text();
-  const stderr = await new Response(proc.stderr).text();
-  const exitCode = await proc.exited;
-  if (exitCode !== 0) {
-    const msg = `${args.join(" ")} failed (exit ${exitCode}): ${stderr || stdout}`;
-    log.error(`[workmux:exec] ${msg}`);
-    return { ok: false, error: msg };
-  }
-  return { ok: true, stdout: stdout.trim() };
+  return {
+    stdout: new TextDecoder().decode(result.stdout).trim(),
+    stderr: new TextDecoder().decode(result.stderr).trim(),
+    exitCode: result.exitCode
+  };
 }
-function buildAgentCmd(env, agent, profileConfig, isSandbox, prompt) {
-  const systemPrompt = profileConfig.systemPrompt ? expandTemplate(profileConfig.systemPrompt, env) : "";
-  const innerEscaped = systemPrompt.replace(/["\\$`]/g, "\\$&");
-  const promptEscaped = prompt ? prompt.replace(/["\\$`]/g, "\\$&") : "";
-  const envPrefix = !isSandbox && profileConfig.envPassthrough?.length ? buildEnvPrefix(profileConfig.envPassthrough, { ...process.env, ...env }) : "";
-  const promptSuffix = promptEscaped ? ` "${promptEscaped}"` : "";
-  if (agent === "codex") {
-    return systemPrompt ? `${envPrefix}codex --yolo -c "developer_instructions=${innerEscaped}"${promptSuffix}` : `${envPrefix}codex --yolo${promptSuffix}`;
+function assertTmuxOk(args, action) {
+  const result = runTmux(args);
+  if (result.exitCode !== 0) {
+    throw new Error(`${action} failed: ${result.stderr || `tmux ${args.join(" ")} exit ${result.exitCode}`}`);
   }
-  const skipPerms = isSandbox ? " --dangerously-skip-permissions" : "";
-  return systemPrompt ? `${envPrefix}claude${skipPerms} --append-system-prompt "${innerEscaped}"${promptSuffix}` : `${envPrefix}claude${skipPerms}${promptSuffix}`;
+  return result.stdout;
 }
-function buildEnvPrefix(keys, env) {
-  const parts = [];
-  for (const key of keys) {
-    const val = env[key];
-    if (val) {
-      const escaped = val.replace(/'/g, "'\\''");
-      parts.push(`${key}='${escaped}'`);
-    }
-  }
-  return parts.length > 0 ? parts.join(" ") + " " : "";
+function sanitizeTmuxNameSegment(value, maxLength = 24) {
+  const sanitized = value.toLowerCase().replace(/[^a-z0-9_.-]+/g, "-").replace(/-{2,}/g, "-").replace(/^[.-]+|[.-]+$/g, "");
+  const trimmed = sanitized.slice(0, maxLength);
+  return trimmed || "x";
 }
-function parseWorktreePorcelain(output) {
-  const paths = new Map;
-  let currentPath = "";
-  for (const line of output.split(`
-`)) {
-    if (line.startsWith("worktree ")) {
-      currentPath = line.slice("worktree ".length);
-    } else if (line.startsWith("branch ")) {
-      const name = line.slice("branch ".length).replace("refs/heads/", "");
-      if (currentPath)
-        paths.set(name, currentPath);
-    }
-  }
-  return paths;
+function buildProjectSessionName(projectRoot) {
+  const resolved = resolve2(projectRoot);
+  const base = sanitizeTmuxNameSegment(basename(resolved), 18);
+  const hash = createHash("sha1").update(resolved).digest("hex").slice(0, 8);
+  return `wm-${base}-${hash}`;
 }
-function ensureTmux() {
-  const check = Bun.spawnSync(["tmux", "list-sessions"], { stdout: "pipe", stderr: "pipe" });
-  if (check.exitCode !== 0) {
-    const started = Bun.spawnSync(["tmux", "new-session", "-d", "-s", "0"]);
-    if (started.exitCode !== 0) {
-      log.debug("[workmux] tmux session already exists (concurrent start)");
-    } else {
-      log.debug("[workmux] restarted tmux session");
+function buildWorktreeWindowName(branch) {
+  return `wm-${branch}`;
+}
+function parseWindowSummaries(output) {
+  return output.split(`
+`).map((line) => line.trim()).filter(Boolean).map((line) => {
+    const [sessionName = "", windowName = "", paneCountRaw = "0"] = line.split("\t");
+    return {
+      sessionName,
+      windowName,
+      paneCount: parseInt(paneCountRaw, 10) || 0
+    };
+  }).filter((entry) => entry.sessionName.length > 0 && entry.windowName.length > 0);
+}
+
+class BunTmuxGateway {
+  ensureServer() {
+    assertTmuxOk(["start-server"], "tmux start-server");
+  }
+  ensureSession(sessionName, cwd) {
+    const check = runTmux(["has-session", "-t", sessionName]);
+    if (check.exitCode === 0)
+      return;
+    assertTmuxOk(["new-session", "-d", "-s", sessionName, "-c", cwd], `create tmux session ${sessionName}`);
+  }
+  hasWindow(sessionName, windowName) {
+    const result = runTmux(["list-windows", "-t", sessionName, "-F", "#{window_name}"]);
+    if (result.exitCode !== 0)
+      return false;
+    return result.stdout.split(`
+`).some((line) => line.trim() === windowName);
+  }
+  killWindow(sessionName, windowName) {
+    const result = runTmux(["kill-window", "-t", `${sessionName}:${windowName}`]);
+    if (result.exitCode !== 0 && !result.stderr.includes("can't find window")) {
+      throw new Error(`kill tmux window ${sessionName}:${windowName} failed: ${result.stderr}`);
     }
   }
+  createWindow(opts) {
+    const args = ["new-window", "-d", "-t", opts.sessionName, "-n", opts.windowName, "-c", opts.cwd];
+    if (opts.command)
+      args.push(opts.command);
+    assertTmuxOk(args, `create tmux window ${opts.sessionName}:${opts.windowName}`);
+  }
+  splitWindow(opts) {
+    const args = ["split-window", "-t", opts.target, opts.split === "right" ? "-h" : "-v", "-c", opts.cwd];
+    if (opts.sizePct !== undefined)
+      args.push("-l", `${opts.sizePct}%`);
+    if (opts.command)
+      args.push(opts.command);
+    assertTmuxOk(args, `split tmux window at ${opts.target}`);
+  }
+  setWindowOption(sessionName, windowName, option, value) {
+    assertTmuxOk(["set-window-option", "-t", `${sessionName}:${windowName}`, option, value], `set tmux option ${option} on ${sessionName}:${windowName}`);
+  }
+  runCommand(target, command) {
+    assertTmuxOk(["send-keys", "-t", target, "-l", "--", command], `send tmux command to ${target}`);
+    assertTmuxOk(["send-keys", "-t", target, "C-m"], `submit tmux command on ${target}`);
+  }
+  selectPane(target) {
+    assertTmuxOk(["select-pane", "-t", target], `select tmux pane ${target}`);
+  }
+  listWindows() {
+    const output = assertTmuxOk(["list-windows", "-a", "-F", "#{session_name}\t#{window_name}\t#{window_panes}"], "list tmux windows");
+    return parseWindowSummaries(output);
+  }
+}
+
+// backend/src/lib/http.ts
+function jsonResponse(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function errorResponse(message, status = 500) {
+  return jsonResponse({ error: message }, status);
+}
+
+// backend/src/services/dashboard-activity.ts
+var ACTIVITY_TIMEOUT_MS = 15000;
+var lastActivityAt = Date.now();
+function touchDashboardActivity() {
+  lastActivityAt = Date.now();
+}
+function hasRecentDashboardActivity() {
+  return Date.now() - lastActivityAt < ACTIVITY_TIMEOUT_MS;
 }
+
+// backend/src/domain/policies.ts
+var INVALID_BRANCH_CHARS_RE = /[~^:?*\[\]\\]+/g;
+var UNSAFE_ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 function sanitizeBranchName(raw) {
-  return raw.toLowerCase().replace(/\s+/g, "-").replace(/[~^:?*\[\]\\]+/g, "").replace(/@\{/g, "").replace(/\.{2,}/g, ".").replace(/\/{2,}/g, "/").replace(/-{2,}/g, "-").replace(/^[.\-/]+|[.\-/]+$/g, "").replace(/\.lock$/i, "");
+  return raw.toLowerCase().replace(/\s+/g, "-").replace(INVALID_BRANCH_CHARS_RE, "").replace(/@\{/g, "").replace(/\.{2,}/g, ".").replace(/\/{2,}/g, "/").replace(/-{2,}/g, "-").replace(/^[.\-/]+|[.\-/]+$/g, "").replace(/\.lock$/i, "");
+}
+function isValidBranchName(raw) {
+  return raw.length > 0 && sanitizeBranchName(raw) === raw;
+}
+function isValidEnvKey2(key) {
+  return UNSAFE_ENV_KEY_RE.test(key);
 }
-function randomName(len) {
-  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
-  let result = "";
-  for (let i = 0;i < len; i++) {
-    result += chars[Math.floor(Math.random() * chars.length)];
+function allocateServicePorts(existingMetas, services) {
+  const allocatable = services.filter((service) => service.portStart != null);
+  if (allocatable.length === 0)
+    return {};
+  const reference = allocatable[0];
+  const referenceStart = reference.portStart;
+  const referenceStep = reference.portStep ?? 1;
+  const occupiedSlots = new Set;
+  for (const meta of existingMetas) {
+    const port = meta.allocatedPorts[reference.portEnv];
+    if (!Number.isInteger(port) || port < referenceStart)
+      continue;
+    const diff = port - referenceStart;
+    if (diff % referenceStep !== 0)
+      continue;
+    occupiedSlots.add(diff / referenceStep);
+  }
+  let slot = 1;
+  while (occupiedSlots.has(slot))
+    slot += 1;
+  const result = {};
+  for (const service of allocatable) {
+    const start = service.portStart;
+    const step = service.portStep ?? 1;
+    result[service.portEnv] = start + slot * step;
   }
   return result;
 }
-function parseBranchFromOutput(output) {
-  const match = output.match(/branch:\s*(\S+)/i);
-  return match?.[1] ?? null;
-}
-async function initWorktreeEnv(branch, opts) {
-  const profile = opts?.profile ?? "default";
-  const agent = opts?.agent ?? "claude";
-  const porcelainResult = Bun.spawnSync(["git", "worktree", "list", "--porcelain"], { stdout: "pipe", stderr: "pipe" });
-  const worktreeMap = parseWorktreePorcelain(new TextDecoder().decode(porcelainResult.stdout));
-  const wtDir = worktreeMap.get(branch) ?? null;
-  if (!wtDir)
-    return;
-  const existingEnv = await readEnvLocal(wtDir);
-  const allPaths = [...worktreeMap.values()];
-  const existingEnvs = await readAllWorktreeEnvs(allPaths, wtDir);
-  const portAssignments = opts?.services ? allocatePorts(existingEnvs, opts.services) : {};
-  const defaults = { ...portAssignments, PROFILE: profile, AGENT: agent, ...opts?.envOverrides };
-  const toWrite = {};
-  for (const [key, value] of Object.entries(defaults)) {
-    if (!existingEnv[key])
-      toWrite[key] = value;
-  }
-  if (Object.keys(toWrite).length > 0) {
-    await writeEnvLocal(wtDir, toWrite);
-  }
-  const rpcPort = Bun.env.BACKEND_PORT || "5111";
-  const hooksConfig = {
-    hooks: {
-      Stop: [{ hooks: [{ type: "command", command: `WORKMUX_RPC_PORT=${rpcPort} ~/.config/workmux/hooks/notify-stop.sh`, async: true }] }],
-      PostToolUse: [{ matcher: "Bash", hooks: [{ type: "command", command: `WORKMUX_RPC_PORT=${rpcPort} ~/.config/workmux/hooks/notify-pr.sh`, async: true }] }]
-    }
-  };
-  await mkdir2(`${wtDir}/.claude`, { recursive: true });
-  const settingsPath = `${wtDir}/.claude/settings.local.json`;
-  let existing = {};
-  try {
-    const file = Bun.file(settingsPath);
-    if (await file.exists()) {
-      existing = await file.json();
-    }
-  } catch {}
-  const existingHooks = existing.hooks ?? {};
-  const merged = { ...existing, hooks: { ...existingHooks, ...hooksConfig.hooks } };
-  await Bun.write(settingsPath, JSON.stringify(merged, null, 2) + `
-`);
-}
-async function addWorktree(rawBranch, opts) {
-  ensureTmux();
-  const profile = opts?.profile ?? "default";
-  const agent = opts?.agent ?? "claude";
-  const profileConfig = opts?.profileConfig;
-  const isSandbox = opts?.isSandbox === true;
-  const hasSystemPrompt = !!profileConfig?.systemPrompt;
-  const args = ["workmux", "add", "-b"];
-  let branch = "";
-  let useAutoName = false;
-  if (isSandbox) {
-    args.push("-C");
-    if (rawBranch) {
-      branch = sanitizeBranchName(rawBranch);
-      if (!branch) {
-        return { ok: false, error: `"${rawBranch}" is not a valid branch name after sanitization` };
-      }
-    } else {
-      branch = randomName(8);
-    }
-    args.push(branch);
-  } else {
-    if (hasSystemPrompt) {
-      args.push("-C");
-    }
-    if (opts?.prompt)
-      args.push("-p", opts.prompt);
-    useAutoName = !rawBranch && !!opts?.prompt && !!opts?.autoName;
-    if (rawBranch) {
-      branch = sanitizeBranchName(rawBranch);
-      if (!branch) {
-        return { ok: false, error: `"${rawBranch}" is not a valid branch name after sanitization` };
-      }
-      args.push(branch);
-    } else if (useAutoName) {
-      args.push("-A");
-    } else {
-      branch = randomName(8);
-      args.push(branch);
-    }
-  }
-  log.debug(`[workmux:add] running: ${args.join(" ")}`);
-  const execResult = await tryExec(args, opts?.envOverrides);
-  if (!execResult.ok)
-    return { ok: false, error: execResult.error };
-  const result = execResult.stdout;
-  if (useAutoName) {
-    const parsed = parseBranchFromOutput(result);
-    if (!parsed) {
-      return { ok: false, error: `Failed to parse branch name from workmux output: ${JSON.stringify(result)}` };
-    }
-    branch = parsed;
-  }
-  const windowTarget = `wm-${branch}`;
-  await initWorktreeEnv(branch, { profile, agent, services: opts?.services, envOverrides: opts?.envOverrides });
-  const porcelainResult = Bun.spawnSync(["git", "worktree", "list", "--porcelain"], { stdout: "pipe", stderr: "pipe" });
-  const worktreeMap = parseWorktreePorcelain(new TextDecoder().decode(porcelainResult.stdout));
-  const wtDir = worktreeMap.get(branch) ?? null;
-  const env = wtDir ? await readEnvLocal(wtDir) : {};
-  log.debug(`[workmux:add] branch=${branch} dir=${wtDir ?? "(not found)"} env=${JSON.stringify(env)}`);
-  if (hasSystemPrompt && profileConfig) {
-    const paneCountResult = Bun.spawnSync(["tmux", "list-panes", "-t", windowTarget, "-F", "#{pane_index}"], { stdout: "pipe", stderr: "pipe" });
-    if (paneCountResult.exitCode === 0) {
-      const paneIds = new TextDecoder().decode(paneCountResult.stdout).trim().split(`
-`);
-      for (let i = paneIds.length - 1;i >= 1; i--) {
-        Bun.spawnSync(["tmux", "kill-pane", "-t", `${windowTarget}.${paneIds[i]}`]);
-      }
-    }
-    let containerName2;
-    if (isSandbox && opts?.sandboxConfig && wtDir) {
-      const mainRepoDir = opts.mainRepoDir ?? process.cwd();
-      containerName2 = await launchContainer({
-        branch,
-        wtDir,
-        mainRepoDir,
-        sandboxConfig: opts.sandboxConfig,
-        services: opts.services ?? [],
-        env
-      });
-    }
-    const agentCmd = buildAgentCmd(env, agent, profileConfig, isSandbox, isSandbox ? opts?.prompt : undefined);
-    if (containerName2) {
-      const dockerExec = `docker exec -it -w ${wtDir} ${containerName2} bash`;
-      Bun.spawnSync(["tmux", "send-keys", "-t", `${windowTarget}.0`, dockerExec, "Enter"]);
-      await Bun.sleep(500);
-      const entrypointThenAgent = `/usr/local/bin/entrypoint.sh && ${agentCmd}`;
-      log.debug(`[workmux] sending to ${windowTarget}.0:
-${entrypointThenAgent}`);
-      Bun.spawnSync(["tmux", "send-keys", "-t", `${windowTarget}.0`, entrypointThenAgent, "Enter"]);
-      Bun.spawnSync(["tmux", "split-window", "-h", "-t", `${windowTarget}.0`, "-l", "25%", "-c", wtDir ?? process.cwd()]);
-    } else {
-      log.debug(`[workmux] sending command to ${windowTarget}.0:
-${agentCmd}`);
-      Bun.spawnSync(["tmux", "send-keys", "-t", `${windowTarget}.0`, agentCmd, "Enter"]);
-      Bun.spawnSync(["tmux", "split-window", "-h", "-t", `${windowTarget}.0`, "-l", "25%", "-c", wtDir ?? process.cwd()]);
+
+// backend/src/services/auto-name-service.ts
+var BRANCH_NAME_SCHEMA = {
+  type: "object",
+  properties: {
+    branch_name: {
+      type: "string",
+      description: "A lowercase kebab-case git branch name with no prefix"
     }
-    Bun.spawnSync(["tmux", "select-pane", "-t", `${windowTarget}.0`]);
-  }
-  return { ok: true, branch, output: result };
+  },
+  required: ["branch_name"],
+  additionalProperties: false
+};
+var GEMINI_BRANCH_NAME_SCHEMA = {
+  ...BRANCH_NAME_SCHEMA,
+  propertyOrdering: ["branch_name"]
+};
+var DEFAULT_SYSTEM_PROMPT = [
+  "Generate a concise git branch name from the task description.",
+  "Return only the branch name.",
+  "Use lowercase kebab-case.",
+  "Do not include quotes, code fences, or prefixes like feature/ or fix/."
+].join(" ");
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-async function removeWorktree(name) {
-  log.debug(`[workmux:rm] running: workmux rm --force ${name}`);
-  await removeContainer(name);
-  const result = await tryExec(["workmux", "rm", "--force", name]);
-  if (!result.ok)
-    return result;
-  return { ok: true, output: result.stdout };
+function buildPrompt(task) {
+  return `Task description:
+${task.trim()}`;
 }
-var TMUX_TIMEOUT_MS = 5000;
-async function tmuxExec(args, opts = {}) {
-  const proc = Bun.spawn(args, {
-    stdin: opts.stdin ?? "ignore",
-    stdout: "ignore",
-    stderr: "pipe"
-  });
-  const timeout = Bun.sleep(TMUX_TIMEOUT_MS).then(() => {
-    proc.kill();
-    return "timeout";
-  });
-  const result = await Promise.race([proc.exited, timeout]);
-  if (result === "timeout") {
-    return { exitCode: -1, stderr: "timed out after 5s (agent may be busy)" };
+function parseBranchNamePayload(raw) {
+  if (!isRecord2(raw) || typeof raw.branch_name !== "string") {
+    throw new Error("Auto-name response did not include branch_name");
   }
-  const stderr = (await new Response(proc.stderr).text()).trim();
-  return { exitCode: result, stderr };
+  return raw.branch_name;
 }
-async function sendPrompt(branch, text, pane = 0, preamble) {
-  const windowName = `wm-${branch}`;
-  const session = await findWorktreeSession(windowName);
-  if (!session) {
-    return { ok: false, error: `tmux window "${windowName}" not found` };
+function parseJsonText(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`Auto-name response was not valid JSON: ${text}`);
   }
-  const target = `${session}:${windowName}.${pane}`;
-  log.debug(`[send:${branch}] target=${target} textBytes=${text.length}${preamble ? ` preamble=${preamble.length}b` : ""}`);
-  if (preamble) {
-    const { exitCode, stderr } = await tmuxExec(["tmux", "send-keys", "-t", target, "-l", "--", preamble]);
-    if (exitCode !== 0) {
-      return { ok: false, error: `send-keys preamble failed${stderr ? `: ${stderr}` : ""}` };
+}
+function normalizeGeneratedBranchName(raw) {
+  let branch = raw.trim();
+  branch = branch.replace(/^```[\w-]*\s*/, "").replace(/\s*```$/, "");
+  branch = branch.split(/\r?\n/)[0]?.trim() ?? "";
+  branch = branch.replace(/^branch(?:\s+name)?\s*:\s*/i, "");
+  branch = branch.replace(/^["'`]+|["'`]+$/g, "");
+  branch = branch.toLowerCase();
+  branch = branch.replace(/[^a-z0-9._/-]+/g, "-");
+  branch = branch.replace(/[/.]+/g, "-");
+  branch = branch.replace(/-+/g, "-");
+  branch = branch.replace(/^-+|-+$/g, "");
+  if (!branch) {
+    throw new Error("Auto-name model returned an empty branch name");
+  }
+  if (!isValidBranchName(branch)) {
+    throw new Error(`Auto-name model returned an invalid branch name: ${branch}`);
+  }
+  return branch;
+}
+function resolveAutoNameModel(modelSpec) {
+  const trimmed = modelSpec.trim();
+  const slashIndex = trimmed.indexOf("/");
+  if (slashIndex > 0) {
+    const provider = trimmed.slice(0, slashIndex);
+    const model = trimmed.slice(slashIndex + 1).trim().replace(/^models\//, "");
+    if (!model) {
+      throw new Error(`Invalid auto_name model: ${modelSpec}`);
+    }
+    if (provider === "anthropic" || provider === "google" || provider === "openai") {
+      return { provider, model };
+    }
+    if (provider === "gemini") {
+      return { provider: "google", model };
     }
   }
-  const cleaned = text.replace(/\0/g, "");
-  const bufName = `wm-prompt-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
-  const load = await tmuxExec(["tmux", "load-buffer", "-b", bufName, "-"], { stdin: new TextEncoder().encode(cleaned) });
-  if (load.exitCode !== 0) {
-    return { ok: false, error: `load-buffer failed${load.stderr ? `: ${load.stderr}` : ""}` };
+  if (trimmed.startsWith("claude-")) {
+    return { provider: "anthropic", model: trimmed };
   }
-  const paste = await tmuxExec(["tmux", "paste-buffer", "-b", bufName, "-t", target, "-d"]);
-  if (paste.exitCode !== 0) {
-    return { ok: false, error: `paste-buffer failed${paste.stderr ? `: ${paste.stderr}` : ""}` };
+  if (trimmed.startsWith("gemini-") || trimmed.startsWith("models/gemini-")) {
+    return { provider: "google", model: trimmed.replace(/^models\//, "") };
   }
-  return { ok: true };
+  if (/^(gpt-|chatgpt-|o\d)/.test(trimmed)) {
+    return { provider: "openai", model: trimmed };
+  }
+  throw new Error(`Unsupported auto_name model provider for ${modelSpec}. Use an anthropic/, gemini/, google/, or openai/ prefix, or a known model name.`);
 }
-async function findWorktreeSession(windowName) {
-  const proc = Bun.spawn(["tmux", "list-windows", "-a", "-F", "#{session_name}:#{window_name}"], { stdout: "pipe", stderr: "pipe" });
-  if (await proc.exited !== 0)
-    return null;
-  const output = (await new Response(proc.stdout).text()).trim();
-  if (!output)
+function getSystemPrompt(config) {
+  return config.systemPrompt?.trim() || DEFAULT_SYSTEM_PROMPT;
+}
+function extractAnthropicText(raw) {
+  if (!isRecord2(raw) || !Array.isArray(raw.content))
     return null;
-  for (const line of output.split(`
-`)) {
-    const colonIdx = line.indexOf(":");
-    if (colonIdx === -1)
+  for (const item of raw.content) {
+    if (!isRecord2(item))
       continue;
-    const session = line.slice(0, colonIdx);
-    const name = line.slice(colonIdx + 1);
-    if (name === windowName)
-      return session;
+    if (item.type === "text" && typeof item.text === "string" && item.text.trim()) {
+      return item.text;
+    }
   }
   return null;
 }
-async function openWorktree(name) {
-  const result = await tryExec(["workmux", "open", name]);
-  if (!result.ok)
-    return result;
-  return { ok: true, output: result.stdout };
-}
-async function checkDirty(dir) {
-  const [status, ahead] = await Promise.all([
-    (async () => {
-      const proc = Bun.spawn(["git", "status", "--porcelain"], {
-        cwd: dir,
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      const output = await new Response(proc.stdout).text();
-      await proc.exited;
-      return output.trim().length > 0;
-    })(),
-    (async () => {
-      const proc = Bun.spawn(["git", "rev-list", "--count", "@{u}..HEAD"], {
-        cwd: dir,
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      const output = await new Response(proc.stdout).text();
-      const exitCode = await proc.exited;
-      if (exitCode !== 0)
-        return false;
-      return (parseInt(output.trim(), 10) || 0) > 0;
-    })()
-  ]);
-  return status || ahead;
+function extractGoogleText(raw) {
+  if (!isRecord2(raw) || !Array.isArray(raw.candidates))
+    return null;
+  for (const candidate of raw.candidates) {
+    if (!isRecord2(candidate) || !isRecord2(candidate.content) || !Array.isArray(candidate.content.parts))
+      continue;
+    for (const part of candidate.content.parts) {
+      if (isRecord2(part) && typeof part.text === "string" && part.text.trim()) {
+        return part.text;
+      }
+    }
+  }
+  return null;
 }
-async function cleanupStaleWindows(activeBranches, worktreeBaseDir) {
-  try {
-    const proc = Bun.spawn(["tmux", "list-panes", "-a", "-F", "#{session_name}:#{window_name} #{pane_current_path}"], { stdout: "pipe", stderr: "pipe" });
-    if (await proc.exited !== 0)
-      return;
-    const output = (await new Response(proc.stdout).text()).trim();
-    if (!output)
-      return;
-    const toKill = [];
-    const seen = new Set;
-    for (const line of output.split(`
-`)) {
-      const spaceIdx = line.indexOf(" ");
-      if (spaceIdx === -1)
-        continue;
-      const target = line.slice(0, spaceIdx);
-      const panePath = line.slice(spaceIdx + 1);
-      const colonIdx = target.indexOf(":");
-      if (colonIdx === -1)
-        continue;
-      const session = target.slice(0, colonIdx);
-      const windowName = target.slice(colonIdx + 1);
-      if (!windowName.startsWith("wm-"))
-        continue;
-      if (seen.has(windowName))
-        continue;
-      const branch = windowName.slice(3);
-      if (activeBranches.has(branch))
-        continue;
-      if (!panePath.startsWith(worktreeBaseDir))
+function extractOpenAiText(raw) {
+  if (!isRecord2(raw))
+    return null;
+  if (typeof raw.output_text === "string" && raw.output_text.trim()) {
+    return raw.output_text;
+  }
+  if (!Array.isArray(raw.output))
+    return null;
+  for (const item of raw.output) {
+    if (!isRecord2(item) || !Array.isArray(item.content))
+      continue;
+    for (const content of item.content) {
+      if (!isRecord2(content))
         continue;
-      toKill.push({ session, windowName });
-      seen.add(windowName);
-    }
-    await Promise.all(toKill.map(async ({ session, windowName }) => {
-      log.info(`[cleanup] killing stale tmux window "${windowName}" (no matching worktree)`);
-      const kill = Bun.spawn(["tmux", "kill-window", "-t", `${session}:${windowName}`], {
-        stdout: "ignore",
-        stderr: "ignore"
-      });
-      await kill.exited;
-    }));
-  } catch (err) {
-    log.warn(`[cleanup] cleanupStaleWindows failed: ${err instanceof Error ? err.message : String(err)}`);
+      if (typeof content.text === "string" && content.text.trim()) {
+        return content.text;
+      }
+    }
   }
+  return null;
 }
-async function mergeWorktree(name) {
-  log.debug(`[workmux:merge] running: workmux merge ${name}`);
-  await removeContainer(name);
-  const result = await tryExec(["workmux", "merge", name]);
-  if (!result.ok)
-    return result;
-  return { ok: true, output: result.stdout };
+async function readErrorBody(response) {
+  const text = (await response.text()).trim();
+  return text || `HTTP ${response.status}`;
 }
 
-// backend/src/terminal.ts
-var textDecoder = new TextDecoder;
-var textEncoder = new TextEncoder;
-var DASH_PORT = Bun.env.BACKEND_PORT || "5111";
-var SESSION_PREFIX = `wm-dash-${DASH_PORT}-`;
-var MAX_SCROLLBACK_BYTES = 1 * 1024 * 1024;
-var sessions = new Map;
-var sessionCounter = 0;
-function groupedName() {
-  return `${SESSION_PREFIX}${++sessionCounter}`;
+class AutoNameService {
+  fetchImpl;
+  anthropicApiKey;
+  geminiApiKey;
+  openaiApiKey;
+  constructor(deps = {}) {
+    this.fetchImpl = deps.fetchImpl ?? fetch;
+    this.anthropicApiKey = deps.anthropicApiKey ?? Bun.env.ANTHROPIC_API_KEY;
+    this.geminiApiKey = deps.geminiApiKey ?? Bun.env.GEMINI_API_KEY;
+    this.openaiApiKey = deps.openaiApiKey ?? Bun.env.OPENAI_API_KEY;
+  }
+  async generateBranchName(config, task) {
+    const prompt = task.trim();
+    if (!prompt) {
+      throw new Error("Auto-name requires a prompt");
+    }
+    const resolved = resolveAutoNameModel(config.model);
+    const branchName = resolved.provider === "anthropic" ? await this.generateWithAnthropic(resolved.model, getSystemPrompt(config), prompt) : resolved.provider === "google" ? await this.generateWithGoogle(resolved.model, getSystemPrompt(config), prompt) : await this.generateWithOpenAI(resolved.model, getSystemPrompt(config), prompt);
+    return normalizeGeneratedBranchName(branchName);
+  }
+  async generateWithAnthropic(model, systemPrompt, task) {
+    if (!this.anthropicApiKey) {
+      throw new Error("ANTHROPIC_API_KEY is required for auto_name with Anthropic models");
+    }
+    const response = await this.fetchImpl("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-api-key": this.anthropicApiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model,
+        system: systemPrompt,
+        max_tokens: 64,
+        messages: [{ role: "user", content: buildPrompt(task) }],
+        output_config: {
+          format: {
+            type: "json_schema",
+            schema: BRANCH_NAME_SCHEMA
+          }
+        }
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Anthropic auto-name request failed: ${await readErrorBody(response)}`);
+    }
+    const json = await response.json();
+    if (isRecord2(json) && json.stop_reason === "refusal") {
+      throw new Error("Anthropic auto-name request was refused");
+    }
+    if (isRecord2(json) && json.stop_reason === "max_tokens") {
+      throw new Error("Anthropic auto-name response hit max_tokens before completing");
+    }
+    const text = extractAnthropicText(json);
+    if (!text) {
+      throw new Error("Anthropic auto-name response did not include text");
+    }
+    return parseBranchNamePayload(parseJsonText(text));
+  }
+  async generateWithGoogle(model, systemPrompt, task) {
+    if (!this.geminiApiKey) {
+      throw new Error("GEMINI_API_KEY is required for auto_name with Gemini models");
+    }
+    const response = await this.fetchImpl(`https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model)}:generateContent`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-goog-api-key": this.geminiApiKey
+      },
+      body: JSON.stringify({
+        systemInstruction: {
+          parts: [{ text: systemPrompt }]
+        },
+        contents: [
+          {
+            role: "user",
+            parts: [{ text: buildPrompt(task) }]
+          }
+        ],
+        generationConfig: {
+          responseMimeType: "application/json",
+          responseJsonSchema: GEMINI_BRANCH_NAME_SCHEMA
+        }
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Google auto-name request failed: ${await readErrorBody(response)}`);
+    }
+    const json = await response.json();
+    const text = extractGoogleText(json);
+    if (!text) {
+      throw new Error("Google auto-name response did not include text");
+    }
+    return parseBranchNamePayload(parseJsonText(text));
+  }
+  async generateWithOpenAI(model, systemPrompt, task) {
+    if (!this.openaiApiKey) {
+      throw new Error("OPENAI_API_KEY is required for auto_name with OpenAI models");
+    }
+    const response = await this.fetchImpl("https://api.openai.com/v1/responses", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${this.openaiApiKey}`
+      },
+      body: JSON.stringify({
+        model,
+        input: [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: buildPrompt(task) }
+        ],
+        max_output_tokens: 64,
+        text: {
+          format: {
+            type: "json_schema",
+            name: "branch_name_response",
+            strict: true,
+            schema: BRANCH_NAME_SCHEMA
+          }
+        }
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`OpenAI auto-name request failed: ${await readErrorBody(response)}`);
+    }
+    const json = await response.json();
+    if (isRecord2(json) && Array.isArray(json.output)) {
+      for (const item of json.output) {
+        if (!isRecord2(item) || !Array.isArray(item.content))
+          continue;
+        for (const content of item.content) {
+          if (isRecord2(content) && content.type === "refusal" && typeof content.refusal === "string") {
+            throw new Error(`OpenAI auto-name request was refused: ${content.refusal}`);
+          }
+        }
+      }
+    }
+    const text = extractOpenAiText(json);
+    if (!text) {
+      throw new Error("OpenAI auto-name response did not include text");
+    }
+    return parseBranchNamePayload(parseJsonText(text));
+  }
 }
-function buildAttachCmd(opts) {
-  const windowTarget = `wm-${opts.worktreeName}`;
-  const paneTarget = `${opts.gName}:${windowTarget}.${opts.initialPane ?? 0}`;
-  return [
-    `tmux new-session -d -s "${opts.gName}" -t "${opts.tmuxSession}"`,
-    `tmux set-option -t "${opts.tmuxSession}" window-size latest`,
-    `tmux set-option -t "${opts.gName}" mouse on`,
-    `tmux set-option -t "${opts.gName}" set-clipboard on`,
-    `tmux select-window -t "${opts.gName}:${windowTarget}"`,
-    `if [ "$(tmux display-message -t '${opts.gName}:${windowTarget}' -p '#{window_zoomed_flag}')" = "1" ]; then tmux resize-pane -Z -t '${opts.gName}:${windowTarget}'; fi`,
-    `tmux select-pane -t "${paneTarget}"`,
-    ...opts.initialPane !== undefined ? [`tmux resize-pane -Z -t "${paneTarget}"`] : [],
-    `stty rows ${opts.rows} cols ${opts.cols}`,
-    `exec tmux attach-session -t "${opts.gName}"`
-  ].join(" && ");
+
+// backend/src/services/linear-service.ts
+var ASSIGNED_ISSUES_QUERY = `
+  query AssignedIssues {
+    viewer {
+      assignedIssues(
+        filter: { state: { type: { nin: ["completed", "canceled"] } } }
+        orderBy: updatedAt
+        first: 50
+      ) {
+        nodes {
+          id
+          identifier
+          title
+          description
+          priority
+          priorityLabel
+          url
+          branchName
+          dueDate
+          updatedAt
+          state { name color type }
+          team { name key }
+          labels { nodes { name color } }
+          project { name }
+        }
+      }
+    }
+  }
+`;
+function parseIssuesResponse(raw) {
+  if (raw.errors && raw.errors.length > 0) {
+    return { ok: false, error: raw.errors.map((e) => e.message).join("; ") };
+  }
+  if (!raw.data) {
+    return { ok: false, error: "No data in response" };
+  }
+  const nodes = raw.data.viewer.assignedIssues.nodes;
+  const issues = nodes.map((n) => ({
+    id: n.id,
+    identifier: n.identifier,
+    title: n.title,
+    description: n.description,
+    priority: n.priority,
+    priorityLabel: n.priorityLabel,
+    url: n.url,
+    branchName: n.branchName,
+    dueDate: n.dueDate,
+    updatedAt: n.updatedAt,
+    state: n.state,
+    team: n.team,
+    labels: n.labels.nodes,
+    project: n.project?.name ?? null
+  }));
+  return { ok: true, data: issues };
 }
-async function asyncTmux(args) {
-  const proc = Bun.spawn(args, { stdin: "ignore", stdout: "ignore", stderr: "pipe" });
-  const exitCode = await proc.exited;
-  const stderr = (await new Response(proc.stderr).text()).trim();
-  return { exitCode, stderr };
+function branchMatchesIssue(worktreeBranch, issueBranchName) {
+  if (!worktreeBranch || !issueBranchName)
+    return false;
+  if (worktreeBranch === issueBranchName)
+    return true;
+  const issueSlashIdx = issueBranchName.indexOf("/");
+  if (issueSlashIdx !== -1) {
+    const suffix = issueBranchName.slice(issueSlashIdx + 1);
+    if (worktreeBranch === suffix)
+      return true;
+  }
+  const wtSlashIdx = worktreeBranch.indexOf("/");
+  if (wtSlashIdx !== -1) {
+    const wtSuffix = worktreeBranch.slice(wtSlashIdx + 1);
+    if (wtSuffix === issueBranchName)
+      return true;
+    if (issueSlashIdx !== -1 && wtSuffix === issueBranchName.slice(issueSlashIdx + 1))
+      return true;
+  }
+  return false;
 }
-function cleanupStaleSessions() {
+var CACHE_TTL_MS = 300000;
+var issueCache = null;
+async function fetchAssignedIssues() {
+  const apiKey = Bun.env.LINEAR_API_KEY;
+  if (!apiKey) {
+    return { ok: false, error: "LINEAR_API_KEY not set" };
+  }
+  const now = Date.now();
+  if (issueCache && now < issueCache.expiry) {
+    return issueCache.data;
+  }
   try {
-    const result = Bun.spawnSync(["tmux", "list-sessions", "-F", "#{session_name}"], { stdout: "pipe", stderr: "pipe" });
-    if (result.exitCode !== 0)
-      return;
-    const lines = textDecoder.decode(result.stdout).trim().split(`
+    const res = await fetch("https://api.linear.app/graphql", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: apiKey
+      },
+      body: JSON.stringify({ query: ASSIGNED_ISSUES_QUERY })
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      const result2 = { ok: false, error: `Linear API ${res.status}: ${text.slice(0, 200)}` };
+      return result2;
+    }
+    const json = await res.json();
+    const result = parseIssuesResponse(json);
+    if (result.ok) {
+      issueCache = { data: result, expiry: now + CACHE_TTL_MS };
+      log.debug(`[linear] fetched ${result.data.length} assigned issues`);
+    } else {
+      log.error(`[linear] GraphQL error: ${result.error}`);
+    }
+    return result;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log.error(`[linear] fetch failed: ${msg}`);
+    return { ok: false, error: msg };
+  }
+}
+
+// backend/src/services/notification-service.ts
+function buildNotification(event, id, timestamp) {
+  switch (event.type) {
+    case "agent_stopped":
+      return {
+        id,
+        branch: event.branch,
+        type: "agent_stopped",
+        message: `Agent stopped on ${event.branch}`,
+        timestamp
+      };
+    case "pr_opened":
+      return {
+        id,
+        branch: event.branch,
+        type: "pr_opened",
+        message: `PR opened on ${event.branch}`,
+        url: event.url,
+        timestamp
+      };
+    case "runtime_error":
+      return {
+        id,
+        branch: event.branch,
+        type: "runtime_error",
+        message: `Runtime error on ${event.branch}: ${event.message}`,
+        timestamp
+      };
+    default:
+      return null;
+  }
+}
+
+class NotificationService {
+  maxItems;
+  notifications = [];
+  sseClients = new Set;
+  nextId = 1;
+  constructor(maxItems = 50) {
+    this.maxItems = maxItems;
+  }
+  list() {
+    return [...this.notifications];
+  }
+  dismiss(id) {
+    const index = this.notifications.findIndex((notification) => notification.id === id);
+    if (index === -1)
+      return false;
+    this.notifications.splice(index, 1);
+    this.broadcast("dismiss", { id });
+    return true;
+  }
+  recordEvent(event, now = () => new Date) {
+    const notification = buildNotification(event, this.nextId, now().getTime());
+    if (!notification)
+      return null;
+    this.nextId += 1;
+    this.notifications.push(notification);
+    while (this.notifications.length > this.maxItems) {
+      this.notifications.shift();
+    }
+    this.broadcast("notification", notification);
+    return notification;
+  }
+  stream() {
+    let controllerRef = null;
+    const stream = new ReadableStream({
+      start: (controller) => {
+        controllerRef = controller;
+        this.sseClients.add(controller);
+        for (const notification of this.notifications) {
+          controller.enqueue(this.formatSse("initial", notification));
+        }
+      },
+      cancel: () => {
+        if (controllerRef)
+          this.sseClients.delete(controllerRef);
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  }
+  formatSse(event, data) {
+    return new TextEncoder().encode(`event: ${event}
+data: ${JSON.stringify(data)}
+
 `);
-    for (const name of lines) {
-      if (name.startsWith(SESSION_PREFIX)) {
-        Bun.spawnSync(["tmux", "kill-session", "-t", name]);
+  }
+  broadcast(event, data) {
+    const encoded = this.formatSse(event, data);
+    for (const controller of this.sseClients) {
+      try {
+        controller.enqueue(encoded);
+      } catch {
+        this.sseClients.delete(controller);
       }
     }
-  } catch {}
+  }
 }
-function killTmuxSession(name) {
-  const result = Bun.spawnSync(["tmux", "kill-session", "-t", name], { stderr: "pipe" });
-  if (result.exitCode !== 0) {
-    const stderr = textDecoder.decode(result.stderr).trim();
-    if (!stderr.includes("can't find session")) {
-      log.warn(`[term] killTmuxSession(${name}) exit=${result.exitCode} ${stderr}`);
+
+// backend/src/services/lifecycle-service.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { mkdir as mkdir4 } from "fs/promises";
+import { dirname as dirname3, resolve as resolve3 } from "path";
+
+// backend/src/adapters/agent-runtime.ts
+import { chmod as chmod2, mkdir as mkdir3 } from "fs/promises";
+import { dirname as dirname2, join as join3 } from "path";
+
+// backend/src/adapters/fs.ts
+import { mkdir as mkdir2 } from "fs/promises";
+import { join as join2 } from "path";
+var SAFE_ENV_VALUE_RE = /^[A-Za-z0-9_./:@%+=,-]+$/;
+function stringifyAllocatedPorts(ports) {
+  const entries = Object.entries(ports).map(([key, value]) => [key, String(value)]);
+  return Object.fromEntries(entries);
+}
+function quoteEnvValue(value) {
+  if (value.length > 0 && SAFE_ENV_VALUE_RE.test(value))
+    return value;
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function getWorktreeStoragePaths(gitDir) {
+  const webmuxDir = join2(gitDir, "webmux");
+  return {
+    gitDir,
+    webmuxDir,
+    metaPath: join2(webmuxDir, "meta.json"),
+    runtimeEnvPath: join2(webmuxDir, "runtime.env"),
+    controlEnvPath: join2(webmuxDir, "control.env"),
+    prsPath: join2(webmuxDir, "prs.json")
+  };
+}
+async function ensureWorktreeStorageDirs(gitDir) {
+  const paths = getWorktreeStoragePaths(gitDir);
+  await mkdir2(paths.webmuxDir, { recursive: true });
+  return paths;
+}
+async function readWorktreeMeta(gitDir) {
+  const { metaPath } = getWorktreeStoragePaths(gitDir);
+  try {
+    return await Bun.file(metaPath).json();
+  } catch {
+    return null;
+  }
+}
+async function writeWorktreeMeta(gitDir, meta) {
+  const { metaPath } = await ensureWorktreeStorageDirs(gitDir);
+  await Bun.write(metaPath, JSON.stringify(meta, null, 2) + `
+`);
+}
+function buildRuntimeEnvMap(meta, extraEnv = {}) {
+  return {
+    ...meta.startupEnvValues,
+    ...stringifyAllocatedPorts(meta.allocatedPorts),
+    ...extraEnv,
+    WEBMUX_WORKTREE_ID: meta.worktreeId,
+    WEBMUX_BRANCH: meta.branch,
+    WEBMUX_PROFILE: meta.profile,
+    WEBMUX_AGENT: meta.agent,
+    WEBMUX_RUNTIME: meta.runtime
+  };
+}
+function buildControlEnvMap(input) {
+  return {
+    WEBMUX_CONTROL_URL: input.controlUrl,
+    WEBMUX_CONTROL_TOKEN: input.controlToken,
+    WEBMUX_WORKTREE_ID: input.worktreeId,
+    WEBMUX_BRANCH: input.branch
+  };
+}
+function renderEnvFile(env) {
+  const lines = Object.entries(env).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => `${key}=${quoteEnvValue(value)}`);
+  return lines.join(`
+`) + `
+`;
+}
+async function writeRuntimeEnv(gitDir, env) {
+  const { runtimeEnvPath } = await ensureWorktreeStorageDirs(gitDir);
+  await Bun.write(runtimeEnvPath, renderEnvFile(env));
+}
+async function writeControlEnv(gitDir, env) {
+  const { controlEnvPath } = await ensureWorktreeStorageDirs(gitDir);
+  await Bun.write(controlEnvPath, renderEnvFile(env));
+}
+function isRecord3(raw) {
+  return typeof raw === "object" && raw !== null && !Array.isArray(raw);
+}
+function isPrComment(raw) {
+  if (!isRecord3(raw))
+    return false;
+  return (raw.type === "comment" || raw.type === "inline") && typeof raw.author === "string" && typeof raw.body === "string" && typeof raw.createdAt === "string" && (raw.path === undefined || typeof raw.path === "string") && (raw.line === undefined || raw.line === null || typeof raw.line === "number") && (raw.diffHunk === undefined || typeof raw.diffHunk === "string") && (raw.isReply === undefined || typeof raw.isReply === "boolean");
+}
+function isCiCheck(raw) {
+  if (!isRecord3(raw))
+    return false;
+  return typeof raw.name === "string" && (raw.status === "pending" || raw.status === "success" || raw.status === "failed" || raw.status === "skipped") && typeof raw.url === "string" && (raw.runId === null || typeof raw.runId === "number");
+}
+function isPrEntry(raw) {
+  if (!isRecord3(raw))
+    return false;
+  return typeof raw.repo === "string" && typeof raw.number === "number" && (raw.state === "open" || raw.state === "closed" || raw.state === "merged") && typeof raw.url === "string" && typeof raw.updatedAt === "string" && (raw.ciStatus === "none" || raw.ciStatus === "pending" || raw.ciStatus === "success" || raw.ciStatus === "failed") && Array.isArray(raw.ciChecks) && raw.ciChecks.every((check) => isCiCheck(check)) && Array.isArray(raw.comments) && raw.comments.every((comment) => isPrComment(comment));
+}
+async function readWorktreePrs(gitDir) {
+  const { prsPath } = getWorktreeStoragePaths(gitDir);
+  try {
+    const raw = await Bun.file(prsPath).json();
+    return Array.isArray(raw) && raw.every((entry) => isPrEntry(entry)) ? raw : [];
+  } catch {
+    return [];
+  }
+}
+async function writeWorktreePrs(gitDir, prs) {
+  const { prsPath } = await ensureWorktreeStorageDirs(gitDir);
+  await Bun.write(prsPath, JSON.stringify(prs, null, 2) + `
+`);
+}
+
+// backend/src/adapters/agent-runtime.ts
+function shellQuote(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function buildAgentCtlScript() {
+  return `#!/usr/bin/env python3
+import argparse
+import json
+import re
+import sys
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+
+CONTROL_ENV_PATH = Path(__file__).resolve().with_name("control.env")
+
+
+def read_control_env():
+    env = {}
+    try:
+        content = CONTROL_ENV_PATH.read_text()
+    except OSError as error:
+        raise RuntimeError(f"failed to read control.env: {error}") from error
+
+    for raw_line in content.splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, value = line.split("=", 1)
+        if len(value) >= 2 and value.startswith("'") and value.endswith("'"):
+            value = value[1:-1].replace("'\\\\''", "'")
+        env[key] = value
+
+    return env
+
+
+def build_parser():
+    parser = argparse.ArgumentParser(prog="webmux-agentctl")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    subparsers.add_parser("agent-stopped")
+
+    status_changed = subparsers.add_parser("status-changed")
+    status_changed.add_argument("--lifecycle", choices=["starting", "running", "idle", "stopped"], required=True)
+
+    pr_opened = subparsers.add_parser("pr-opened")
+    pr_opened.add_argument("--url")
+
+    runtime_error = subparsers.add_parser("runtime-error")
+    runtime_error.add_argument("--message", required=True)
+
+    subparsers.add_parser("claude-user-prompt-submit")
+    subparsers.add_parser("claude-post-tool-use")
+
+    return parser
+
+
+def build_payload(command, args, control_env):
+    payload = {
+        "worktreeId": control_env["WEBMUX_WORKTREE_ID"],
+        "branch": control_env["WEBMUX_BRANCH"],
+    }
+
+    if command == "agent-stopped":
+        payload["type"] = "agent_stopped"
+        return payload
+    if command == "status-changed":
+        payload["type"] = "agent_status_changed"
+        payload["lifecycle"] = args.lifecycle
+        return payload
+    if command == "pr-opened":
+        payload["type"] = "pr_opened"
+        if args.url:
+            payload["url"] = args.url
+        return payload
+    if command == "runtime-error":
+        payload["type"] = "runtime_error"
+        payload["message"] = args.message
+        return payload
+    raise RuntimeError(f"unsupported command: {command}")
+
+
+def read_hook_payload():
+    raw = sys.stdin.read()
+    if not raw.strip():
+        return {}
+
+    try:
+        parsed = json.loads(raw)
+    except json.JSONDecodeError:
+        return {}
+
+    return parsed if isinstance(parsed, dict) else {}
+
+
+def send_payload(payload, control_env):
+    request = urllib.request.Request(
+        control_env["WEBMUX_CONTROL_URL"],
+        data=json.dumps(payload).encode(),
+        headers={
+            "Authorization": f"Bearer {control_env['WEBMUX_CONTROL_TOKEN']}",
+            "Content-Type": "application/json",
+        },
+        method="POST",
+    )
+
+    try:
+        with urllib.request.urlopen(request, timeout=10) as response:
+            if response.status < 200 or response.status >= 300:
+                print(f"control endpoint returned HTTP {response.status}", file=sys.stderr)
+                return False
+    except urllib.error.HTTPError as error:
+        print(f"control endpoint returned HTTP {error.code}", file=sys.stderr)
+        return False
+    except Exception as error:
+        print(f"failed to send runtime event: {error}", file=sys.stderr)
+        return False
+
+    return True
+
+
+def main():
+    parsed = build_parser().parse_args()
+
+    try:
+        control_env = read_control_env()
+    except RuntimeError as error:
+        print(str(error), file=sys.stderr)
+        return 1
+
+    required_keys = [
+        "WEBMUX_CONTROL_URL",
+        "WEBMUX_CONTROL_TOKEN",
+        "WEBMUX_WORKTREE_ID",
+        "WEBMUX_BRANCH",
+    ]
+    missing = [key for key in required_keys if not control_env.get(key)]
+    if missing:
+        print(f"missing control env keys: {', '.join(missing)}", file=sys.stderr)
+        return 1
+
+    if parsed.command == "claude-user-prompt-submit":
+        if not send_payload(build_payload("status-changed", argparse.Namespace(lifecycle="running"), control_env), control_env):
+            return 1
+        return 0
+
+    if parsed.command == "claude-post-tool-use":
+        hook_payload = read_hook_payload()
+        tool_name = hook_payload.get("tool_name")
+        tool_input = hook_payload.get("tool_input")
+        if not isinstance(tool_input, dict) or tool_name != "Bash":
+            return 0
+
+        command = tool_input.get("command")
+        if not isinstance(command, str) or "gh pr create" not in command:
+            return 0
+
+        pr_args = argparse.Namespace(url=None)
+        tool_response = hook_payload.get("tool_response")
+        if isinstance(tool_response, str):
+            match = re.search(r"https://github\\.com/[^\\s\\"]+/pull/\\d+", tool_response)
+            if match:
+                pr_args.url = match.group(0)
+
+        return 0 if send_payload(build_payload("pr-opened", pr_args, control_env), control_env) else 1
+
+    payload = build_payload(parsed.command, parsed, control_env)
+    if not send_payload(payload, control_env):
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+`;
+}
+function buildClaudeHookSettings(input) {
+  return {
+    hooks: {
+      UserPromptSubmit: [
+        {
+          hooks: [
+            {
+              type: "command",
+              command: `${shellQuote(input.agentCtlPath)} claude-user-prompt-submit`,
+              async: true
+            }
+          ]
+        }
+      ],
+      Notification: [
+        {
+          matcher: "permission_prompt|elicitation_dialog",
+          hooks: [
+            {
+              type: "command",
+              command: `${shellQuote(input.agentCtlPath)} status-changed --lifecycle idle`,
+              async: true
+            }
+          ]
+        }
+      ],
+      Stop: [
+        {
+          hooks: [
+            {
+              type: "command",
+              command: `${shellQuote(input.agentCtlPath)} agent-stopped`,
+              async: true
+            }
+          ]
+        }
+      ],
+      PostToolUse: [
+        {
+          hooks: [
+            {
+              type: "command",
+              command: `${shellQuote(input.agentCtlPath)} status-changed --lifecycle running`,
+              async: true
+            }
+          ]
+        },
+        {
+          matcher: "Bash",
+          hooks: [
+            {
+              type: "command",
+              command: `${shellQuote(input.agentCtlPath)} claude-post-tool-use`,
+              async: true
+            }
+          ]
+        }
+      ]
+    }
+  };
+}
+async function mergeClaudeSettings(settingsPath, hookSettings) {
+  let existing = {};
+  try {
+    const file = Bun.file(settingsPath);
+    if (await file.exists()) {
+      const parsed = await file.json();
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        existing = parsed;
+      }
+    }
+  } catch {
+    existing = {};
+  }
+  const existingHooks = existing.hooks;
+  const mergedHooks = existingHooks && typeof existingHooks === "object" && !Array.isArray(existingHooks) ? { ...existingHooks, ...hookSettings } : hookSettings;
+  const merged = { ...existing, hooks: mergedHooks };
+  await Bun.write(settingsPath, JSON.stringify(merged, null, 2) + `
+`);
+}
+async function ensureAgentRuntimeArtifacts(input) {
+  const storagePaths = getWorktreeStoragePaths(input.gitDir);
+  const artifacts = {
+    agentCtlPath: join3(storagePaths.webmuxDir, "webmux-agentctl"),
+    claudeSettingsPath: join3(input.worktreePath, ".claude", "settings.local.json")
+  };
+  await mkdir3(dirname2(artifacts.claudeSettingsPath), { recursive: true });
+  await Bun.write(artifacts.agentCtlPath, buildAgentCtlScript());
+  await chmod2(artifacts.agentCtlPath, 493);
+  const hookSettings = buildClaudeHookSettings(artifacts);
+  const hooks = hookSettings.hooks;
+  if (!isRecord4(hooks)) {
+    throw new Error("Invalid Claude hook settings");
+  }
+  await mergeClaudeSettings(artifacts.claudeSettingsPath, hooks);
+  return artifacts;
+}
+
+// backend/src/services/agent-service.ts
+function quoteShell(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function buildRuntimeBootstrap(runtimeEnvPath) {
+  return `set -a; . ${quoteShell(runtimeEnvPath)}; set +a`;
+}
+function buildAgentInvocation(input) {
+  const promptSuffix = input.prompt ? ` ${quoteShell(input.prompt)}` : "";
+  if (input.agent === "codex") {
+    const yoloFlag2 = input.yolo ? " --yolo" : "";
+    if (input.systemPrompt) {
+      return `codex${yoloFlag2} -c ${quoteShell(`developer_instructions=${input.systemPrompt}`)}${promptSuffix}`;
     }
+    return `codex${yoloFlag2}${promptSuffix}`;
+  }
+  const yoloFlag = input.yolo ? " --dangerously-skip-permissions" : "";
+  if (input.systemPrompt) {
+    return `claude${yoloFlag} --append-system-prompt ${quoteShell(input.systemPrompt)}${promptSuffix}`;
+  }
+  return `claude${yoloFlag}${promptSuffix}`;
+}
+function buildAgentCommand(input) {
+  return `${buildRuntimeBootstrap(input.runtimeEnvPath)}; ${buildAgentInvocation(input)}`;
+}
+function buildDockerExecCommand(containerName2, worktreePath, command) {
+  return `docker exec -it -w ${quoteShell(worktreePath)} ${quoteShell(containerName2)} bash -lc ${quoteShell(command)}`;
+}
+function buildManagedShellCommand(runtimeEnvPath, shellPath = Bun.env.SHELL || "/bin/bash") {
+  return `bash -lc ${quoteShell(`${buildRuntimeBootstrap(runtimeEnvPath)}; exec ${quoteShell(shellPath)} -i`)}`;
+}
+function buildAgentPaneCommand(input) {
+  return buildAgentCommand(input);
+}
+function buildDockerShellCommand(containerName2, worktreePath, runtimeEnvPath, shellPath = Bun.env.SHELL || "/bin/bash") {
+  return buildDockerExecCommand(containerName2, worktreePath, `${buildRuntimeBootstrap(runtimeEnvPath)}; exec ${quoteShell(shellPath)} -i`);
+}
+function buildDockerAgentPaneCommand(input) {
+  return buildDockerExecCommand(input.containerName, input.worktreePath, buildAgentCommand(input));
+}
+
+// backend/src/services/session-service.ts
+function resolvePaneCwd(template, ctx) {
+  return template.cwd === "repo" ? ctx.repoRoot : ctx.worktreePath;
+}
+function resolvePaneStartupCommand(template, commands) {
+  switch (template.kind) {
+    case "agent":
+      return commands.agent;
+    case "shell":
+      return;
+    case "command":
+      if (!template.command) {
+        throw new Error(`Pane "${template.id}" is kind=command but has no command`);
+      }
+      return template.command;
+  }
+}
+function planSessionLayout(projectRoot, branch, templates, ctx) {
+  if (templates.length === 0) {
+    throw new Error("At least one pane template is required");
+  }
+  const panes = templates.map((template, index) => {
+    const startupCommand = resolvePaneStartupCommand(template, ctx.paneCommands);
+    return {
+      id: template.id,
+      index,
+      kind: template.kind,
+      cwd: resolvePaneCwd(template, ctx),
+      ...startupCommand ? { startupCommand } : {},
+      focus: template.focus === true,
+      ...index > 0 ? {
+        split: template.split ?? "right",
+        ...template.sizePct !== undefined ? { sizePct: template.sizePct } : {}
+      } : {}
+    };
+  });
+  const focusPaneIndex = panes.find((pane) => pane.focus)?.index ?? 0;
+  return {
+    sessionName: buildProjectSessionName(projectRoot),
+    windowName: buildWorktreeWindowName(branch),
+    shellCommand: ctx.paneCommands.shell,
+    panes,
+    focusPaneIndex
+  };
+}
+function ensureSessionLayout(tmux, plan) {
+  const rootPane = plan.panes[0];
+  tmux.ensureServer();
+  tmux.ensureSession(plan.sessionName, rootPane.cwd);
+  if (tmux.hasWindow(plan.sessionName, plan.windowName)) {
+    tmux.killWindow(plan.sessionName, plan.windowName);
+  }
+  tmux.createWindow({
+    sessionName: plan.sessionName,
+    windowName: plan.windowName,
+    cwd: rootPane.cwd,
+    command: plan.shellCommand
+  });
+  tmux.setWindowOption(plan.sessionName, plan.windowName, "automatic-rename", "off");
+  tmux.setWindowOption(plan.sessionName, plan.windowName, "allow-rename", "off");
+  for (const pane of plan.panes.slice(1)) {
+    const target = `${plan.sessionName}:${plan.windowName}.${pane.index - 1}`;
+    tmux.splitWindow({
+      target,
+      split: pane.split ?? "right",
+      sizePct: pane.sizePct,
+      cwd: pane.cwd,
+      command: plan.shellCommand
+    });
+  }
+  for (const pane of plan.panes) {
+    if (!pane.startupCommand)
+      continue;
+    tmux.runCommand(`${plan.sessionName}:${plan.windowName}.${pane.index}`, pane.startupCommand);
+  }
+  tmux.selectPane(`${plan.sessionName}:${plan.windowName}.${plan.focusPaneIndex}`);
+}
+
+// backend/src/services/worktree-service.ts
+import { randomUUID } from "crypto";
+
+// backend/src/domain/model.ts
+var WORKTREE_META_SCHEMA_VERSION = 1;
+
+// backend/src/services/worktree-service.ts
+function toErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function joinErrorMessages(messages) {
+  return messages.filter((message) => message.length > 0).join("; ");
+}
+function cleanupSessionLayout(tmux, plan) {
+  if (!tmux || !plan)
+    return null;
+  try {
+    tmux.killWindow(plan.sessionName, plan.windowName);
+    return null;
+  } catch (error) {
+    return `tmux cleanup failed: ${toErrorMessage(error)}`;
+  }
+}
+function rollbackManagedWorktreeCreation(opts, sessionLayoutPlan, git, deps) {
+  const cleanupErrors = [];
+  const sessionCleanupError = cleanupSessionLayout(deps.tmux, sessionLayoutPlan);
+  if (sessionCleanupError)
+    cleanupErrors.push(sessionCleanupError);
+  try {
+    git.removeWorktree({
+      repoRoot: opts.repoRoot,
+      worktreePath: opts.worktreePath,
+      force: true
+    });
+  } catch (error) {
+    cleanupErrors.push(`worktree rollback failed: ${toErrorMessage(error)}`);
+  }
+  try {
+    git.deleteBranch(opts.repoRoot, opts.branch, true);
+  } catch (error) {
+    cleanupErrors.push(`branch rollback failed: ${toErrorMessage(error)}`);
+  }
+  return cleanupErrors.length > 0 ? joinErrorMessages(cleanupErrors) : null;
+}
+async function initializeManagedWorktree(opts) {
+  if (opts.controlUrl && !opts.controlToken || !opts.controlUrl && opts.controlToken) {
+    throw new Error("controlUrl and controlToken must be provided together");
+  }
+  const createdAt = (opts.now ?? (() => new Date))().toISOString();
+  const meta = {
+    schemaVersion: WORKTREE_META_SCHEMA_VERSION,
+    worktreeId: opts.worktreeId ?? randomUUID(),
+    branch: opts.branch,
+    createdAt,
+    profile: opts.profile,
+    agent: opts.agent,
+    runtime: opts.runtime,
+    startupEnvValues: { ...opts.startupEnvValues ?? {} },
+    allocatedPorts: { ...opts.allocatedPorts ?? {} }
+  };
+  const paths = await ensureWorktreeStorageDirs(opts.gitDir);
+  await writeWorktreeMeta(opts.gitDir, meta);
+  const runtimeEnv = buildRuntimeEnvMap(meta, opts.runtimeEnvExtras);
+  await writeRuntimeEnv(opts.gitDir, runtimeEnv);
+  let controlEnv = null;
+  if (opts.controlUrl && opts.controlToken) {
+    controlEnv = buildControlEnvMap({
+      controlUrl: opts.controlUrl,
+      controlToken: opts.controlToken,
+      worktreeId: meta.worktreeId,
+      branch: meta.branch
+    });
+    await writeControlEnv(opts.gitDir, controlEnv);
   }
+  return {
+    meta,
+    paths,
+    runtimeEnv,
+    controlEnv
+  };
 }
-function parseTmuxSessionForWorktree(tmuxOutput, worktreeName) {
-  const windowName = `wm-${worktreeName}`;
-  const lines = tmuxOutput.trim().split(`
-`).filter(Boolean);
-  for (const line of lines) {
-    const colonIdx = line.indexOf(":");
-    if (colonIdx === -1)
-      continue;
-    const session = line.slice(0, colonIdx);
-    const name = line.slice(colonIdx + 1);
-    if (name === windowName && !session.startsWith("wm-dash-")) {
-      return session;
+async function createManagedWorktree(opts, deps = {}) {
+  const git = deps.git ?? new BunGitGateway;
+  let worktreeCreated = false;
+  let sessionLayoutPlan = opts.sessionLayoutPlan;
+  try {
+    git.createWorktree({
+      repoRoot: opts.repoRoot,
+      worktreePath: opts.worktreePath,
+      branch: opts.branch,
+      baseBranch: opts.baseBranch
+    });
+    worktreeCreated = true;
+    const gitDir = git.resolveWorktreeGitDir(opts.worktreePath);
+    const initialized = await initializeManagedWorktree({
+      gitDir,
+      branch: opts.branch,
+      profile: opts.profile,
+      agent: opts.agent,
+      runtime: opts.runtime,
+      startupEnvValues: opts.startupEnvValues,
+      allocatedPorts: opts.allocatedPorts,
+      runtimeEnvExtras: opts.runtimeEnvExtras,
+      controlUrl: opts.controlUrl,
+      controlToken: opts.controlToken,
+      now: opts.now,
+      worktreeId: opts.worktreeId
+    });
+    if (deps.tmux) {
+      sessionLayoutPlan = sessionLayoutPlan ?? opts.sessionLayoutPlanBuilder?.(initialized);
+      if (sessionLayoutPlan) {
+        ensureSessionLayout(deps.tmux, sessionLayoutPlan);
+      }
     }
+    return initialized;
+  } catch (error) {
+    if (!worktreeCreated)
+      throw error;
+    const rollbackError = rollbackManagedWorktreeCreation(opts, sessionLayoutPlan, git, deps);
+    if (!rollbackError)
+      throw error;
+    throw new Error(`${toErrorMessage(error)}; ${rollbackError}`);
   }
-  for (const line of lines) {
-    const colonIdx = line.indexOf(":");
-    if (colonIdx === -1)
-      continue;
-    const session = line.slice(0, colonIdx);
-    const name = line.slice(colonIdx + 1);
-    if (name.startsWith("wm-") && !session.startsWith("wm-dash-")) {
-      return session;
-    }
+}
+function removeManagedWorktree(opts, git = new BunGitGateway) {
+  git.removeWorktree({
+    repoRoot: opts.repoRoot,
+    worktreePath: opts.worktreePath,
+    force: opts.force
+  });
+  if (opts.deleteBranch && opts.branch) {
+    git.deleteBranch(opts.repoRoot, opts.branch, opts.deleteBranchForce);
   }
-  return null;
 }
-async function findTmuxSessionForWorktree(worktreeName) {
-  try {
-    const proc = Bun.spawn(["tmux", "list-windows", "-a", "-F", "#{session_name}:#{window_name}"], { stdout: "pipe", stderr: "pipe" });
-    if (await proc.exited !== 0)
-      return "0";
-    const output = await new Response(proc.stdout).text();
-    return parseTmuxSessionForWorktree(output, worktreeName) ?? "0";
-  } catch {}
-  return "0";
+function mergeManagedWorktree(opts, git = new BunGitGateway) {
+  git.mergeBranch({
+    repoRoot: opts.repoRoot,
+    sourceBranch: opts.sourceBranch,
+    targetBranch: opts.targetBranch
+  });
 }
-async function attach(worktreeName, cols, rows, initialPane) {
-  log.debug(`[term] attach(${worktreeName}) cols=${cols} rows=${rows} existing=${sessions.has(worktreeName)}`);
-  if (sessions.has(worktreeName)) {
-    await detach(worktreeName);
+
+// backend/src/services/lifecycle-service.ts
+function generateBranchName() {
+  return `change-${randomUUID2().slice(0, 8)}`;
+}
+function toErrorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function stringifyStartupEnvValue(value) {
+  return typeof value === "boolean" ? String(value) : value;
+}
+
+class LifecycleError extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.status = status;
   }
-  const tmuxSession = await findTmuxSessionForWorktree(worktreeName);
-  const gName = groupedName();
-  log.debug(`[term] attach(${worktreeName}) tmuxSession=${tmuxSession} gName=${gName} window=wm-${worktreeName}`);
-  killTmuxSession(gName);
-  const cmd = buildAttachCmd({ gName, worktreeName, tmuxSession, cols, rows, initialPane });
-  const scriptArgs = process.platform === "darwin" ? ["python3", "-c", "import pty,sys;pty.spawn(sys.argv[1:])", "bash", "-c", cmd] : ["script", "-q", "-c", cmd, "/dev/null"];
-  const proc = Bun.spawn(scriptArgs, {
-    stdin: "pipe",
-    stdout: "pipe",
-    stderr: "pipe",
-    env: { ...Bun.env, TERM: "xterm-256color" }
-  });
-  const session = {
-    proc,
-    groupedSessionName: gName,
-    scrollback: [],
-    scrollbackBytes: 0,
-    onData: null,
-    onExit: null,
-    cancelled: false
-  };
-  sessions.set(worktreeName, session);
-  log.debug(`[term] attach(${worktreeName}) spawned pid=${proc.pid}`);
-  (async () => {
-    const reader = proc.stdout.getReader();
+}
+
+class LifecycleService {
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async createWorktree(input) {
+    const branch = await this.resolveBranch(input.branch, input.prompt);
+    this.ensureBranchAvailable(branch);
+    const { profileName, profile } = this.resolveProfile(input.profile);
+    const agent = this.resolveAgent(input.agent);
+    const worktreePath = this.resolveWorktreePath(branch);
+    let initialized = null;
     try {
-      while (true) {
-        if (session.cancelled)
-          break;
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        const str = textDecoder.decode(value);
-        session.scrollbackBytes += textEncoder.encode(str).byteLength;
-        session.scrollback.push(str);
-        while (session.scrollbackBytes > MAX_SCROLLBACK_BYTES && session.scrollback.length > 0) {
-          const removed = session.scrollback.shift();
-          session.scrollbackBytes -= textEncoder.encode(removed).byteLength;
+      await mkdir4(dirname3(worktreePath), { recursive: true });
+      initialized = await createManagedWorktree({
+        repoRoot: this.deps.projectRoot,
+        worktreePath,
+        branch,
+        baseBranch: this.deps.config.workspace.mainBranch,
+        profile: profileName,
+        agent,
+        runtime: profile.runtime,
+        startupEnvValues: await this.buildStartupEnvValues(input.envOverrides),
+        allocatedPorts: await this.allocatePorts(),
+        runtimeEnvExtras: { WEBMUX_WORKTREE_PATH: worktreePath },
+        controlUrl: this.controlUrl(),
+        controlToken: await this.deps.getControlToken()
+      }, {
+        git: this.deps.git
+      });
+      await ensureAgentRuntimeArtifacts({
+        gitDir: initialized.paths.gitDir,
+        worktreePath
+      });
+      await this.runLifecycleHook({
+        name: "postCreate",
+        command: this.deps.config.lifecycleHooks.postCreate,
+        meta: initialized.meta,
+        worktreePath
+      });
+      await this.materializeRuntimeSession({
+        branch,
+        profile,
+        agent,
+        initialized,
+        worktreePath,
+        prompt: input.prompt
+      });
+      await this.deps.reconciliation.reconcile(this.deps.projectRoot);
+      return {
+        branch,
+        worktreeId: initialized.meta.worktreeId
+      };
+    } catch (error) {
+      if (initialized) {
+        const cleanupError = await this.cleanupFailedCreate(branch, worktreePath, profile.runtime);
+        if (cleanupError) {
+          throw this.wrapOperationError(new Error(`${toErrorMessage2(error)}; ${cleanupError}`));
         }
-        session.onData?.(str);
-      }
-    } catch (err) {
-      if (!session.cancelled) {
-        log.error(`[term] stdout reader error(${worktreeName})`, err);
       }
+      throw this.wrapOperationError(error);
     }
-  })();
-  (async () => {
-    const reader = proc.stderr.getReader();
+  }
+  async openWorktree(branch) {
     try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        log.debug(`[term] stderr(${worktreeName}): ${textDecoder.decode(value).trimEnd()}`);
+      const resolved = await this.resolveExistingWorktree(branch);
+      const initialized = resolved.meta ? await this.refreshManagedArtifacts(resolved) : await this.initializeUnmanagedWorktree(resolved);
+      const { profile } = this.resolveProfile(initialized.meta.profile);
+      await ensureAgentRuntimeArtifacts({
+        gitDir: initialized.paths.gitDir,
+        worktreePath: resolved.entry.path
+      });
+      await this.materializeRuntimeSession({
+        branch,
+        profile,
+        agent: initialized.meta.agent,
+        initialized,
+        worktreePath: resolved.entry.path
+      });
+      await this.deps.reconciliation.reconcile(this.deps.projectRoot);
+      return {
+        branch,
+        worktreeId: initialized.meta.worktreeId
+      };
+    } catch (error) {
+      throw this.wrapOperationError(error);
+    }
+  }
+  async closeWorktree(branch) {
+    try {
+      const resolved = await this.resolveExistingWorktree(branch);
+      this.deps.tmux.killWindow(buildProjectSessionName(this.deps.projectRoot), buildWorktreeWindowName(branch));
+      await this.deps.reconciliation.reconcile(this.deps.projectRoot);
+    } catch (error) {
+      throw this.wrapOperationError(error);
+    }
+  }
+  async removeWorktree(branch) {
+    try {
+      const resolved = await this.resolveExistingWorktree(branch);
+      await this.removeResolvedWorktree(resolved);
+    } catch (error) {
+      throw this.wrapOperationError(error);
+    }
+  }
+  async mergeWorktree(branch) {
+    try {
+      const resolved = await this.resolveExistingWorktree(branch);
+      this.ensureNoUncommittedChanges(resolved.entry);
+      mergeManagedWorktree({
+        repoRoot: this.deps.projectRoot,
+        sourceBranch: branch,
+        targetBranch: this.deps.config.workspace.mainBranch
+      }, this.deps.git);
+      try {
+        await this.removeResolvedWorktree(resolved);
+      } catch (error) {
+        throw new LifecycleError(`Merged ${branch} into ${this.deps.config.workspace.mainBranch} but cleanup failed: ${toErrorMessage2(error)}`, 500);
       }
-    } catch {}
-  })();
-  proc.exited.then((exitCode) => {
-    log.debug(`[term] proc exited(${worktreeName}) pid=${proc.pid} code=${exitCode}`);
-    if (sessions.get(worktreeName) === session) {
-      session.onExit?.(exitCode);
-      sessions.delete(worktreeName);
-    } else {
-      log.debug(`[term] proc exited(${worktreeName}) stale session, skipping cleanup`);
+    } catch (error) {
+      throw this.wrapOperationError(error);
     }
-    killTmuxSession(gName);
-  });
-  return worktreeName;
-}
-async function detach(worktreeName) {
-  const session = sessions.get(worktreeName);
-  if (!session) {
-    log.debug(`[term] detach(${worktreeName}) no session found`);
-    return;
   }
-  log.debug(`[term] detach(${worktreeName}) killing pid=${session.proc.pid} tmux=${session.groupedSessionName}`);
-  session.cancelled = true;
-  session.proc.kill();
-  sessions.delete(worktreeName);
-  killTmuxSession(session.groupedSessionName);
-}
-function write(worktreeName, data) {
-  const session = sessions.get(worktreeName);
-  if (!session) {
-    log.warn(`[term] write(${worktreeName}) NO SESSION - input dropped (${data.length} bytes)`);
-    return;
+  async resolveBranch(rawBranch, prompt) {
+    const explicitBranch = rawBranch?.trim();
+    const branch = explicitBranch || await this.generateAutoName(prompt) || generateBranchName();
+    if (!isValidBranchName(branch)) {
+      throw new LifecycleError(`Invalid branch name: ${branch}`, 400);
+    }
+    return branch;
   }
-  try {
-    session.proc.stdin.write(textEncoder.encode(data));
-    session.proc.stdin.flush();
-  } catch (err) {
-    log.error(`[term] write(${worktreeName}) stdin closed`, err);
+  async generateAutoName(prompt) {
+    if (!this.deps.config.autoName || !prompt?.trim()) {
+      return null;
+    }
+    return await this.deps.autoName.generateBranchName(this.deps.config.autoName, prompt);
   }
-}
-async function sendKeys(worktreeName, hexBytes) {
-  const session = sessions.get(worktreeName);
-  if (!session)
-    return;
-  const windowTarget = `${session.groupedSessionName}:wm-${worktreeName}`;
-  await asyncTmux(["tmux", "send-keys", "-t", windowTarget, "-H", ...hexBytes]);
-}
-async function resize(worktreeName, cols, rows) {
-  const session = sessions.get(worktreeName);
-  if (!session)
-    return;
-  const windowTarget = `${session.groupedSessionName}:wm-${worktreeName}`;
-  const result = await asyncTmux(["tmux", "resize-window", "-t", windowTarget, "-x", String(cols), "-y", String(rows)]);
-  if (result.exitCode !== 0)
-    log.warn(`[term] resize failed: ${result.stderr}`);
-}
-function getScrollback(worktreeName) {
-  return sessions.get(worktreeName)?.scrollback.join("") ?? "";
-}
-function setCallbacks(worktreeName, onData, onExit) {
-  const session = sessions.get(worktreeName);
-  if (session) {
-    session.onData = onData;
-    session.onExit = onExit;
+  ensureBranchAvailable(branch) {
+    const exists = this.listProjectWorktrees().some((entry) => entry.branch === branch);
+    if (exists) {
+      throw new LifecycleError(`Worktree already exists: ${branch}`, 409);
+    }
   }
-}
-async function selectPane(worktreeName, paneIndex) {
-  const session = sessions.get(worktreeName);
-  if (!session) {
-    log.debug(`[term] selectPane(${worktreeName}) no session found`);
-    return;
+  resolveProfile(profileName) {
+    const name = profileName ?? getDefaultProfileName(this.deps.config);
+    const profile = this.deps.config.profiles[name];
+    if (!profile) {
+      throw new LifecycleError(`Unknown profile: ${name}`, 400);
+    }
+    return {
+      profileName: name,
+      profile
+    };
   }
-  const windowTarget = `wm-${worktreeName}`;
-  const target = `${session.groupedSessionName}:${windowTarget}.${paneIndex}`;
-  log.debug(`[term] selectPane(${worktreeName}) pane=${paneIndex} target=${target}`);
-  const [r1, r2] = await Promise.all([
-    asyncTmux(["tmux", "select-pane", "-t", target]),
-    asyncTmux(["tmux", "resize-pane", "-Z", "-t", target])
-  ]);
-  log.debug(`[term] selectPane(${worktreeName}) select=${r1.exitCode} zoom=${r2.exitCode}`);
-}
-function clearCallbacks(worktreeName) {
-  const session = sessions.get(worktreeName);
-  if (session) {
-    session.onData = null;
-    session.onExit = null;
+  resolveAgent(agent) {
+    if (!agent)
+      return this.deps.config.workspace.defaultAgent;
+    if (agent !== "claude" && agent !== "codex") {
+      throw new LifecycleError(`Unknown agent: ${agent}`, 400);
+    }
+    return agent;
+  }
+  async buildStartupEnvValues(envOverrides) {
+    const startupEnvValues = Object.fromEntries(Object.entries(this.deps.config.startupEnvs).map(([key, value]) => [key, stringifyStartupEnvValue(value)]));
+    for (const [key, value] of Object.entries(envOverrides ?? {})) {
+      if (!isValidEnvKey2(key)) {
+        throw new LifecycleError(`Invalid env override key: ${key}`, 400);
+      }
+      startupEnvValues[key] = value;
+    }
+    return startupEnvValues;
+  }
+  async allocatePorts() {
+    const metas = await this.readManagedMetas();
+    return allocateServicePorts(metas, this.deps.config.services);
+  }
+  resolveWorktreePath(branch) {
+    return resolve3(this.deps.projectRoot, this.deps.config.workspace.worktreeRoot, branch);
+  }
+  listProjectWorktrees() {
+    const projectRoot = resolve3(this.deps.projectRoot);
+    return this.deps.git.listWorktrees(projectRoot).filter((entry) => !entry.bare && resolve3(entry.path) !== projectRoot);
+  }
+  async readManagedMetas() {
+    const metas = await Promise.all(this.listProjectWorktrees().map(async (entry) => {
+      const gitDir = this.deps.git.resolveWorktreeGitDir(entry.path);
+      return readWorktreeMeta(gitDir);
+    }));
+    return metas.filter((meta) => meta !== null);
+  }
+  async resolveExistingWorktree(branch) {
+    const entry = this.listProjectWorktrees().find((candidate) => candidate.branch === branch);
+    if (!entry) {
+      throw new LifecycleError(`Worktree not found: ${branch}`, 404);
+    }
+    const gitDir = this.deps.git.resolveWorktreeGitDir(entry.path);
+    const meta = await readWorktreeMeta(gitDir);
+    return { entry, gitDir, meta };
+  }
+  async initializeUnmanagedWorktree(resolved) {
+    const { profileName, profile } = this.resolveProfile(undefined);
+    return initializeManagedWorktree({
+      gitDir: resolved.gitDir,
+      branch: resolved.entry.branch ?? resolved.entry.path,
+      profile: profileName,
+      agent: this.deps.config.workspace.defaultAgent,
+      runtime: profile.runtime,
+      startupEnvValues: await this.buildStartupEnvValues(undefined),
+      allocatedPorts: await this.allocatePorts(),
+      runtimeEnvExtras: { WEBMUX_WORKTREE_PATH: resolved.entry.path },
+      controlUrl: this.controlUrl(),
+      controlToken: await this.deps.getControlToken()
+    });
+  }
+  async refreshManagedArtifacts(resolved) {
+    if (!resolved.meta) {
+      throw new Error("Missing managed metadata");
+    }
+    const runtimeEnv = buildRuntimeEnvMap(resolved.meta, {
+      WEBMUX_WORKTREE_PATH: resolved.entry.path
+    });
+    await writeRuntimeEnv(resolved.gitDir, runtimeEnv);
+    const controlEnv = buildControlEnvMap({
+      controlUrl: this.controlUrl(),
+      controlToken: await this.deps.getControlToken(),
+      worktreeId: resolved.meta.worktreeId,
+      branch: resolved.meta.branch
+    });
+    await writeControlEnv(resolved.gitDir, controlEnv);
+    return {
+      meta: resolved.meta,
+      paths: getWorktreeStoragePaths(resolved.gitDir),
+      runtimeEnv,
+      controlEnv
+    };
+  }
+  async materializeRuntimeSession(input) {
+    if (input.profile.runtime === "docker") {
+      const dockerProfile = this.requireDockerProfile(input.profile);
+      const containerName2 = await this.deps.docker.launchContainer({
+        branch: input.branch,
+        wtDir: input.worktreePath,
+        mainRepoDir: this.deps.projectRoot,
+        sandboxConfig: dockerProfile,
+        services: this.deps.config.services,
+        runtimeEnv: input.initialized.runtimeEnv
+      });
+      ensureSessionLayout(this.deps.tmux, this.buildSessionLayout({
+        branch: input.branch,
+        profile: input.profile,
+        agent: input.agent,
+        initialized: input.initialized,
+        worktreePath: input.worktreePath,
+        prompt: input.prompt,
+        containerName: containerName2
+      }));
+      return;
+    }
+    ensureSessionLayout(this.deps.tmux, this.buildSessionLayout({
+      branch: input.branch,
+      profile: input.profile,
+      agent: input.agent,
+      initialized: input.initialized,
+      worktreePath: input.worktreePath,
+      prompt: input.prompt
+    }));
+  }
+  buildSessionLayout(input) {
+    const systemPrompt = input.profile.systemPrompt ? expandTemplate(input.profile.systemPrompt, input.initialized.runtimeEnv) : undefined;
+    const containerName2 = input.containerName;
+    return planSessionLayout(this.deps.projectRoot, input.branch, input.profile.panes, {
+      repoRoot: this.deps.projectRoot,
+      worktreePath: input.worktreePath,
+      paneCommands: containerName2 ? {
+        agent: buildDockerAgentPaneCommand({
+          agent: input.agent,
+          containerName: containerName2,
+          worktreePath: input.worktreePath,
+          runtimeEnvPath: input.initialized.paths.runtimeEnvPath,
+          yolo: input.profile.yolo === true,
+          systemPrompt,
+          prompt: input.prompt
+        }),
+        shell: buildDockerShellCommand(containerName2, input.worktreePath, input.initialized.paths.runtimeEnvPath)
+      } : {
+        agent: buildAgentPaneCommand({
+          agent: input.agent,
+          runtimeEnvPath: input.initialized.paths.runtimeEnvPath,
+          yolo: input.profile.yolo === true,
+          systemPrompt,
+          prompt: input.prompt
+        }),
+        shell: buildManagedShellCommand(input.initialized.paths.runtimeEnvPath)
+      }
+    });
+  }
+  requireDockerProfile(profile) {
+    if (!isDockerProfile(profile)) {
+      throw new LifecycleError("Docker profile is missing an image", 422);
+    }
+    return profile;
+  }
+  async cleanupFailedCreate(branch, worktreePath, runtime) {
+    const cleanupErrors = [];
+    if (runtime === "docker") {
+      try {
+        await this.deps.docker.removeContainer(branch);
+      } catch (error) {
+        cleanupErrors.push(`container cleanup failed: ${toErrorMessage2(error)}`);
+      }
+    }
+    try {
+      this.deps.tmux.killWindow(buildProjectSessionName(this.deps.projectRoot), buildWorktreeWindowName(branch));
+    } catch (error) {
+      cleanupErrors.push(`tmux cleanup failed: ${toErrorMessage2(error)}`);
+    }
+    try {
+      removeManagedWorktree({
+        repoRoot: this.deps.projectRoot,
+        worktreePath,
+        branch,
+        force: true,
+        deleteBranch: true,
+        deleteBranchForce: true
+      }, this.deps.git);
+    } catch (error) {
+      cleanupErrors.push(`worktree cleanup failed: ${toErrorMessage2(error)}`);
+    }
+    return cleanupErrors.length > 0 ? cleanupErrors.join("; ") : null;
+  }
+  ensureNoUncommittedChanges(entry) {
+    const status = this.deps.git.readWorktreeStatus(entry.path);
+    if (status.dirty) {
+      throw new LifecycleError(`Worktree has uncommitted changes: ${entry.branch ?? entry.path}`, 409);
+    }
+  }
+  controlUrl() {
+    return `${this.deps.controlBaseUrl.replace(/\/+$/, "")}/api/runtime/events`;
+  }
+  async removeResolvedWorktree(resolved) {
+    await this.runLifecycleHook({
+      name: "preRemove",
+      command: this.deps.config.lifecycleHooks.preRemove,
+      meta: resolved.meta,
+      worktreePath: resolved.entry.path
+    });
+    const branch = resolved.entry.branch ?? resolved.entry.path;
+    if (resolved.meta?.runtime === "docker") {
+      await this.deps.docker.removeContainer(branch);
+    }
+    this.deps.tmux.killWindow(buildProjectSessionName(this.deps.projectRoot), buildWorktreeWindowName(branch));
+    removeManagedWorktree({
+      repoRoot: this.deps.projectRoot,
+      worktreePath: resolved.entry.path,
+      branch,
+      force: true,
+      deleteBranch: true,
+      deleteBranchForce: true
+    }, this.deps.git);
+    await this.deps.reconciliation.reconcile(this.deps.projectRoot);
+  }
+  async runLifecycleHook(input) {
+    if (!input.command || !input.meta) {
+      return;
+    }
+    await this.deps.hooks.run({
+      name: input.name,
+      command: input.command,
+      cwd: input.worktreePath,
+      env: buildRuntimeEnvMap(input.meta, {
+        WEBMUX_WORKTREE_PATH: input.worktreePath
+      })
+    });
+  }
+  wrapOperationError(error) {
+    if (error instanceof LifecycleError) {
+      return error;
+    }
+    return new LifecycleError(toErrorMessage2(error), 422);
   }
 }
 
-// backend/src/pr.ts
+// backend/src/services/pr-service.ts
 var PR_FETCH_LIMIT = 50;
 var GH_TIMEOUT_MS = 15000;
 var prUpdatedAtCache = new Map;
@@ -8297,9 +9870,9 @@ async function fetchReviewComments(prNumber, repoSlug, cwd) {
     apiPath,
     "--include"
   ];
-  const cached2 = etagCache.get(apiPath);
-  if (cached2) {
-    args.push("--header", `If-None-Match: ${cached2.etag}`);
+  const cached = etagCache.get(apiPath);
+  if (cached) {
+    args.push("--header", `If-None-Match: ${cached.etag}`);
   }
   const proc = Bun.spawn(args, {
     stdout: "pipe",
@@ -8312,7 +9885,7 @@ async function fetchReviewComments(prNumber, repoSlug, cwd) {
   });
   const raceResult = await Promise.race([proc.exited, timeout]);
   if (raceResult === "timeout")
-    return cached2?.comments ?? [];
+    return cached?.comments ?? [];
   const raw = await new Response(proc.stdout).text();
   let blankLineIdx = raw.indexOf(`\r
 \r
@@ -8326,21 +9899,21 @@ async function fetchReviewComments(prNumber, repoSlug, cwd) {
   }
   if (blankLineIdx === -1) {
     if (raceResult !== 0)
-      return cached2?.comments ?? [];
+      return cached?.comments ?? [];
     try {
       return parseReviewComments(raw);
     } catch {
-      return cached2?.comments ?? [];
+      return cached?.comments ?? [];
     }
   }
   const headerBlock = raw.slice(0, blankLineIdx);
   const body = raw.slice(blankLineIdx + separatorLen);
   if (headerBlock.includes("304 Not Modified")) {
     log.debug(`[pr] etag cache hit for PR #${prNumber}`);
-    return cached2?.comments ?? [];
+    return cached?.comments ?? [];
   }
   if (raceResult !== 0)
-    return cached2?.comments ?? [];
+    return cached?.comments ?? [];
   const etagMatch = headerBlock.match(/^etag:\s*(.+)$/mi);
   try {
     const comments = parseReviewComments(body);
@@ -8349,7 +9922,7 @@ async function fetchReviewComments(prNumber, repoSlug, cwd) {
     }
     return comments;
   } catch {
-    return cached2?.comments ?? [];
+    return cached?.comments ?? [];
   }
 }
 async function fetchPrState(url) {
@@ -8371,16 +9944,8 @@ async function fetchPrState(url) {
     return null;
   }
 }
-async function refreshStalePrData(wtDir) {
-  const env = await readEnvLocal(wtDir);
-  if (!env.PR_DATA)
-    return;
-  let entries;
-  try {
-    entries = JSON.parse(env.PR_DATA);
-  } catch {
-    return;
-  }
+async function refreshStalePrData(gitDir) {
+  const entries = await readWorktreePrs(gitDir);
   if (!entries.some((e) => e.state === "open"))
     return;
   const updated = await Promise.all(entries.map(async (entry) => {
@@ -8389,9 +9954,9 @@ async function refreshStalePrData(wtDir) {
     const state = await fetchPrState(entry.url);
     return state ? { ...entry, state } : entry;
   }));
-  await writeEnvLocal(wtDir, { PR_DATA: JSON.stringify(updated) });
+  await writeWorktreePrs(gitDir, updated);
 }
-async function syncPrStatus(getWorktreePaths, linkedRepos, projectDir) {
+async function syncPrStatus(getWorktreeGitDirs, linkedRepos, projectDir) {
   log.debug(`[pr] starting sync (${1 + linkedRepos.length} repo(s))`);
   const allRepoResults = await Promise.all([
     fetchAllPrs(undefined, undefined, projectDir),
@@ -8409,8 +9974,8 @@ async function syncPrStatus(getWorktreePaths, linkedRepos, projectDir) {
       branchPrs.set(branch, existing);
     }
   }
-  const wtPaths = await getWorktreePaths();
-  const activeBranches = new Set(wtPaths.keys());
+  const worktreeGitDirs = await getWorktreeGitDirs();
+  const activeBranches = new Set(worktreeGitDirs.keys());
   const reviewTuples = [];
   for (const [branch, entries] of branchPrs) {
     if (!activeBranches.has(branch))
@@ -8421,8 +9986,8 @@ async function syncPrStatus(getWorktreePaths, linkedRepos, projectDir) {
       const cachedUpdatedAt = prUpdatedAtCache.get(entry.url);
       if (cachedUpdatedAt === entry.updatedAt && prCommentsCache.has(entry.url)) {
         log.debug(`[pr] skipping comments for PR #${entry.number} (unchanged)`);
-        const cached2 = prCommentsCache.get(entry.url);
-        entry.comments = [...entry.comments, ...cached2].sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+        const cached = prCommentsCache.get(entry.url);
+        entry.comments = [...entry.comments, ...cached].sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
       } else {
         const repoSlug = entry.repo ? linkedRepos.find((lr) => lr.alias === entry.repo)?.repo : undefined;
         reviewTuples.push({ entry, repoSlug });
@@ -8442,21 +10007,21 @@ async function syncPrStatus(getWorktreePaths, linkedRepos, projectDir) {
   }
   const seen = new Set;
   for (const [branch, entries] of branchPrs) {
-    const wtDir = wtPaths.get(branch);
-    if (!wtDir || seen.has(wtDir))
+    const gitDir = worktreeGitDirs.get(branch);
+    if (!gitDir || seen.has(gitDir))
       continue;
-    seen.add(wtDir);
-    await writeEnvLocal(wtDir, { PR_DATA: JSON.stringify(entries) });
+    seen.add(gitDir);
+    await writeWorktreePrs(gitDir, entries);
   }
   if (seen.size > 0) {
     log.debug(`[pr] synced ${seen.size} worktree(s) with PR data from ${allRepoResults.length} repo(s)`);
   }
-  const uniqueDirs = new Set(wtPaths.values());
+  const uniqueDirs = new Set(worktreeGitDirs.values());
   const staleRefreshes = [];
-  for (const wtDir of uniqueDirs) {
-    if (seen.has(wtDir))
+  for (const gitDir of uniqueDirs) {
+    if (seen.has(gitDir))
       continue;
-    staleRefreshes.push(refreshStalePrData(wtDir));
+    staleRefreshes.push(refreshStalePrData(gitDir));
   }
   await Promise.all(staleRefreshes);
   const currentPrUrls = new Set;
@@ -8481,13 +10046,13 @@ async function syncPrStatus(getWorktreePaths, linkedRepos, projectDir) {
       etagCache.delete(key);
   }
 }
-function startPrMonitor(getWorktreePaths, linkedRepos, projectDir, intervalMs = 20000, isActive) {
+function startPrMonitor(getWorktreeGitDirs, linkedRepos, projectDir, intervalMs = 20000, isActive) {
   const run = () => {
     if (isActive && !isActive()) {
       log.debug("[pr] skipping PR sync: no active clients");
       return;
     }
-    syncPrStatus(getWorktreePaths, linkedRepos, projectDir).catch((err) => {
+    syncPrStatus(getWorktreeGitDirs, linkedRepos, projectDir).catch((err) => {
       log.error(`[pr] sync error: ${err}`);
     });
   };
@@ -8498,381 +10063,373 @@ function startPrMonitor(getWorktreePaths, linkedRepos, projectDir, intervalMs =
   };
 }
 
-// backend/src/http.ts
-function jsonResponse(data, status = 200) {
-  return new Response(JSON.stringify(data), {
-    status,
-    headers: { "Content-Type": "application/json" }
-  });
-}
-function errorResponse(message, status = 500) {
-  return jsonResponse({ error: message }, status);
-}
-
-// backend/src/notifications.ts
-import { mkdir as mkdir3, chmod as chmod2 } from "fs/promises";
-var nextId = 1;
-var notifications = [];
-var sseClients = new Set;
-function formatSse(event, data) {
-  return new TextEncoder().encode(`event: ${event}
-data: ${JSON.stringify(data)}
-
-`);
-}
-function broadcast(event) {
-  const encoded = event.kind === "notification" ? formatSse("notification", event.data) : formatSse("dismiss", { id: event.id });
-  for (const controller of sseClients) {
-    try {
-      controller.enqueue(encoded);
-    } catch {
-      sseClients.delete(controller);
-    }
-  }
-}
-var ACTIVITY_TIMEOUT_MS = 15000;
-var lastActivityAt = Date.now();
-function touchActivity() {
-  lastActivityAt = Date.now();
-}
-function hasDashboardActivity() {
-  return Date.now() - lastActivityAt < ACTIVITY_TIMEOUT_MS;
+// backend/src/services/project-runtime.ts
+function isoNow(now) {
+  return (now ?? (() => new Date))().toISOString();
 }
-function addNotification(branch, type, url) {
-  const message = type === "agent_stopped" ? `Agent stopped on ${branch}` : `PR opened on ${branch}`;
-  const notification = {
-    id: nextId++,
-    branch,
-    type,
-    message,
-    url,
-    timestamp: Date.now()
-  };
-  notifications.push(notification);
-  if (notifications.length > 50)
-    notifications.shift();
-  log.info(`[notify] ${type} branch=${branch}${url ? ` url=${url}` : ""}`);
-  broadcast({ kind: "notification", data: notification });
-  return notification;
-}
-function dismissNotification(id) {
-  const idx = notifications.findIndex((n) => n.id === id);
-  if (idx === -1)
-    return false;
-  notifications.splice(idx, 1);
-  broadcast({ kind: "dismiss", id });
-  return true;
-}
-function handleNotificationStream() {
-  let ctrl;
-  const stream = new ReadableStream({
-    start(controller) {
-      ctrl = controller;
-      sseClients.add(controller);
-      for (const n of notifications) {
-        controller.enqueue(formatSse("initial", n));
-      }
+function makeDefaultState(input) {
+  return {
+    worktreeId: input.worktreeId,
+    branch: input.branch,
+    path: input.path,
+    profile: input.profile ?? null,
+    agentName: input.agentName ?? null,
+    git: {
+      exists: true,
+      branch: input.branch,
+      dirty: false,
+      aheadCount: 0,
+      currentCommit: null
     },
-    cancel() {
-      sseClients.delete(ctrl);
-    }
-  });
-  return new Response(stream, {
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive"
-    }
-  });
+    session: {
+      exists: false,
+      sessionName: null,
+      windowName: buildWorktreeWindowName(input.branch),
+      paneCount: 0
+    },
+    agent: {
+      runtime: input.runtime ?? "host",
+      lifecycle: "closed",
+      lastStartedAt: null,
+      lastEventAt: null,
+      lastError: null
+    },
+    services: [],
+    prs: []
+  };
 }
-function handleDismissNotification(id) {
-  const ok = dismissNotification(id);
-  if (!ok) {
-    return new Response(JSON.stringify({ error: "Not found" }), {
-      status: 404,
-      headers: { "Content-Type": "application/json" }
-    });
-  }
-  return new Response(JSON.stringify({ ok: true }), {
-    headers: { "Content-Type": "application/json" }
-  });
+function clonePrEntry(pr) {
+  return {
+    ...pr,
+    ciChecks: pr.ciChecks.map((check) => ({ ...check })),
+    comments: pr.comments.map((comment) => ({ ...comment }))
+  };
 }
-var HOOKS_DIR = `${Bun.env.HOME ?? "/root"}/.config/workmux/hooks`;
-var NOTIFY_STOP_SH = `#!/usr/bin/env bash
-# Claude Code Stop hook \u2014 notifies workmux backend that an agent stopped.
-set -euo pipefail
-
-# Read hook input from stdin
-INPUT=$(cat)
 
-# Auth: token from env or secret file
-TOKEN="\${WORKMUX_RPC_TOKEN:-}"
-if [ -z "$TOKEN" ] && [ -f "\${HOME}/.config/workmux/rpc-secret" ]; then
-  TOKEN=$(cat "\${HOME}/.config/workmux/rpc-secret")
-fi
-[ -z "$TOKEN" ] && exit 0
-
-PORT="\${WORKMUX_RPC_PORT:-5111}"
-
-# Extract branch from cwd field: .../__worktrees/<branch>
-CWD=$(echo "$INPUT" | jq -r '.cwd // empty')
-[ -z "$CWD" ] && exit 0
-BRANCH=$(echo "$CWD" | grep -oP '__worktrees/\\K[^/]+' || true)
-[ -z "$BRANCH" ] && exit 0
-
-PAYLOAD=$(jq -n --arg branch "$BRANCH" '{"command":"notify","branch":$branch,"args":["agent_stopped"]}')
-
-curl -sf -X POST "http://127.0.0.1:\${PORT}/rpc/workmux" \\
-  -H "Authorization: Bearer $TOKEN" \\
-  -H "Content-Type: application/json" \\
-  -d "$PAYLOAD" \\
-  >/dev/null 2>&1 || true
-`;
-var NOTIFY_PR_SH = `#!/usr/bin/env bash
-# Claude Code PostToolUse hook \u2014 notifies workmux backend when a PR is opened.
-set -euo pipefail
-
-# Read hook input from stdin
-INPUT=$(cat)
-
-# Only trigger on Bash tool calls containing "gh pr create"
-TOOL_INPUT=$(echo "$INPUT" | jq -r '.tool_input.command // empty')
-echo "$TOOL_INPUT" | grep -q 'gh pr create' || exit 0
-
-# Auth: token from env or secret file
-TOKEN="\${WORKMUX_RPC_TOKEN:-}"
-if [ -z "$TOKEN" ] && [ -f "\${HOME}/.config/workmux/rpc-secret" ]; then
-  TOKEN=$(cat "\${HOME}/.config/workmux/rpc-secret")
-fi
-[ -z "$TOKEN" ] && exit 0
-
-PORT="\${WORKMUX_RPC_PORT:-5111}"
-
-# Extract branch from cwd
-CWD=$(echo "$INPUT" | jq -r '.cwd // empty')
-[ -z "$CWD" ] && exit 0
-BRANCH=$(echo "$CWD" | grep -oP '__worktrees/\\K[^/]+' || true)
-[ -z "$BRANCH" ] && exit 0
-
-# Extract PR URL from tool response (gh pr create outputs the URL)
-PR_URL=$(echo "$INPUT" | jq -r '.tool_response // empty' | grep -oP 'https://github\\.com/[^\\s"]+/pull/\\d+' | head -1 || true)
-
-if [ -n "$PR_URL" ]; then
-  PAYLOAD=$(jq -n --arg branch "$BRANCH" --arg url "$PR_URL" '{"command":"notify","branch":$branch,"args":["pr_opened",$url]}')
-else
-  PAYLOAD=$(jq -n --arg branch "$BRANCH" '{"command":"notify","branch":$branch,"args":["pr_opened"]}')
-fi
-
-curl -sf -X POST "http://127.0.0.1:\${PORT}/rpc/workmux" \\
-  -H "Authorization: Bearer $TOKEN" \\
-  -H "Content-Type: application/json" \\
-  -d "$PAYLOAD" \\
-  >/dev/null 2>&1 || true
-`;
-async function installHookScripts() {
-  await mkdir3(HOOKS_DIR, { recursive: true });
-  const stopPath = `${HOOKS_DIR}/notify-stop.sh`;
-  const prPath = `${HOOKS_DIR}/notify-pr.sh`;
-  await Bun.write(stopPath, NOTIFY_STOP_SH);
-  await Bun.write(prPath, NOTIFY_PR_SH);
-  await chmod2(stopPath, 493);
-  await chmod2(prPath, 493);
-  log.info(`[notify] installed hook scripts in ${HOOKS_DIR}`);
-}
-
-// backend/src/rpc.ts
-function tmuxEnv() {
-  if (Bun.env.TMUX)
-    return Bun.env;
-  const tmpdir = Bun.env.TMUX_TMPDIR || "/tmp";
-  const uid = process.getuid?.() ?? 1000;
-  return { ...Bun.env, TMUX: `${tmpdir}/tmux-${uid}/default,0,0` };
-}
-async function resolvePaneId(branch) {
-  const proc = Bun.spawn(["tmux", "list-panes", "-a", "-F", "#{window_name}\t#{pane_id}"], { stdout: "pipe", stderr: "pipe", env: tmuxEnv() });
-  const [stdout, , exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited
-  ]);
-  if (exitCode !== 0)
-    return null;
-  const target = `wm-${branch}`;
-  for (const line of stdout.trim().split(`
-`)) {
-    const [windowName, paneId] = line.split("\t");
-    if (windowName === target && paneId)
-      return paneId;
+class ProjectRuntime {
+  worktrees = new Map;
+  worktreeIdsByBranch = new Map;
+  upsertWorktree(input) {
+    const existing = this.worktrees.get(input.worktreeId);
+    if (existing) {
+      this.reindexBranch(existing.branch, input.branch, input.worktreeId);
+      existing.path = input.path;
+      existing.branch = input.branch;
+      existing.profile = input.profile ?? existing.profile;
+      existing.agentName = input.agentName ?? existing.agentName;
+      if (input.runtime)
+        existing.agent.runtime = input.runtime;
+      existing.git.exists = true;
+      existing.git.branch = input.branch;
+      existing.session.windowName = buildWorktreeWindowName(input.branch);
+      return existing;
+    }
+    const created = makeDefaultState(input);
+    this.worktrees.set(input.worktreeId, created);
+    this.worktreeIdsByBranch.set(input.branch, input.worktreeId);
+    return created;
+  }
+  removeWorktree(worktreeId) {
+    const state = this.worktrees.get(worktreeId);
+    if (!state)
+      return false;
+    this.worktreeIdsByBranch.delete(state.branch);
+    return this.worktrees.delete(worktreeId);
+  }
+  getWorktree(worktreeId) {
+    return this.worktrees.get(worktreeId) ?? null;
+  }
+  getWorktreeByBranch(branch) {
+    const worktreeId = this.worktreeIdsByBranch.get(branch);
+    return worktreeId ? this.worktrees.get(worktreeId) ?? null : null;
+  }
+  listWorktrees() {
+    return [...this.worktrees.values()].sort((a, b) => a.branch.localeCompare(b.branch));
+  }
+  setGitState(worktreeId, patch) {
+    const state = this.requireWorktree(worktreeId);
+    if (patch.branch && patch.branch !== state.branch) {
+      this.applyBranchChange(state, patch.branch);
+    }
+    state.git = { ...state.git, ...patch, branch: state.branch };
+    return state;
+  }
+  setSessionState(worktreeId, patch) {
+    const state = this.requireWorktree(worktreeId);
+    state.session = { ...state.session, ...patch, windowName: buildWorktreeWindowName(state.branch) };
+    return state;
+  }
+  setServices(worktreeId, services) {
+    const state = this.requireWorktree(worktreeId);
+    state.services = services.map((service) => ({ ...service }));
+    return state;
+  }
+  setPrs(worktreeId, prs) {
+    const state = this.requireWorktree(worktreeId);
+    state.prs = prs.map((pr) => clonePrEntry(pr));
+    return state;
+  }
+  applyEvent(event, now) {
+    const state = this.requireWorktree(event.worktreeId);
+    if (event.branch !== state.branch) {
+      this.applyBranchChange(state, event.branch);
+    }
+    const timestamp = isoNow(now);
+    switch (event.type) {
+      case "agent_stopped":
+        state.agent.lifecycle = "stopped";
+        state.agent.lastEventAt = timestamp;
+        break;
+      case "agent_status_changed":
+        this.applyStatusChanged(state, event, timestamp);
+        break;
+      case "runtime_error":
+        this.applyRuntimeError(state, event, timestamp);
+        break;
+      case "pr_opened":
+        state.agent.lastEventAt = timestamp;
+        break;
+    }
+    return state;
   }
-  return null;
-}
-async function handleWorkmuxRpc(req) {
-  const secret = await loadRpcSecret();
-  const authHeader = req.headers.get("Authorization");
-  const token = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : null;
-  if (token !== secret) {
-    return new Response("Unauthorized", { status: 401 });
+  applyStatusChanged(state, event, timestamp) {
+    state.agent.lifecycle = event.lifecycle;
+    state.agent.lastEventAt = timestamp;
+    if (state.agent.lastStartedAt === null && event.lifecycle === "running") {
+      state.agent.lastStartedAt = timestamp;
+    }
+    state.agent.lastError = null;
   }
-  let raw;
-  try {
-    raw = await req.json();
-  } catch {
-    return jsonResponse({ ok: false, error: "Invalid JSON" }, 400);
+  applyRuntimeError(state, event, timestamp) {
+    state.agent.lifecycle = "error";
+    state.agent.lastError = event.message;
+    state.agent.lastEventAt = timestamp;
   }
-  const { command, args = [], branch } = raw;
-  if (!command) {
-    return jsonResponse({ ok: false, error: "Missing command" }, 400);
+  applyBranchChange(state, branch) {
+    this.reindexBranch(state.branch, branch, state.worktreeId);
+    state.branch = branch;
+    state.git.branch = branch;
+    state.session.windowName = buildWorktreeWindowName(branch);
   }
-  if (command === "notify" && branch) {
-    const [type, url] = args;
-    if (type === "agent_stopped" || type === "pr_opened") {
-      addNotification(branch, type, url);
-      return jsonResponse({ ok: true, output: "ok" });
+  reindexBranch(previousBranch, nextBranch, worktreeId) {
+    if (previousBranch !== nextBranch) {
+      this.worktreeIdsByBranch.delete(previousBranch);
     }
-    return jsonResponse({ ok: false, error: `Unknown notification type: ${type}` }, 400);
+    this.worktreeIdsByBranch.set(nextBranch, worktreeId);
   }
-  try {
-    const env = tmuxEnv();
-    if (command === "set-window-status" && branch) {
-      const paneId = await resolvePaneId(branch);
-      if (paneId) {
-        env.TMUX_PANE = paneId;
-      }
-    }
-    const proc = Bun.spawn(["workmux", command, ...args], {
-      stdout: "pipe",
-      stderr: "pipe",
-      env
-    });
-    const [stdout, stderr, exitCode] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-      proc.exited
-    ]);
-    if (exitCode !== 0) {
-      return jsonResponse({ ok: false, error: stderr.trim() || `exit code ${exitCode}` }, 422);
+  requireWorktree(worktreeId) {
+    const state = this.worktrees.get(worktreeId);
+    if (!state) {
+      throw new Error(`Unknown worktree id: ${worktreeId}`);
     }
-    return jsonResponse({ ok: true, output: stdout.trim() });
-  } catch (err) {
-    const error = err instanceof Error ? err.message : String(err);
-    return jsonResponse({ ok: false, error }, 500);
+    return state;
   }
 }
 
-// backend/src/linear.ts
-var ASSIGNED_ISSUES_QUERY = `
-  query AssignedIssues {
-    viewer {
-      assignedIssues(
-        filter: { state: { type: { nin: ["completed", "canceled"] } } }
-        orderBy: updatedAt
-        first: 50
-      ) {
-        nodes {
-          id
-          identifier
-          title
-          description
-          priority
-          priorityLabel
-          url
-          branchName
-          dueDate
-          updatedAt
-          state { name color type }
-          team { name key }
-          labels { nodes { name color } }
-          project { name }
-        }
-      }
-    }
-  }
-`;
-function parseIssuesResponse(raw) {
-  if (raw.errors && raw.errors.length > 0) {
-    return { ok: false, error: raw.errors.map((e) => e.message).join("; ") };
-  }
-  if (!raw.data) {
-    return { ok: false, error: "No data in response" };
-  }
-  const nodes = raw.data.viewer.assignedIssues.nodes;
-  const issues = nodes.map((n) => ({
-    id: n.id,
-    identifier: n.identifier,
-    title: n.title,
-    description: n.description,
-    priority: n.priority,
-    priorityLabel: n.priorityLabel,
-    url: n.url,
-    branchName: n.branchName,
-    dueDate: n.dueDate,
-    updatedAt: n.updatedAt,
-    state: n.state,
-    team: n.team,
-    labels: n.labels.nodes,
-    project: n.project?.name ?? null
+// backend/src/services/reconciliation-service.ts
+import { basename as basename2, resolve as resolve4 } from "path";
+function makeUnmanagedWorktreeId(path) {
+  return `unmanaged:${resolve4(path)}`;
+}
+function isValidPort2(port) {
+  return port !== null && Number.isInteger(port) && port >= 1 && port <= 65535;
+}
+async function buildServiceStates(deps, input) {
+  const runtimeEnv = buildRuntimeEnvMap({
+    schemaVersion: 1,
+    worktreeId: input.worktreeId,
+    branch: input.branch,
+    createdAt: "",
+    profile: input.profile,
+    agent: input.agent,
+    runtime: input.runtime,
+    startupEnvValues: input.startupEnvValues,
+    allocatedPorts: input.allocatedPorts
+  });
+  return Promise.all(deps.config.services.map(async (service) => {
+    const port = input.allocatedPorts[service.portEnv] ?? null;
+    const running = isValidPort2(port) ? await deps.portProbe.isListening(port) : false;
+    return {
+      name: service.name,
+      port,
+      running,
+      url: port !== null && service.urlTemplate ? expandTemplate(service.urlTemplate, runtimeEnv) : null
+    };
   }));
-  return { ok: true, data: issues };
 }
-function branchMatchesIssue(worktreeBranch, issueBranchName) {
-  if (!worktreeBranch || !issueBranchName)
-    return false;
-  if (worktreeBranch === issueBranchName)
-    return true;
-  const issueSlashIdx = issueBranchName.indexOf("/");
-  if (issueSlashIdx !== -1) {
-    const suffix = issueBranchName.slice(issueSlashIdx + 1);
-    if (worktreeBranch === suffix)
-      return true;
-  }
-  const wtSlashIdx = worktreeBranch.indexOf("/");
-  if (wtSlashIdx !== -1) {
-    const wtSuffix = worktreeBranch.slice(wtSlashIdx + 1);
-    if (wtSuffix === issueBranchName)
-      return true;
-    if (issueSlashIdx !== -1 && wtSuffix === issueBranchName.slice(issueSlashIdx + 1))
-      return true;
-  }
-  return false;
+function findWindow(windows, sessionName, branch) {
+  const windowName = buildWorktreeWindowName(branch);
+  return windows.find((window) => window.sessionName === sessionName && window.windowName === windowName) ?? null;
 }
-var CACHE_TTL_MS = 300000;
-var issueCache = null;
-async function fetchAssignedIssues() {
-  const apiKey = Bun.env.LINEAR_API_KEY;
-  if (!apiKey) {
-    return { ok: false, error: "LINEAR_API_KEY not set" };
-  }
-  const now = Date.now();
-  if (issueCache && now < issueCache.expiry) {
-    return issueCache.data;
+function resolveBranch(entry, metaBranch) {
+  const fallback = basename2(entry.path);
+  return entry.branch ?? metaBranch ?? (fallback.length > 0 ? fallback : "unknown");
+}
+
+class ReconciliationService {
+  deps;
+  constructor(deps) {
+    this.deps = deps;
   }
-  try {
-    const res = await fetch("https://api.linear.app/graphql", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: apiKey
-      },
-      body: JSON.stringify({ query: ASSIGNED_ISSUES_QUERY })
-    });
-    if (!res.ok) {
-      const text = await res.text();
-      const result2 = { ok: false, error: `Linear API ${res.status}: ${text.slice(0, 200)}` };
-      return result2;
+  async reconcile(repoRoot) {
+    const normalizedRepoRoot = resolve4(repoRoot);
+    const worktrees = this.deps.git.listWorktrees(normalizedRepoRoot);
+    const sessionName = buildProjectSessionName(normalizedRepoRoot);
+    let windows = [];
+    try {
+      windows = this.deps.tmux.listWindows();
+    } catch {
+      windows = [];
     }
-    const json = await res.json();
-    const result = parseIssuesResponse(json);
-    if (result.ok) {
-      issueCache = { data: result, expiry: now + CACHE_TTL_MS };
-      log.debug(`[linear] fetched ${result.data.length} assigned issues`);
-    } else {
-      log.error(`[linear] GraphQL error: ${result.error}`);
+    const seenWorktreeIds = new Set;
+    for (const entry of worktrees) {
+      if (entry.bare)
+        continue;
+      if (resolve4(entry.path) === normalizedRepoRoot)
+        continue;
+      const gitDir = this.deps.git.resolveWorktreeGitDir(entry.path);
+      const meta = await readWorktreeMeta(gitDir);
+      const branch = resolveBranch(entry, meta?.branch ?? null);
+      const worktreeId = meta?.worktreeId ?? makeUnmanagedWorktreeId(entry.path);
+      seenWorktreeIds.add(worktreeId);
+      this.deps.runtime.upsertWorktree({
+        worktreeId,
+        branch,
+        path: entry.path,
+        profile: meta?.profile ?? null,
+        agentName: meta?.agent ?? null,
+        runtime: meta?.runtime ?? "host"
+      });
+      const gitStatus = this.deps.git.readWorktreeStatus(entry.path);
+      this.deps.runtime.setGitState(worktreeId, {
+        exists: true,
+        branch,
+        dirty: gitStatus.dirty,
+        aheadCount: gitStatus.aheadCount,
+        currentCommit: gitStatus.currentCommit
+      });
+      const window = findWindow(windows, sessionName, branch);
+      this.deps.runtime.setSessionState(worktreeId, {
+        exists: window !== null,
+        sessionName: window?.sessionName ?? null,
+        paneCount: window?.paneCount ?? 0
+      });
+      if (meta) {
+        this.deps.runtime.setServices(worktreeId, await buildServiceStates(this.deps, {
+          allocatedPorts: meta.allocatedPorts,
+          startupEnvValues: meta.startupEnvValues,
+          worktreeId: meta.worktreeId,
+          branch,
+          profile: meta.profile,
+          agent: meta.agent,
+          runtime: meta.runtime
+        }));
+      } else {
+        this.deps.runtime.setServices(worktreeId, []);
+      }
+      this.deps.runtime.setPrs(worktreeId, await readWorktreePrs(gitDir));
     }
-    return result;
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    log.error(`[linear] fetch failed: ${msg}`);
-    return { ok: false, error: msg };
+    for (const state of this.deps.runtime.listWorktrees()) {
+      if (!seenWorktreeIds.has(state.worktreeId)) {
+        this.deps.runtime.removeWorktree(state.worktreeId);
+      }
+    }
+  }
+}
+
+// backend/src/services/snapshot-service.ts
+function formatElapsedSince(startedAt, now) {
+  if (!startedAt)
+    return "";
+  const startedMs = Date.parse(startedAt);
+  if (Number.isNaN(startedMs))
+    return "";
+  const diffMs = Math.max(0, now().getTime() - startedMs);
+  const diffMinutes = Math.floor(diffMs / 60000);
+  if (diffMinutes < 1)
+    return "0m";
+  if (diffMinutes < 60)
+    return `${diffMinutes}m`;
+  const diffHours = Math.floor(diffMinutes / 60);
+  if (diffHours < 24)
+    return `${diffHours}h`;
+  const diffDays = Math.floor(diffHours / 24);
+  return `${diffDays}d`;
+}
+function clonePrEntry2(pr) {
+  return {
+    ...pr,
+    ciChecks: pr.ciChecks.map((check) => ({ ...check })),
+    comments: pr.comments.map((comment) => ({ ...comment }))
+  };
+}
+function mapWorktreeSnapshot(state, now, findLinearIssue) {
+  return {
+    branch: state.branch,
+    path: state.path,
+    dir: state.path,
+    profile: state.profile,
+    agentName: state.agentName,
+    mux: state.session.exists,
+    dirty: state.git.dirty || state.git.aheadCount > 0,
+    paneCount: state.session.paneCount,
+    status: state.agent.lifecycle,
+    elapsed: formatElapsedSince(state.agent.lastStartedAt, now),
+    services: state.services.map((service) => ({ ...service })),
+    prs: state.prs.map((pr) => clonePrEntry2(pr)),
+    linearIssue: findLinearIssue ? findLinearIssue(state.branch) : null
+  };
+}
+function buildProjectSnapshot(input) {
+  const now = input.now ?? (() => new Date);
+  return {
+    project: {
+      name: input.projectName,
+      mainBranch: input.mainBranch
+    },
+    worktrees: input.runtime.listWorktrees().map((state) => mapWorktreeSnapshot(state, now, input.findLinearIssue)),
+    notifications: input.notifications.map((notification) => ({ ...notification }))
+  };
+}
+
+// backend/src/domain/events.ts
+function hasBaseFields(raw) {
+  return typeof raw.worktreeId === "string" && raw.worktreeId.length > 0 && typeof raw.branch === "string" && raw.branch.length > 0 && typeof raw.type === "string" && ["agent_stopped", "agent_status_changed", "pr_opened", "runtime_error"].includes(raw.type);
+}
+function parseRuntimeEvent(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return null;
+  if (!hasBaseFields(raw))
+    return null;
+  const event = raw;
+  switch (event.type) {
+    case "agent_stopped":
+      return {
+        worktreeId: event.worktreeId,
+        branch: event.branch,
+        type: event.type
+      };
+    case "agent_status_changed":
+      return event.lifecycle === "starting" || event.lifecycle === "running" || event.lifecycle === "idle" || event.lifecycle === "stopped" ? {
+        worktreeId: event.worktreeId,
+        branch: event.branch,
+        type: event.type,
+        lifecycle: event.lifecycle
+      } : null;
+    case "pr_opened":
+      return typeof event.url === "string" || event.url === undefined ? {
+        worktreeId: event.worktreeId,
+        branch: event.branch,
+        type: event.type,
+        ...typeof event.url === "string" ? { url: event.url } : {}
+      } : null;
+    case "runtime_error":
+      return typeof event.message === "string" && event.message.length > 0 ? {
+        worktreeId: event.worktreeId,
+        branch: event.branch,
+        type: event.type,
+        message: event.message
+      } : null;
   }
 }
 
@@ -8881,8 +10438,55 @@ var PORT = parseInt(Bun.env.BACKEND_PORT || "5111", 10);
 var STATIC_DIR = Bun.env.WEBMUX_STATIC_DIR || "";
 var PROJECT_DIR = Bun.env.WEBMUX_PROJECT_DIR || gitRoot(process.cwd());
 var config = loadConfig(PROJECT_DIR);
-var WORKTREE_CACHE_TTL_MS = 2000;
-var wtCache = null;
+var git = new BunGitGateway;
+var portProbe = new BunPortProbe;
+var tmux = new BunTmuxGateway;
+var docker = new BunDockerGateway;
+var hooks = new BunLifecycleHookRunner;
+var autoName = new AutoNameService;
+var projectRuntime = new ProjectRuntime;
+var runtimeNotifications = new NotificationService;
+var reconciliationService = new ReconciliationService({
+  config,
+  git,
+  tmux,
+  portProbe,
+  runtime: projectRuntime
+});
+var removingBranches = new Set;
+var lifecycleService = new LifecycleService({
+  projectRoot: PROJECT_DIR,
+  controlBaseUrl: `http://127.0.0.1:${PORT}`,
+  getControlToken: loadControlToken,
+  config,
+  git,
+  tmux,
+  docker,
+  reconciliation: reconciliationService,
+  hooks,
+  autoName
+});
+function getFrontendConfig() {
+  const defaultProfileName = getDefaultProfileName(config);
+  const orderedProfileEntries = Object.entries(config.profiles).sort(([left], [right]) => {
+    if (left === defaultProfileName)
+      return -1;
+    if (right === defaultProfileName)
+      return 1;
+    return 0;
+  });
+  return {
+    name: config.name,
+    services: config.services,
+    profiles: orderedProfileEntries.map(([name, profile]) => ({
+      name,
+      ...profile.systemPrompt ? { systemPrompt: profile.systemPrompt } : {}
+    })),
+    defaultProfileName,
+    autoName: config.autoName !== null,
+    startupEnvs: config.startupEnvs
+  };
+}
 function parseWsMessage(raw) {
   try {
     const str = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
@@ -8928,82 +10532,67 @@ function isValidWorktreeName(name) {
 }
 function catching(label, fn) {
   return fn().catch((err) => {
+    if (err instanceof LifecycleError) {
+      return errorResponse(err.message, err.status);
+    }
     const msg = err instanceof Error ? err.message : String(err);
     log.error(`[api:error] ${label}: ${msg}`);
     return errorResponse(msg);
   });
 }
-function safeJsonParse(str) {
+function ensureBranchNotRemoving(branch) {
+  if (removingBranches.has(branch)) {
+    throw new LifecycleError(`Worktree is being removed: ${branch}`, 409);
+  }
+}
+async function withRemovingBranch(branch, fn) {
+  ensureBranchNotRemoving(branch);
+  removingBranches.add(branch);
   try {
-    return JSON.parse(str);
-  } catch {
-    return null;
+    return await fn();
+  } finally {
+    removingBranches.delete(branch);
   }
 }
-async function getWorktreePaths() {
-  const proc = Bun.spawn(["git", "worktree", "list", "--porcelain"], { stdout: "pipe" });
-  await proc.exited;
-  const output = await new Response(proc.stdout).text();
-  const all = parseWorktreePorcelain(output);
-  const paths = new Map;
-  let isFirst = true;
-  for (const [branch, path] of all) {
-    if (isFirst) {
-      isFirst = false;
-      continue;
+async function resolveTerminalWorktree(branch) {
+  ensureBranchNotRemoving(branch);
+  await reconciliationService.reconcile(PROJECT_DIR);
+  const state = projectRuntime.getWorktreeByBranch(branch);
+  if (!state) {
+    throw new Error(`Worktree not found: ${branch}`);
+  }
+  if (!state.session.exists || !state.session.sessionName) {
+    throw new Error(`No open tmux window found for worktree: ${branch}`);
+  }
+  return {
+    worktreeId: state.worktreeId,
+    attachTarget: {
+      ownerSessionName: state.session.sessionName,
+      windowName: state.session.windowName
     }
-    paths.set(branch, path);
-    const basename = path.split("/").pop() ?? "";
-    if (basename !== branch)
-      paths.set(basename, path);
+  };
+}
+function getAttachedWorktreeId(ws) {
+  if (ws.data.attached && ws.data.worktreeId) {
+    return ws.data.worktreeId;
   }
-  return paths;
+  sendWs(ws, { type: "error", message: "Terminal not attached" });
+  return null;
 }
-async function getAllPaneCounts() {
-  const proc = Bun.spawn(["tmux", "list-windows", "-a", "-F", "#{window_name} #{window_panes}"], { stdout: "pipe", stderr: "pipe" });
-  if (await proc.exited !== 0)
-    return new Map;
-  const out = await new Response(proc.stdout).text();
-  const counts = new Map;
-  for (const line of out.trim().split(`
-`)) {
-    const spaceIdx = line.lastIndexOf(" ");
-    if (spaceIdx === -1)
-      continue;
-    const name = line.slice(0, spaceIdx);
-    if (!name.startsWith("wm-"))
+async function hasValidControlToken(req) {
+  const authHeader = req.headers.get("Authorization");
+  const token = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : null;
+  return token === await loadControlToken();
+}
+async function getWorktreeGitDirs() {
+  const gitDirs = new Map;
+  const projectRoot = resolve5(PROJECT_DIR);
+  for (const entry of git.listWorktrees(projectRoot)) {
+    if (entry.bare || resolve5(entry.path) === projectRoot || !entry.branch)
       continue;
-    const branch = name.slice(3);
-    const count = parseInt(line.slice(spaceIdx + 1), 10) || 0;
-    if (!counts.has(branch) || count > counts.get(branch)) {
-      counts.set(branch, count);
-    }
+    gitDirs.set(entry.branch, git.resolveWorktreeGitDir(entry.path));
   }
-  return counts;
-}
-function isPortListening(port) {
-  return new Promise((resolve2) => {
-    const timer = setTimeout(() => resolve2(false), 300);
-    Bun.connect({
-      hostname: "127.0.0.1",
-      port,
-      socket: {
-        open(socket) {
-          clearTimeout(timer);
-          socket.end();
-          resolve2(true);
-        },
-        error() {
-          clearTimeout(timer);
-          resolve2(false);
-        },
-        data() {}
-      }
-    }).catch(() => {
-      clearTimeout(timer);
-      resolve2(false);
-    });
-  });
+  return gitDirs;
 }
 function makeCallbacks(ws) {
   return {
@@ -9017,61 +10606,56 @@ function makeCallbacks(ws) {
     }
   };
 }
-async function apiGetWorktrees(req) {
-  touchActivity();
-  const now = Date.now();
-  if (wtCache && now < wtCache.expiry) {
-    if (req.headers.get("if-none-match") === wtCache.etag) {
-      return new Response(null, { status: 304 });
-    }
-    return new Response(wtCache.json, {
-      headers: { "Content-Type": "application/json", ETag: wtCache.etag }
-    });
-  }
-  const [worktrees, status, wtPaths, paneCounts, linearResult] = await Promise.all([
-    listWorktrees(),
-    getStatus(),
-    getWorktreePaths(),
-    getAllPaneCounts(),
-    fetchAssignedIssues()
+async function apiGetProject() {
+  touchDashboardActivity();
+  const linearIssuesPromise = config.integrations.linear.enabled ? fetchAssignedIssues() : Promise.resolve({ ok: true, data: [] });
+  const [, linearResult] = await Promise.all([
+    reconciliationService.reconcile(PROJECT_DIR),
+    linearIssuesPromise
   ]);
   const linearIssues = linearResult.ok ? linearResult.data : [];
-  const activeBranches = new Set(worktrees.map((wt) => wt.branch));
-  activeBranches.add("main");
-  cleanupStaleWindows(activeBranches, `${PROJECT_DIR}__worktrees/`);
-  const nonMainWorktrees = worktrees.filter((wt) => wtPaths.has(wt.branch));
-  const merged = await Promise.all(nonMainWorktrees.map(async (wt) => {
-    const st = status.find((s) => s.worktree.includes(wt.branch) || s.worktree.startsWith(wt.branch));
-    const wtDir = wtPaths.get(wt.branch);
-    const env = wtDir ? await readEnvLocal(wtDir) : {};
-    const dirty = wtDir ? await checkDirty(wtDir) : false;
-    const services = await Promise.all(config.services.map(async (svc) => {
-      const port = env[svc.portEnv] ? parseInt(env[svc.portEnv], 10) : null;
-      const running = port !== null && port >= 1 && port <= 65535 ? await isPortListening(port) : false;
-      return { name: svc.name, port, running };
-    }));
-    const matchedIssue = linearIssues.find((issue) => branchMatchesIssue(wt.branch, issue.branchName));
-    const linearIssue = matchedIssue ? { identifier: matchedIssue.identifier, url: matchedIssue.url, state: matchedIssue.state } : null;
-    return {
-      ...wt,
-      dir: wtDir ?? null,
-      dirty,
-      status: st?.status ?? "",
-      elapsed: st?.elapsed ?? "",
-      title: st?.title ?? "",
-      profile: env.PROFILE || null,
-      agentName: env.AGENT || null,
-      services,
-      paneCount: wt.mux === "\u2713" ? paneCounts.get(wt.branch) ?? 0 : 0,
-      prs: env.PR_DATA ? (safeJsonParse(env.PR_DATA) ?? []).map((pr) => ({ ...pr, comments: pr.comments ?? [] })) : [],
-      linearIssue
-    };
+  return jsonResponse(buildProjectSnapshot({
+    projectName: config.name,
+    mainBranch: config.workspace.mainBranch,
+    runtime: projectRuntime,
+    notifications: runtimeNotifications.list(),
+    findLinearIssue: (branch) => {
+      const match = linearIssues.find((issue) => branchMatchesIssue(branch, issue.branchName));
+      return match ? {
+        identifier: match.identifier,
+        url: match.url,
+        state: match.state
+      } : null;
+    }
   }));
-  const json = JSON.stringify(merged);
-  const etag = `"${Bun.hash(json).toString(36)}"`;
-  wtCache = { json, etag, expiry: now + WORKTREE_CACHE_TTL_MS };
-  return new Response(json, {
-    headers: { "Content-Type": "application/json", ETag: etag }
+}
+async function apiRuntimeEvent(req) {
+  if (!await hasValidControlToken(req)) {
+    return new Response("Unauthorized", { status: 401 });
+  }
+  let raw;
+  try {
+    raw = await req.json();
+  } catch {
+    return errorResponse("Invalid JSON", 400);
+  }
+  const event = parseRuntimeEvent(raw);
+  if (!event)
+    return errorResponse("Invalid runtime event body", 400);
+  await reconciliationService.reconcile(PROJECT_DIR);
+  try {
+    projectRuntime.applyEvent(event);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("Unknown worktree id")) {
+      return errorResponse(message, 404);
+    }
+    throw error;
+  }
+  const notification = runtimeNotifications.recordEvent(event);
+  return jsonResponse({
+    ok: true,
+    ...notification ? { notification } : {}
   });
 }
 async function apiCreateWorktree(req) {
@@ -9080,12 +10664,6 @@ async function apiCreateWorktree(req) {
     return errorResponse("Invalid request body", 400);
   }
   const body = raw;
-  const branch = typeof body.branch === "string" ? body.branch : undefined;
-  const prompt = typeof body.prompt === "string" ? body.prompt : undefined;
-  const profileName = typeof body.profile === "string" ? body.profile : config.profiles.default.name;
-  const agent = typeof body.agent === "string" ? body.agent : "claude";
-  const isSandbox = config.profiles.sandbox !== undefined && profileName === config.profiles.sandbox.name;
-  const profileConfig = isSandbox ? config.profiles.sandbox : config.profiles.default;
   let envOverrides;
   if (body.envOverrides && typeof body.envOverrides === "object" && !Array.isArray(body.envOverrides)) {
     const raw2 = body.envOverrides;
@@ -9097,55 +10675,41 @@ async function apiCreateWorktree(req) {
     if (Object.keys(parsed).length > 0)
       envOverrides = parsed;
   }
-  log.info(`[worktree:add] agent=${agent} profile=${profileName}${branch ? ` branch=${branch}` : ""}${prompt ? ` prompt="${prompt.slice(0, 80)}"` : ""}`);
-  const result = await addWorktree(branch, {
+  const branch = typeof body.branch === "string" ? body.branch : undefined;
+  const prompt = typeof body.prompt === "string" ? body.prompt : undefined;
+  const profile = typeof body.profile === "string" ? body.profile : undefined;
+  const agent = body.agent === "claude" || body.agent === "codex" ? body.agent : undefined;
+  log.info(`[worktree:add]${branch ? ` branch=${branch}` : ""}${profile ? ` profile=${profile}` : ""}${agent ? ` agent=${agent}` : ""}${prompt ? ` prompt="${prompt.slice(0, 80)}"` : ""}`);
+  const result = await lifecycleService.createWorktree({
+    branch,
     prompt,
-    profile: profileName,
+    profile,
     agent,
-    autoName: config.autoName,
-    profileConfig,
-    isSandbox,
-    sandboxConfig: isSandbox ? config.profiles.sandbox : undefined,
-    services: config.services,
-    mainRepoDir: PROJECT_DIR,
     envOverrides
   });
-  if (!result.ok)
-    return errorResponse(result.error, 422);
-  log.debug(`[worktree:add] done branch=${result.branch}: ${result.output}`);
-  wtCache = null;
+  log.debug(`[worktree:add] done branch=${result.branch} worktreeId=${result.worktreeId}`);
   return jsonResponse({ branch: result.branch }, 201);
 }
 async function apiDeleteWorktree(name) {
-  log.info(`[worktree:rm] name=${name}`);
-  const result = await removeWorktree(name);
-  if (!result.ok)
-    return errorResponse(result.error, 422);
-  log.debug(`[worktree:rm] done name=${name}: ${result.output}`);
-  wtCache = null;
-  return jsonResponse({ message: result.output });
+  return withRemovingBranch(name, async () => {
+    log.info(`[worktree:rm] name=${name}`);
+    await lifecycleService.removeWorktree(name);
+    log.debug(`[worktree:rm] done name=${name}`);
+    return jsonResponse({ ok: true });
+  });
 }
 async function apiOpenWorktree(name) {
+  ensureBranchNotRemoving(name);
   log.info(`[worktree:open] name=${name}`);
-  const wtPaths = await getWorktreePaths();
-  const wtDir = wtPaths.get(name);
-  if (wtDir) {
-    const env = await readEnvLocal(wtDir);
-    if (!env.PROFILE) {
-      log.info(`[worktree:open] initializing env for ${name}`);
-      await initWorktreeEnv(name, {
-        profile: config.profiles.default.name,
-        agent: "claude",
-        services: config.services
-      });
-      wtCache = null;
-    }
-  }
-  const result = await openWorktree(name);
-  if (!result.ok)
-    return errorResponse(result.error, 422);
-  wtCache = null;
-  return jsonResponse({ message: result.output });
+  const result = await lifecycleService.openWorktree(name);
+  log.debug(`[worktree:open] done name=${name} worktreeId=${result.worktreeId}`);
+  return jsonResponse({ ok: true });
+}
+async function apiCloseWorktree(name) {
+  log.info(`[worktree:close] name=${name}`);
+  await lifecycleService.closeWorktree(name);
+  log.debug(`[worktree:close] done name=${name}`);
+  return jsonResponse({ ok: true });
 }
 async function apiSendPrompt(name, req) {
   const raw = await req.json();
@@ -9158,26 +10722,17 @@ async function apiSendPrompt(name, req) {
     return errorResponse("Missing 'text' field", 400);
   const preamble = typeof body.preamble === "string" ? body.preamble : undefined;
   log.info(`[worktree:send] name=${name} text="${text.slice(0, 80)}"`);
-  const result = await sendPrompt(name, text, 0, preamble);
+  const terminalWorktree = await resolveTerminalWorktree(name);
+  const result = await sendPrompt(terminalWorktree.worktreeId, terminalWorktree.attachTarget, text, 0, preamble);
   if (!result.ok)
     return errorResponse(result.error, 503);
   return jsonResponse({ ok: true });
 }
 async function apiMergeWorktree(name) {
   log.info(`[worktree:merge] name=${name}`);
-  const result = await mergeWorktree(name);
-  if (!result.ok)
-    return errorResponse(result.error, 422);
-  log.debug(`[worktree:merge] done name=${name}: ${result.output}`);
-  wtCache = null;
-  return jsonResponse({ message: result.output });
-}
-async function apiWorktreeStatus(name) {
-  const statuses = await getStatus();
-  const match = statuses.find((s) => s.worktree.includes(name));
-  if (!match)
-    return errorResponse("Worktree status not found", 404);
-  return jsonResponse(match);
+  await lifecycleService.mergeWorktree(name);
+  log.debug(`[worktree:merge] done name=${name}`);
+  return jsonResponse({ ok: true });
 }
 async function apiGetLinearIssues() {
   const result = await fetchAssignedIssues();
@@ -9205,17 +10760,19 @@ Bun.serve({
   idleTimeout: 255,
   routes: {
     "/ws/:worktree": (req, server) => {
-      const worktree = decodeURIComponent(req.params.worktree);
-      return server.upgrade(req, { data: { worktree, attached: false } }) ? undefined : new Response("WebSocket upgrade failed", { status: 400 });
-    },
-    "/rpc/workmux": {
-      POST: (req) => handleWorkmuxRpc(req)
+      const branch = decodeURIComponent(req.params.worktree);
+      return server.upgrade(req, { data: { branch, worktreeId: null, attached: false } }) ? undefined : new Response("WebSocket upgrade failed", { status: 400 });
     },
     "/api/config": {
-      GET: () => jsonResponse(config)
+      GET: () => jsonResponse(getFrontendConfig())
+    },
+    "/api/project": {
+      GET: () => catching("GET /api/project", () => apiGetProject())
+    },
+    "/api/runtime/events": {
+      POST: (req) => catching("POST /api/runtime/events", () => apiRuntimeEvent(req))
     },
     "/api/worktrees": {
-      GET: (req) => catching("GET /api/worktrees", () => apiGetWorktrees(req)),
       POST: (req) => catching("POST /api/worktrees", () => apiCreateWorktree(req))
     },
     "/api/worktrees/:name": {
@@ -9234,28 +10791,28 @@ Bun.serve({
         return catching(`POST /api/worktrees/${name}/open`, () => apiOpenWorktree(name));
       }
     },
-    "/api/worktrees/:name/send": {
+    "/api/worktrees/:name/close": {
       POST: (req) => {
         const name = decodeURIComponent(req.params.name);
         if (!isValidWorktreeName(name))
           return errorResponse("Invalid worktree name", 400);
-        return catching(`POST /api/worktrees/${name}/send`, () => apiSendPrompt(name, req));
+        return catching(`POST /api/worktrees/${name}/close`, () => apiCloseWorktree(name));
       }
     },
-    "/api/worktrees/:name/merge": {
+    "/api/worktrees/:name/send": {
       POST: (req) => {
         const name = decodeURIComponent(req.params.name);
         if (!isValidWorktreeName(name))
           return errorResponse("Invalid worktree name", 400);
-        return catching(`POST /api/worktrees/${name}/merge`, () => apiMergeWorktree(name));
+        return catching(`POST /api/worktrees/${name}/send`, () => apiSendPrompt(name, req));
       }
     },
-    "/api/worktrees/:name/status": {
-      GET: (req) => {
+    "/api/worktrees/:name/merge": {
+      POST: (req) => {
         const name = decodeURIComponent(req.params.name);
         if (!isValidWorktreeName(name))
           return errorResponse("Invalid worktree name", 400);
-        return catching(`GET /api/worktrees/${name}/status`, () => apiWorktreeStatus(name));
+        return catching(`POST /api/worktrees/${name}/merge`, () => apiMergeWorktree(name));
       }
     },
     "/api/linear/issues": {
@@ -9265,14 +10822,16 @@ Bun.serve({
       GET: (req) => catching(`GET /api/ci-logs/${req.params.runId}`, () => apiCiLogs(req.params.runId))
     },
     "/api/notifications/stream": {
-      GET: () => handleNotificationStream()
+      GET: () => runtimeNotifications.stream()
     },
     "/api/notifications/:id/dismiss": {
       POST: (req) => {
         const id = parseInt(req.params.id, 10);
         if (isNaN(id))
           return errorResponse("Invalid notification ID", 400);
-        return handleDismissNotification(id);
+        if (!runtimeNotifications.dismiss(id))
+          return errorResponse("Not found", 404);
+        return jsonResponse({ ok: true });
       }
     }
   },
@@ -9280,9 +10839,9 @@ Bun.serve({
     if (STATIC_DIR) {
       const url = new URL(req.url);
       const rawPath = url.pathname === "/" ? "index.html" : url.pathname;
-      const filePath = join2(STATIC_DIR, rawPath);
-      const staticRoot = resolve(STATIC_DIR);
-      if (!resolve(filePath).startsWith(staticRoot + "/")) {
+      const filePath = join5(STATIC_DIR, rawPath);
+      const staticRoot = resolve5(STATIC_DIR);
+      if (!resolve5(filePath).startsWith(staticRoot + "/")) {
         return new Response("Forbidden", { status: 403 });
       }
       const file = Bun.file(filePath);
@@ -9290,7 +10849,7 @@ Bun.serve({
         const headers = rawPath.startsWith("/assets/") ? { "Cache-Control": "public, max-age=31536000, immutable" } : {};
         return new Response(file, { headers });
       }
-      return new Response(Bun.file(join2(STATIC_DIR, "index.html")), {
+      return new Response(Bun.file(join5(STATIC_DIR, "index.html")), {
         headers: { "Cache-Control": "no-cache" }
       });
     }
@@ -9299,7 +10858,7 @@ Bun.serve({
   websocket: {
     data: {},
     open(ws) {
-      log.debug(`[ws] open worktree=${ws.data.worktree}`);
+      log.debug(`[ws] open branch=${ws.data.branch}`);
     },
     async message(ws, message) {
       const msg = parseWsMessage(message);
@@ -9307,52 +10866,72 @@ Bun.serve({
         sendWs(ws, { type: "error", message: "malformed message" });
         return;
       }
-      const { worktree } = ws.data;
+      const { branch } = ws.data;
       switch (msg.type) {
-        case "input":
-          write(worktree, msg.data);
+        case "input": {
+          const worktreeId = getAttachedWorktreeId(ws);
+          if (!worktreeId)
+            return;
+          write(worktreeId, msg.data);
           break;
-        case "sendKeys":
-          await sendKeys(worktree, msg.hexBytes);
+        }
+        case "sendKeys": {
+          const worktreeId = getAttachedWorktreeId(ws);
+          if (!worktreeId)
+            return;
+          await sendKeys(worktreeId, msg.hexBytes);
           break;
+        }
         case "selectPane":
-          if (ws.data.attached) {
-            log.debug(`[ws] selectPane pane=${msg.pane} worktree=${worktree}`);
-            await selectPane(worktree, msg.pane);
+          {
+            const worktreeId = getAttachedWorktreeId(ws);
+            if (!worktreeId)
+              return;
+            log.debug(`[ws] selectPane pane=${msg.pane} branch=${branch} worktreeId=${worktreeId}`);
+            await selectPane(worktreeId, msg.pane);
           }
           break;
         case "resize":
           if (!ws.data.attached) {
             ws.data.attached = true;
-            log.debug(`[ws] first resize (attaching) worktree=${worktree} cols=${msg.cols} rows=${msg.rows}`);
+            log.debug(`[ws] first resize (attaching) branch=${branch} cols=${msg.cols} rows=${msg.rows}`);
             try {
               if (msg.initialPane !== undefined) {
-                log.debug(`[ws] initialPane=${msg.initialPane} worktree=${worktree}`);
+                log.debug(`[ws] initialPane=${msg.initialPane} branch=${branch}`);
               }
-              await attach(worktree, msg.cols, msg.rows, msg.initialPane);
+              const terminalWorktree = await resolveTerminalWorktree(branch);
+              ws.data.worktreeId = terminalWorktree.worktreeId;
+              await attach(terminalWorktree.worktreeId, terminalWorktree.attachTarget, msg.cols, msg.rows, msg.initialPane);
               const { onData, onExit } = makeCallbacks(ws);
-              setCallbacks(worktree, onData, onExit);
-              const scrollback = getScrollback(worktree);
-              log.debug(`[ws] attached worktree=${worktree} scrollback=${scrollback.length} bytes`);
+              setCallbacks(terminalWorktree.worktreeId, onData, onExit);
+              const scrollback = getScrollback(terminalWorktree.worktreeId);
+              log.debug(`[ws] attached branch=${branch} worktreeId=${terminalWorktree.worktreeId} scrollback=${scrollback.length} bytes`);
               if (scrollback.length > 0) {
                 sendWs(ws, { type: "scrollback", data: scrollback });
               }
             } catch (err) {
               const errMsg = err instanceof Error ? err.message : String(err);
-              log.error(`[ws] attach failed worktree=${worktree}: ${errMsg}`);
+              ws.data.attached = false;
+              ws.data.worktreeId = null;
+              log.error(`[ws] attach failed branch=${branch}: ${errMsg}`);
               sendWs(ws, { type: "error", message: errMsg });
               ws.close(1011, errMsg.slice(0, 123));
             }
           } else {
-            await resize(worktree, msg.cols, msg.rows);
+            const worktreeId = getAttachedWorktreeId(ws);
+            if (!worktreeId)
+              return;
+            await resize(worktreeId, msg.cols, msg.rows);
           }
           break;
       }
     },
     async close(ws) {
-      log.debug(`[ws] close worktree=${ws.data.worktree} attached=${ws.data.attached}`);
-      clearCallbacks(ws.data.worktree);
-      await detach(ws.data.worktree);
+      log.debug(`[ws] close branch=${ws.data.branch} attached=${ws.data.attached} worktreeId=${ws.data.worktreeId}`);
+      if (ws.data.worktreeId) {
+        clearCallbacks(ws.data.worktreeId);
+        await detach(ws.data.worktreeId);
+      }
     }
   }
 });
@@ -9362,10 +10941,7 @@ if (tmuxCheck.exitCode !== 0) {
   log.info("Started tmux session");
 }
 cleanupStaleSessions();
-startPrMonitor(getWorktreePaths, config.linkedRepos, PROJECT_DIR, undefined, hasDashboardActivity);
-installHookScripts().catch((err) => {
-  log.error(`[notify] failed to install hook scripts: ${err instanceof Error ? err.message : String(err)}`);
-});
+startPrMonitor(getWorktreeGitDirs, config.integrations.github.linkedRepos, PROJECT_DIR, undefined, hasRecentDashboardActivity);
 log.info(`Dev Dashboard API running at http://localhost:${PORT}`);
 var nets = networkInterfaces();
 for (const addrs of Object.values(nets)) {