wmdev 0.2.3 → 0.4.0

package/backend/dist/server.js

@@ -6931,6 +6931,7 @@ var log = {
 
 // backend/src/workmux.ts
 var {$ } = globalThis.Bun;
+import { mkdir as mkdir2 } from "fs/promises";
 
 // backend/src/env.ts
 async function readEnvLocal(wtDir) {
@@ -6940,8 +6941,13 @@ async function readEnvLocal(wtDir) {
     for (const line of text.split(`
 `)) {
       const match = line.match(/^(\w+)=(.*)$/);
-      if (match)
-        env[match[1]] = match[2];
+      if (match) {
+        let val = match[2];
+        if (val.length >= 2 && val.startsWith("'") && val.endsWith("'")) {
+          val = val.slice(1, -1);
+        }
+        env[match[1]] = val;
+      }
     }
     return env;
   } catch {
@@ -6958,26 +6964,22 @@ async function writeEnvLocal(wtDir, entries) {
 `);
   } catch {}
   for (const [key, value] of Object.entries(entries)) {
+    const needsQuoting = /[{}"\s$`\\!#|;&()<>]/.test(value);
+    const safe = needsQuoting ? `'${value}'` : value;
     const pattern = new RegExp(`^${key}=`);
     const idx = lines.findIndex((l) => pattern.test(l));
     if (idx >= 0) {
-      lines[idx] = `${key}=${value}`;
+      lines[idx] = `${key}=${safe}`;
     } else {
-      lines.push(`${key}=${value}`);
+      lines.push(`${key}=${safe}`);
     }
   }
   await Bun.write(filePath, lines.join(`
 `) + `
 `);
 }
-async function readAllWorktreeEnvs(worktreePaths, excludeDir) {
-  const results = [];
-  for (const p of worktreePaths) {
-    if (excludeDir && p === excludeDir)
-      continue;
-    results.push(await readEnvLocal(p));
-  }
-  return results;
+function readAllWorktreeEnvs(worktreePaths, excludeDir) {
+  return Promise.all(worktreePaths.filter((p) => !excludeDir || p !== excludeDir).map((p) => readEnvLocal(p)));
 }
 function allocatePorts(existingEnvs, services) {
   const allocatable = services.filter((s) => s.portStart != null);
@@ -7103,6 +7105,7 @@ function loadConfig(dir) {
       alias: typeof r.alias === "string" ? r.alias : r.repo.split("/").pop()
     })) : [];
     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,
@@ -7332,7 +7335,7 @@ async function launchContainer(opts) {
   const name = containerName(branch);
   const home = Bun.env.HOME ?? "/root";
   const rpcSecret = await loadRpcSecret();
-  const rpcPort = Bun.env.DASHBOARD_PORT ?? "5111";
+  const rpcPort = Bun.env.BACKEND_PORT ?? "5111";
   let sshAuthSock = Bun.env.SSH_AUTH_SOCK;
   if (sshAuthSock) {
     try {
@@ -7488,19 +7491,30 @@ function workmuxEnv() {
   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;
+}
 async function listWorktrees() {
-  const result = await $`workmux list`.env(workmuxEnv()).text();
-  return parseTable(result, (cols) => ({
-    branch: cols[0] ?? "",
-    agent: cols[1] ?? "",
-    mux: cols[2] ?? "",
-    unmerged: cols[3] ?? "",
-    path: cols[4] ?? ""
-  }), WORKTREE_HEADERS);
+  const proc = await $`workmux list`.env(workmuxEnv()).nothrow().quiet();
+  if (proc.exitCode !== 0) {
+    ensureTmux();
+    return [];
+  }
+  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 result = await $`workmux status`.env(workmuxEnv()).text();
-  return parseTable(result, (cols) => ({
+  const proc = await $`workmux status`.env(workmuxEnv()).nothrow().quiet();
+  if (proc.exitCode !== 0) {
+    ensureTmux();
+    return [];
+  }
+  return parseTable(proc.text(), (cols) => ({
     worktree: cols[0] ?? "",
     status: cols[1] ?? "",
     elapsed: cols[2] ?? "",
@@ -7645,6 +7659,26 @@ async function addWorktree(rawBranch, opts) {
     const existingEnvs = await readAllWorktreeEnvs(allPaths, wtDir);
     const portAssignments = opts?.services ? allocatePorts(existingEnvs, opts.services) : {};
     await writeEnvLocal(wtDir, { ...portAssignments, PROFILE: profile, AGENT: agent });
+    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) + `
+`);
   }
   const env = wtDir ? await readEnvLocal(wtDir) : {};
   log.debug(`[workmux:add] branch=${branch} dir=${wtDir ?? "(not found)"} env=${JSON.stringify(env)}`);
@@ -7766,6 +7800,33 @@ async function openWorktree(name) {
     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;
+}
 async function mergeWorktree(name) {
   log.debug(`[workmux:merge] running: workmux merge ${name}`);
   await removeContainer(name);
@@ -7776,7 +7837,9 @@ async function mergeWorktree(name) {
 }
 
 // backend/src/terminal.ts
-var DASH_PORT = Bun.env.DASHBOARD_PORT || "5111";
+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;
@@ -7811,7 +7874,7 @@ function cleanupStaleSessions() {
     const result = Bun.spawnSync(["tmux", "list-sessions", "-F", "#{session_name}"], { stdout: "pipe", stderr: "pipe" });
     if (result.exitCode !== 0)
       return;
-    const lines = new TextDecoder().decode(result.stdout).trim().split(`
+    const lines = textDecoder.decode(result.stdout).trim().split(`
 `);
     for (const name of lines) {
       if (name.startsWith(SESSION_PREFIX)) {
@@ -7823,7 +7886,7 @@ function cleanupStaleSessions() {
 function killTmuxSession(name) {
   const result = Bun.spawnSync(["tmux", "kill-session", "-t", name], { stderr: "pipe" });
   if (result.exitCode !== 0) {
-    const stderr = new TextDecoder().decode(result.stderr).trim();
+    const stderr = textDecoder.decode(result.stderr).trim();
     if (!stderr.includes("can't find session")) {
       log.warn(`[term] killTmuxSession(${name}) exit=${result.exitCode} ${stderr}`);
     }
@@ -7901,13 +7964,12 @@ async function attach(worktreeName, cols, rows, initialPane) {
         const { done, value } = await reader.read();
         if (done)
           break;
-        const str = new TextDecoder().decode(value);
-        const encoder = new TextEncoder;
-        session.scrollbackBytes += encoder.encode(str).byteLength;
+        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 -= encoder.encode(removed).byteLength;
+          session.scrollbackBytes -= textEncoder.encode(removed).byteLength;
         }
         session.onData?.(str);
       }
@@ -7924,7 +7986,7 @@ async function attach(worktreeName, cols, rows, initialPane) {
         const { done, value } = await reader.read();
         if (done)
           break;
-        log.debug(`[term] stderr(${worktreeName}): ${new TextDecoder().decode(value).trimEnd()}`);
+        log.debug(`[term] stderr(${worktreeName}): ${textDecoder.decode(value).trimEnd()}`);
       }
     } catch {}
   })();
@@ -7959,7 +8021,7 @@ function write(worktreeName, data) {
     return;
   }
   try {
-    session.proc.stdin.write(new TextEncoder().encode(data));
+    session.proc.stdin.write(textEncoder.encode(data));
     session.proc.stdin.flush();
   } catch (err) {
     log.error(`[term] write(${worktreeName}) stdin closed`, err);
@@ -8043,6 +8105,20 @@ function mapChecks(checks) {
     runId: parseRunId(c.detailsUrl)
   }));
 }
+function parseReviewComments(json) {
+  const raw = JSON.parse(json);
+  const sorted = raw.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+  return sorted.slice(0, PR_FETCH_LIMIT).map((c) => ({
+    type: "inline",
+    author: c.user?.login ?? "unknown",
+    body: c.body ?? "",
+    createdAt: c.created_at ?? "",
+    path: c.path ?? "",
+    line: c.line ?? null,
+    diffHunk: c.diff_hunk ?? "",
+    isReply: c.in_reply_to_id !== undefined
+  }));
+}
 function parsePrResponse(json, repoLabel) {
   const prs = new Map;
   const entries = JSON.parse(json);
@@ -8057,6 +8133,7 @@ function parsePrResponse(json, repoLabel) {
       ciStatus: summarizeChecks(entry.statusCheckRollup),
       ciChecks: mapChecks(entry.statusCheckRollup),
       comments: (entry.comments ?? []).map((c) => ({
+        type: "comment",
         author: c.author?.login ?? "unknown",
         body: c.body ?? "",
         createdAt: c.createdAt ?? ""
@@ -8107,6 +8184,45 @@ async function fetchAllPrs(repoSlug, repoLabel, cwd) {
     return { ok: false, error: `failed to parse gh output for ${label}: ${err}` };
   }
 }
+async function mapWithConcurrency(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  async function worker() {
+    while (next < items.length) {
+      const idx = next++;
+      results[idx] = await fn(items[idx]);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
+  return results;
+}
+async function fetchReviewComments(prNumber, repoSlug, cwd) {
+  const repoFlag = repoSlug ? repoSlug : "{owner}/{repo}";
+  const args = [
+    "gh",
+    "api",
+    `repos/${repoFlag}/pulls/${prNumber}/comments`,
+    "--paginate"
+  ];
+  const proc = Bun.spawn(args, {
+    stdout: "pipe",
+    stderr: "pipe",
+    ...cwd ? { cwd } : {}
+  });
+  const timeout = Bun.sleep(GH_TIMEOUT_MS).then(() => {
+    proc.kill();
+    return "timeout";
+  });
+  const raceResult = await Promise.race([proc.exited, timeout]);
+  if (raceResult === "timeout" || raceResult !== 0)
+    return [];
+  try {
+    const json = await new Response(proc.stdout).text();
+    return parseReviewComments(json);
+  } catch {
+    return [];
+  }
+}
 async function fetchPrState(url) {
   const proc = Bun.spawn(["gh", "pr", "view", url, "--json", "state"], {
     stdout: "pipe",
@@ -8163,6 +8279,22 @@ async function syncPrStatus(getWorktreePaths, linkedRepos, projectDir) {
       branchPrs.set(branch, existing);
     }
   }
+  const reviewTuples = [];
+  for (const entries of branchPrs.values()) {
+    for (const entry of entries) {
+      if (entry.state === "open") {
+        const repoSlug = entry.repo ? linkedRepos.find((lr) => lr.alias === entry.repo)?.repo : undefined;
+        reviewTuples.push({ entry, repoSlug });
+      }
+    }
+  }
+  if (reviewTuples.length > 0) {
+    const reviewResults = await mapWithConcurrency(reviewTuples, 5, (t) => fetchReviewComments(t.entry.number, t.repoSlug, projectDir));
+    for (let i = 0;i < reviewTuples.length; i++) {
+      const entry = reviewTuples[i].entry;
+      entry.comments = [...entry.comments, ...reviewResults[i]].sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+    }
+  }
   const wtPaths = await getWorktreePaths();
   const seen = new Set;
   for (const [branch, entries] of branchPrs) {
@@ -8208,6 +8340,169 @@ 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);
+    }
+  }
+}
+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));
+      }
+    },
+    cancel() {
+      sseClients.delete(ctrl);
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    }
+  });
+}
+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" }
+  });
+}
+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)
@@ -8251,6 +8546,14 @@ async function handleWorkmuxRpc(req) {
   if (!command) {
     return jsonResponse({ ok: false, error: "Missing command" }, 400);
   }
+  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" });
+    }
+    return jsonResponse({ ok: false, error: `Unknown notification type: ${type}` }, 400);
+  }
   try {
     const env = tmuxEnv();
     if (command === "set-window-status" && branch) {
@@ -8279,11 +8582,130 @@ async function handleWorkmuxRpc(req) {
   }
 }
 
+// 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
+  }));
+  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;
+}
+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 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/server.ts
-var PORT = parseInt(Bun.env.DASHBOARD_PORT || "5111", 10);
+var PORT = parseInt(Bun.env.BACKEND_PORT || "5111", 10);
 var STATIC_DIR = Bun.env.WMDEV_STATIC_DIR || "";
 var PROJECT_DIR = Bun.env.WMDEV_PROJECT_DIR || gitRoot(process.cwd());
 var config = loadConfig(PROJECT_DIR);
+var WORKTREE_CACHE_TTL_MS = 2000;
+var wtCache = null;
 function parseWsMessage(raw) {
   try {
     const str = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
@@ -8311,7 +8733,16 @@ function parseWsMessage(raw) {
   }
 }
 function sendWs(ws, msg) {
-  ws.send(JSON.stringify(msg));
+  switch (msg.type) {
+    case "output":
+      ws.send("o" + msg.data);
+      break;
+    case "scrollback":
+      ws.send("s" + msg.data);
+      break;
+    default:
+      ws.send(JSON.stringify(msg));
+  }
 }
 function isValidWorktreeName(name) {
   return name.length > 0 && /^[a-z0-9][a-z0-9\-_./]*$/.test(name) && !name.includes("..");
@@ -8349,25 +8780,48 @@ async function getWorktreePaths() {
   }
   return paths;
 }
-async function getTmuxPaneCount(branch) {
-  const proc = Bun.spawn(["tmux", "list-panes", "-t", `wm-${branch}`, "-F", "#{pane_index}"], { stdout: "pipe", stderr: "pipe" });
-  const exitCode = await proc.exited;
-  if (exitCode !== 0)
-    return 0;
+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();
-  return out.trim().split(`
-`).filter(Boolean).length;
+  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-"))
+      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);
+    }
+  }
+  return counts;
 }
 function isPortListening(port) {
   return new Promise((resolve2) => {
-    const timeout = setTimeout(() => {
-      resolve2(false);
-    }, 1000);
-    fetch(`http://127.0.0.1:${port}/`, { signal: AbortSignal.timeout(1000) }).then(() => {
-      clearTimeout(timeout);
-      resolve2(true);
+    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(timeout);
+      clearTimeout(timer);
       resolve2(false);
     });
   });
@@ -8384,35 +8838,57 @@ function makeCallbacks(ws) {
     }
   };
 }
-async function apiGetWorktrees() {
-  const [worktrees, status, wtPaths] = await Promise.all([
+async function apiGetWorktrees(req) {
+  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()
+    getWorktreePaths(),
+    getAllPaneCounts(),
+    fetchAssignedIssues()
   ]);
+  const linearIssues = linearResult.ok ? linearResult.data : [];
   const merged = await Promise.all(worktrees.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" ? await getTmuxPaneCount(wt.branch) : 0,
-      prs: env.PR_DATA ? (safeJsonParse(env.PR_DATA) ?? []).map((pr) => ({ ...pr, comments: pr.comments ?? [] })) : []
+      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(merged);
+  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 apiCreateWorktree(req) {
   const raw = await req.json();
@@ -8441,6 +8917,7 @@ async function apiCreateWorktree(req) {
   if (!result.ok)
     return errorResponse(result.error, 422);
   log.debug(`[worktree:add] done branch=${result.branch}: ${result.output}`);
+  wtCache = null;
   return jsonResponse({ branch: result.branch }, 201);
 }
 async function apiDeleteWorktree(name) {
@@ -8449,6 +8926,7 @@ async function apiDeleteWorktree(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 });
 }
 async function apiOpenWorktree(name) {
@@ -8480,6 +8958,7 @@ async function apiMergeWorktree(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) {
@@ -8489,6 +8968,12 @@ async function apiWorktreeStatus(name) {
     return errorResponse("Worktree status not found", 404);
   return jsonResponse(match);
 }
+async function apiGetLinearIssues() {
+  const result = await fetchAssignedIssues();
+  if (!result.ok)
+    return errorResponse(result.error, 502);
+  return jsonResponse(result.data);
+}
 async function apiCiLogs(runId) {
   if (!/^\d+$/.test(runId))
     return errorResponse("Invalid run ID", 400);
@@ -8519,7 +9004,7 @@ Bun.serve({
       GET: () => jsonResponse(config)
     },
     "/api/worktrees": {
-      GET: () => catching("GET /api/worktrees", apiGetWorktrees),
+      GET: (req) => catching("GET /api/worktrees", () => apiGetWorktrees(req)),
       POST: (req) => catching("POST /api/worktrees", () => apiCreateWorktree(req))
     },
     "/api/worktrees/:name": {
@@ -8562,8 +9047,22 @@ Bun.serve({
         return catching(`GET /api/worktrees/${name}/status`, () => apiWorktreeStatus(name));
       }
     },
+    "/api/linear/issues": {
+      GET: () => catching("GET /api/linear/issues", () => apiGetLinearIssues())
+    },
     "/api/ci-logs/:runId": {
       GET: (req) => catching(`GET /api/ci-logs/${req.params.runId}`, () => apiCiLogs(req.params.runId))
+    },
+    "/api/notifications/stream": {
+      GET: () => handleNotificationStream()
+    },
+    "/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);
+      }
     }
   },
   async fetch(req) {
@@ -8577,9 +9076,12 @@ Bun.serve({
       }
       const file = Bun.file(filePath);
       if (await file.exists()) {
-        return new Response(file);
+        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(join2(STATIC_DIR, "index.html")), {
+        headers: { "Cache-Control": "no-cache" }
+      });
     }
     return new Response("Not Found", { status: 404 });
   },
@@ -8647,6 +9149,9 @@ if (tmuxCheck.exitCode !== 0) {
 }
 cleanupStaleSessions();
 startPrMonitor(getWorktreePaths, config.linkedRepos, PROJECT_DIR);
+installHookScripts().catch((err) => {
+  log.error(`[notify] failed to install hook scripts: ${err instanceof Error ? err.message : String(err)}`);
+});
 log.info(`Dev Dashboard API running at http://localhost:${PORT}`);
 var nets = networkInterfaces();
 for (const addrs of Object.values(nets)) {