agent-board-runner 0.1.4 → 0.1.6

package/dist/index.js

@@ -38,8 +38,9 @@ var EVAL_INTERVAL_MS = 2e3;
 var ANSI_PATTERN = /\x1b\[[0-9;?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;
 var BOX_DRAWING_PATTERN = /[─-╿]/g;
 var WORKING_PATTERN = /esc to interrupt/i;
+var BACKGROUND_SHELL_PATTERN = /\b[1-9]\d*\s+shells?\b/i;
 function isAgentHookMoment(value) {
-  return value === "implementing" || value === "waiting_plan_approval" || value === "commit_detected" || value === "turn_stopped" || value === "notification";
+  return value === "implementing" || value === "tool_active" || value === "waiting_plan_approval" || value === "commit_detected" || value === "turn_stopped" || value === "notification";
 }
 var USAGE_LIMIT_PATTERN = /(usage limit reached|limit reached[^\n]{0,60}resets|reached your (?:usage|session) limit|out of (?:weekly|session) (?:usage|limit))/i;
 var PLAN_APPROVAL_PATTERN = /would you like to proceed\??/i;
@@ -63,7 +64,10 @@ function classifyAgentOutput(recentOutput, options) {
   if (options.planApprovalPending) return "waiting_plan_approval";
   if (USER_PROMPT_PATTERNS.some((pattern) => pattern.test(recentOutput))) return "waiting_user";
   const idleThreshold = options.toolCallPending ? IDLE_AFTER_MS_TOOL_PENDING : IDLE_AFTER_MS;
-  if (options.silentForMs >= idleThreshold) return options.commitDetected ? "done" : "waiting_user";
+  if (options.silentForMs >= idleThreshold) {
+    if (BACKGROUND_SHELL_PATTERN.test(recentOutput)) return "waiting_background";
+    return options.commitDetected ? "done" : "waiting_user";
+  }
   return options.previous;
 }
 var AgentActivityWatcher = class {
@@ -124,6 +128,10 @@ var AgentActivityWatcher = class {
         this.commitDetected = false;
         this.setState("implementing");
         break;
+      case "tool_active":
+        if (this.usageLimited) break;
+        this.setState("implementing");
+        break;
       case "waiting_plan_approval":
         this.planApprovalPending = true;
         this.setState("waiting_plan_approval");
@@ -133,17 +141,29 @@ var AgentActivityWatcher = class {
         break;
       case "turn_stopped":
         if (this.usageLimited) break;
+        if (BACKGROUND_SHELL_PATTERN.test(this.recentOutput())) {
+          this.setState("waiting_background");
+          break;
+        }
         this.setState(this.commitDetected ? "done" : "waiting_user");
         break;
       case "notification":
         if (this.usageLimited || this.planApprovalPending) break;
-        if (this.state === "implementing" || this.state === "starting") this.setState("waiting_user");
+        if (this.state === "implementing" || this.state === "starting") {
+          this.setState(BACKGROUND_SHELL_PATTERN.test(this.recentOutput()) ? "waiting_background" : "waiting_user");
+        }
         break;
     }
   }
-  evaluate(now = Date.now()) {
+  /** Text still inside RECENT_WINDOW_MS as of `now`, pruning anything older. Shared by evaluate()
+   * (the text/idle-timer path) and reportHookMoment() (the hook path), which both need to know
+   * whether the background-shell indicator is currently on screen. */
+  recentOutput(now = Date.now()) {
     while (this.chunks.length > 0 && now - this.chunks[0].at > RECENT_WINDOW_MS) this.chunks.shift();
-    const next = classifyAgentOutput(this.chunks.map((chunk) => chunk.text).join(""), {
+    return this.chunks.map((chunk) => chunk.text).join("");
+  }
+  evaluate(now = Date.now()) {
+    const next = classifyAgentOutput(this.recentOutput(now), {
       silentForMs: now - this.lastOutputAt,
       usageLimited: this.usageLimited,
       planApprovalPending: this.planApprovalPending,
@@ -289,7 +309,7 @@ function stopPtySession(sessionId) {
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { spawn } from "node-pty";
 var SHELL_COMMAND = process.platform === "win32" ? process.env.COMSPEC ?? "cmd.exe" : process.env.SHELL ?? "bash";
-function spawnShellPty(repoPath, sessionIdPrefix) {
+function spawnShellPty(repoPath, sessionIdPrefix, initialCommand) {
   const sessionId = `${sessionIdPrefix}:${randomUUID2()}`;
   const ticket = randomUUID2();
   const pty = spawn(SHELL_COMMAND, [], {
@@ -299,14 +319,15 @@ function spawnShellPty(repoPath, sessionIdPrefix) {
     cwd: repoPath
   });
   registerPtySession(sessionId, pty, ticket);
+  if (initialCommand) pty.write(`${initialCommand}\r`);
   pty.onExit(({ exitCode }) => {
     logger.runner.info("SHELL", `Shell ${sessionId} exited (code ${exitCode}).`);
     stopPtySession(sessionId);
   });
   return { sessionId, ticket };
 }
-function openShellSession(repoPath) {
-  return spawnShellPty(repoPath, "shell");
+function openShellSession(repoPath, initialCommand) {
+  return spawnShellPty(repoPath, "shell", initialCommand);
 }
 function closeShellSession(sessionId) {
   stopPtySession(sessionId);
@@ -315,9 +336,8 @@ var columnShells = /* @__PURE__ */ new Map();
 function openOrReuseColumnShell(key, repoPath, initialCommand) {
   const existing = columnShells.get(key);
   if (existing && getPtySession(existing.sessionId)) return existing;
-  const shell = spawnShellPty(repoPath, "column-shell");
+  const shell = spawnShellPty(repoPath, "column-shell", initialCommand);
   columnShells.set(key, shell);
-  if (initialCommand) getPtySession(shell.sessionId)?.pty.write(`${initialCommand}\r`);
   return shell;
 }
 function closeColumnShell(key) {
@@ -585,11 +605,19 @@ async function getRunningSessionForProject(supabase, projectId, ownerUserId) {
 }
 async function listQueuedSessionsForRunner(supabase, ownerUserId) {
   const { data, error } = await supabase.from("sessions").select(
-    "id, card_id, claude_session_id, agent_state, created_at, cards!card_id!inner(project_id, assigned_user_id, title, instructions, file_references, plan_first)"
+    "id, card_id, claude_session_id, agent_state, created_at, cards!card_id!inner(project_id, assigned_user_id, title, instructions, file_references, plan_first, prerequisite_card_id)"
   ).eq("cards.assigned_user_id", ownerUserId).eq("status", "queued").order("created_at", { ascending: true });
   if (error) throw error;
   return data;
 }
+async function listPausedSessionsForRunner(supabase, ownerUserId) {
+  const { data, error } = await supabase.from("sessions").select("card_id, cards!card_id!inner(project_id, assigned_user_id)").eq("cards.assigned_user_id", ownerUserId).eq("status", "paused");
+  if (error) throw error;
+  return data.map((row) => ({
+    card_id: row.card_id,
+    project_id: row.cards.project_id
+  }));
+}
 async function createSession(supabase, userId, cardId, resumeClaudeSessionId) {
   const { data, error } = await supabase.from("sessions").insert({
     card_id: cardId,
@@ -648,6 +676,11 @@ async function getLastClaudeSessionIdForCard(supabase, cardId) {
   if (error) throw error;
   return data?.claude_session_id ?? null;
 }
+async function getLatestAgentStateForCard(supabase, cardId) {
+  const { data, error } = await supabase.from("sessions").select("agent_state").eq("card_id", cardId).order("created_at", { ascending: false }).limit(1).maybeSingle();
+  if (error) throw error;
+  return data?.agent_state ?? null;
+}
 async function updateCard(supabase, cardId, changes) {
   const { error } = await supabase.from("cards").update({
     ...changes.column !== void 0 ? { column_name: changes.column } : {},
@@ -768,6 +801,9 @@ var AGENT_MOMENT_HOOK_SCRIPT_PATH = join2(tmpdir2(), "agent-board-agent-moment-h
 var SCRIPT_SOURCE = `#!/usr/bin/env node
 "use strict";
 const http = require("node:http");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
 
 function readStdin() {
   return new Promise((resolve) => {
@@ -786,6 +822,58 @@ function readStdin() {
 const COMMIT_SUCCESS_PATTERN = /\\[\\S+\\s+[0-9a-f]{7,40}\\]/;
 const GIT_COMMIT_COMMAND_PATTERN = /\\bgit\\b[^\\n]*\\bcommit\\b/i;
 
+// Catches the agent writing a tool invocation as plain prose (e.g. "Agent({ subagent_type:
+// ... })") in what was meant to be its final message, instead of actually emitting a
+// structured tool call \u2014 Claude Code then just ends the turn, having "announced" work it
+// never did. Restricted to names that look like a real tool (PascalCase built-ins, or
+// "mcp__server__tool") rather than any "Word({" in the text, so ordinary prose describing
+// hypothetical code doesn't trip it.
+const KNOWN_TOOL_NAMES = new Set([
+  "Agent", "AskUserQuestion", "Bash", "PowerShell", "Edit", "Write", "Read", "Glob", "Grep",
+  "NotebookEdit", "WebFetch", "WebSearch", "Skill", "ExitPlanMode", "EnterPlanMode",
+  "ToolSearch", "ListAgents", "SendMessage", "ScheduleWakeup", "SendFeedback", "ReportFindings",
+  "Artifact", "CronCreate", "CronDelete", "CronList", "DesignSync", "EndConversation",
+  "EnterWorktree", "ExitWorktree", "LSP", "ListMcpResourcesTool", "Monitor",
+  "PushNotification", "ReadMcpResourceDirTool", "ReadMcpResourceTool", "RemoteTrigger",
+  "TaskOutput", "TaskStop", "TodoWrite", "SlashCommand", "Task",
+]);
+const TOOL_CALL_LOOKALIKE_PATTERN = /\\b([A-Z][A-Za-z0-9]*|mcp__[A-Za-z0-9_]+)\\(\\s*\\{/g;
+
+function findFakeToolCallName(text) {
+  if (!text) return null;
+  TOOL_CALL_LOOKALIKE_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = TOOL_CALL_LOOKALIKE_PATTERN.exec(text))) {
+    const name = match[1];
+    if (name.startsWith("mcp__") || KNOWN_TOOL_NAMES.has(name)) return name;
+  }
+  return null;
+}
+
+// Bounds the auto-continue below to at most one nudge per session: if the model fakes a
+// tool call again right after being told to actually call it, something stranger than this
+// specific slip is going on, and blocking forever would risk an unbounded loop. One file,
+// shared by every session on this machine, keyed by AGENT_BOARD_SESSION_ID \u2014 a miscount
+// under concurrent sessions just means the cap is off by one, never a correctness issue.
+const FAKE_CALL_STATE_PATH = path.join(os.tmpdir(), "agent-board-fake-tool-call-hook-state.json");
+const MAX_AUTO_CONTINUES_PER_SESSION = 1;
+
+function fakeCallAttemptsSoFar(sessionId) {
+  try {
+    const state = JSON.parse(fs.readFileSync(FAKE_CALL_STATE_PATH, "utf8"));
+    return state[sessionId] || 0;
+  } catch {
+    return 0;
+  }
+}
+
+function recordFakeCallAttempt(sessionId) {
+  let state = {};
+  try { state = JSON.parse(fs.readFileSync(FAKE_CALL_STATE_PATH, "utf8")); } catch {}
+  state[sessionId] = (state[sessionId] || 0) + 1;
+  try { fs.writeFileSync(FAKE_CALL_STATE_PATH, JSON.stringify(state)); } catch {}
+}
+
 // Which "moment" (if any) this hook invocation reports, from the single JSON payload Claude
 // Code gives a hook on stdin. Returning null means "nothing conclusive" \u2014 the hook exits
 // quietly and the runner's text-based fallback (agentActivity.ts) stays in charge.
@@ -801,6 +889,12 @@ function detectMoment(input) {
   // "would you like to proceed?", before the CLI even renders the prompt.
   if (eventName === "PreToolUse" && input.tool_name === "ExitPlanMode") return "waiting_plan_approval";
 
+  // Any other tool about to run is also a precise "the turn is active" signal \u2014 notably the
+  // one that resumes a permission prompt (y/n) or an AskUserQuestion answer: neither of those
+  // is a new UserPromptSubmit, so without this the badge had nothing but the text fallback to
+  // notice the agent is working again once the human replies.
+  if (eventName === "PreToolUse") return "tool_active";
+
   // The plan prompt resolving one way or the other: approved, the turn resumes implementing
   // right away with no new UserPromptSubmit to catch it; asked to revise, a fresh
   // UserPromptSubmit follows almost immediately anyway. Either way "implementing" is correct
@@ -809,14 +903,22 @@ function detectMoment(input) {
 
   // A commit that actually succeeded, read off the Bash tool's own structured result instead
   // of guessing from scrollback text (exact, and immune to locale/color/format changes to
-  // git's own banner).
+  // git's own banner). Any other Bash completion still reports "tool_active" below, same as
+  // every other tool.
   if (eventName === "PostToolUse" && input.tool_name === "Bash") {
     const command = String((input.tool_input && input.tool_input.command) || "");
-    if (!GIT_COMMIT_COMMAND_PATTERN.test(command)) return null;
-    const response = JSON.stringify(input.tool_response || "");
-    return COMMIT_SUCCESS_PATTERN.test(response) ? "commit_detected" : null;
+    if (GIT_COMMIT_COMMAND_PATTERN.test(command)) {
+      const response = JSON.stringify(input.tool_response || "");
+      if (COMMIT_SUCCESS_PATTERN.test(response)) return "commit_detected";
+    }
   }
 
+  // Any other tool finishing is the same "still active" signal as PreToolUse above \u2014 this is
+  // what actually clears a yellow badge once a permission-gated or AskUserQuestion tool call
+  // resumes and completes (there's no hook fired at the exact instant permission is granted,
+  // only at the tool call's start and end).
+  if (eventName === "PostToolUse") return "tool_active";
+
   // The turn actually ending \u2014 Claude Code back at its input box, no idle timer needed.
   if (eventName === "Stop") return "turn_stopped";
 
@@ -858,6 +960,23 @@ function reportToRunner(sessionId, ticket, port, moment) {
 (async () => {
   try {
     const input = JSON.parse(await readStdin());
+    if (input.hook_event_name === "Stop") {
+      const fakeCallName = findFakeToolCallName(input.lastAssistantMessage);
+      const sessionId = process.env.AGENT_BOARD_SESSION_ID || "unknown";
+      if (fakeCallName && fakeCallAttemptsSoFar(sessionId) < MAX_AUTO_CONTINUES_PER_SESSION) {
+        recordFakeCallAttempt(sessionId);
+        process.stdout.write(JSON.stringify({
+          decision: "block",
+          reason:
+            \`You wrote "\${fakeCallName}({...})" as plain text in your final message instead of \` +
+            "actually calling that tool \u2014 no such call happened, so nothing was delegated/executed. " +
+            "If you meant to use it, call it for real now as a structured tool call, don't just " +
+            "describe it. If you already finished without needing it, say so explicitly instead of " +
+            "writing pseudocode that looks like a call.",
+        }));
+        process.exit(0);
+      }
+    }
     const moment = detectMoment(input);
     if (moment) {
       const sessionId = process.env.AGENT_BOARD_SESSION_ID;
@@ -883,11 +1002,8 @@ function agentMomentHookSettingsFragment() {
   return {
     hooks: {
       UserPromptSubmit: [{ hooks: [hookEntry] }],
-      PreToolUse: [{ matcher: "ExitPlanMode", hooks: [hookEntry] }],
-      PostToolUse: [
-        { matcher: "ExitPlanMode", hooks: [hookEntry] },
-        { matcher: "Bash", hooks: [hookEntry] }
-      ],
+      PreToolUse: [{ matcher: "*", hooks: [hookEntry] }],
+      PostToolUse: [{ matcher: "*", hooks: [hookEntry] }],
       Stop: [{ hooks: [hookEntry] }],
       Notification: [{ hooks: [hookEntry] }]
     }
@@ -1627,47 +1743,51 @@ async function handleAgentHookReport(req, res) {
   res.writeHead(204, { "Access-Control-Allow-Origin": "*" });
   res.end();
 }
-async function handleBranchRequest(entry, res, relPath) {
-  let cwd;
-  try {
-    cwd = relPath ? resolveWithinRepo(entry.repoRoot, relPath) : entry.repoRoot;
-  } catch (err) {
-    if (err instanceof HttpError) {
-      sendJson(res, err.status, { error: err.message });
-      return;
-    }
-    throw err;
-  }
-  try {
-    const { stdout } = await execFileAsync2("git", ["branch", "--show-current"], { cwd });
-    sendJson(res, 200, { branch: stdout.trim() });
-  } catch (err) {
-    logger.runner.error("FILES", "Unexpected error handling a branch request:", err);
-    sendJson(res, 500, { error: "Erro interno do runner." });
-  }
-}
 var DIFF_EXEC_OPTIONS = { maxBuffer: 10 * 1024 * 1024 };
-function parseGitStatusPorcelain(output) {
+function parseGitDiffNameStatus(output) {
   return output.split("\n").filter((line) => line.length > 0).map((line) => {
-    const status = line.slice(0, 2).trim();
-    const rest = line.slice(3);
-    const arrowIndex = rest.indexOf(" -> ");
-    const path = arrowIndex >= 0 ? rest.slice(arrowIndex + 4) : rest;
+    const columns = line.split("	");
+    const status = columns[0].slice(0, 1);
+    const path = columns[columns.length - 1];
     return { path, status };
   });
 }
 async function getRepoDiffForTarget(label, cwd) {
+  let branch;
+  try {
+    const { stdout } = await execFileAsync2("git", ["branch", "--show-current"], { cwd });
+    branch = stdout.trim();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { label, files: [], diff: "", error: message };
+  }
+  if (!branch) {
+    return { label, files: [], diff: "", error: "HEAD destacado: sem branch local para comparar com a origin." };
+  }
+  try {
+    await execFileAsync2("git", ["fetch", "origin", branch], { cwd });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const notOnRemote = /couldn't find remote ref/i.test(message);
+    return {
+      label,
+      files: [],
+      diff: "",
+      error: notOnRemote ? `A branch "${branch}" ainda n\xE3o existe na origin.` : message
+    };
+  }
+  const remoteRef = `origin/${branch}`;
   let files;
   try {
-    const { stdout } = await execFileAsync2("git", ["status", "--porcelain=v1"], { cwd });
-    files = parseGitStatusPorcelain(stdout);
+    const { stdout } = await execFileAsync2("git", ["diff", "--name-status", remoteRef, "HEAD"], { cwd });
+    files = parseGitDiffNameStatus(stdout);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     return { label, files: [], diff: "", error: message };
   }
   if (files.length === 0) return { label, files, diff: "" };
   try {
-    const { stdout } = await execFileAsync2("git", ["diff", "HEAD"], { ...DIFF_EXEC_OPTIONS, cwd });
+    const { stdout } = await execFileAsync2("git", ["diff", remoteRef, "HEAD"], { ...DIFF_EXEC_OPTIONS, cwd });
     return { label, files, diff: stdout };
   } catch {
     return { label, files, diff: "" };
@@ -1850,10 +1970,6 @@ function handleRequest(req, res) {
     sendJson(res, 401, { error: "Ticket inv\xE1lido, expirado, ou projeto desconhecido." });
     return;
   }
-  if (pathname === "/branch") {
-    void handleBranchRequest(entry, res, relPath);
-    return;
-  }
   if (pathname === "/diff") {
     const projectId = typeof query.projectId === "string" ? query.projectId : "";
     void handleDiffRequest(entry, res, projectId);
@@ -1890,7 +2006,9 @@ function handleRequest(req, res) {
       return;
     }
     if (pathname === "/shell/open") {
-      sendJson(res, 200, openShellSession(entry.repoRoot));
+      const kind = typeof query.kind === "string" ? query.kind : "shell";
+      if (!COLUMN_SHELL_KINDS.includes(kind)) throw new HttpError(400, "Par\xE2metro kind inv\xE1lido.");
+      sendJson(res, 200, openShellSession(entry.repoRoot, kind === "claude" ? CLAUDE_BYPASS_COMMAND : void 0));
       return;
     }
     if (pathname === "/shell/close") {
@@ -1936,11 +2054,18 @@ function attachFilesServer(httpServer, supabase, config) {
 }
 
 // src/agentEventsServer.ts
+var EMPTY_QUEUE = { queuedCardIds: [], pausedCardIds: [] };
 var stateByProject = /* @__PURE__ */ new Map();
+var queueByProject = /* @__PURE__ */ new Map();
+var branchesByProject = /* @__PURE__ */ new Map();
 var socketsByProject = /* @__PURE__ */ new Map();
 function sendSnapshot(socket, projectId) {
   const states = Array.from(stateByProject.get(projectId)?.values() ?? []);
-  socket.send(JSON.stringify({ type: "snapshot", states }));
+  const queue = queueByProject.get(projectId) ?? EMPTY_QUEUE;
+  const branches = Array.from(branchesByProject.get(projectId)?.entries() ?? []).map(
+    ([label, branch]) => ({ label: label || null, branch })
+  );
+  socket.send(JSON.stringify({ type: "snapshot", states, queue, branches }));
 }
 function publishAgentStateEvent(projectId, cardId, sessionId, agentState) {
   let projectState = stateByProject.get(projectId);
@@ -1956,6 +2081,29 @@ function publishAgentStateEvent(projectId, cardId, sessionId, agentState) {
     if (socket.readyState === socket.OPEN) socket.send(payload);
   }
 }
+function publishQueueEvent(projectId, queue) {
+  queueByProject.set(projectId, queue);
+  const sockets = socketsByProject.get(projectId);
+  if (!sockets || sockets.size === 0) return;
+  const payload = JSON.stringify({ type: "queue", ...queue });
+  for (const socket of sockets) {
+    if (socket.readyState === socket.OPEN) socket.send(payload);
+  }
+}
+function publishBranchEvent(projectId, label, branch) {
+  let projectBranches = branchesByProject.get(projectId);
+  if (!projectBranches) {
+    projectBranches = /* @__PURE__ */ new Map();
+    branchesByProject.set(projectId, projectBranches);
+  }
+  projectBranches.set(label ?? "", branch);
+  const sockets = socketsByProject.get(projectId);
+  if (!sockets || sockets.size === 0) return;
+  const payload = JSON.stringify({ type: "branch", label, branch });
+  for (const socket of sockets) {
+    if (socket.readyState === socket.OPEN) socket.send(payload);
+  }
+}
 function attachAgentEventsServer() {
   const wss = new WebSocketServer({ noServer: true });
   wss.on("connection", (socket, request) => {
@@ -2027,8 +2175,8 @@ function resolveRepoPath(config, relativeRepoPath) {
 
 // src/auth.ts
 var SESSION_FILE = join9(CONFIG_DIR, "session.json");
-var DEFAULT_SUPABASE_URL = "https://brpxshvnmxgkbffgdfcc.supabase.co";
-var DEFAULT_SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImJycHhzaHZubXhna2JmZmdkZmNjIiwicm9sZSI6ImFub24iLCJpYXQiOjE3ODc1OTQwMTEsImV4cCI6MjEwMzE3MDAxMX0.ErsAGZysLFgNvijetR7w1YvIziXC-1D2sx04Hm2UW9c";
+var DEFAULT_SUPABASE_URL = "https://supabase.lealtek.com";
+var DEFAULT_SUPABASE_ANON_KEY = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJzdXBhYmFzZSIsImlhdCI6MTc5MjAwNTE4MCwiZXhwIjo0OTQ3Njc4NzgwLCJyb2xlIjoiYW5vbiJ9.gxNuRa1STVA4lQPLghoGbuqV9_21lVOG1yXSu9WNmJ4";
 function resolveSupabaseUrl() {
   return process.env.AGENT_BOARD_SUPABASE_URL ?? DEFAULT_SUPABASE_URL;
 }
@@ -2083,11 +2231,77 @@ async function requireSession(supabase) {
   return session;
 }
 
-// src/columnActions.ts
-import { exec } from "node:child_process";
+// src/branchWatcher.ts
+import { execFile as execFile3 } from "node:child_process";
+import { watch } from "node:fs";
 import { join as join10 } from "node:path";
 import { promisify as promisify3 } from "node:util";
-var execAsync = promisify3(exec);
+var execFileAsync3 = promisify3(execFile3);
+var DEBOUNCE_MS = 300;
+var watchedProjects = /* @__PURE__ */ new Map();
+async function readCurrentBranch(cwd) {
+  try {
+    const { stdout } = await execFileAsync3("git", ["branch", "--show-current"], { cwd });
+    return stdout.trim();
+  } catch {
+    return "";
+  }
+}
+function watchTarget(projectId, label, cwd, state) {
+  let debounceTimer = null;
+  function check() {
+    void readCurrentBranch(cwd).then((branch) => {
+      if (!branch || state.lastBranch.get(label) === branch) return;
+      state.lastBranch.set(label, branch);
+      publishBranchEvent(projectId, label || null, branch);
+    });
+  }
+  let watcher;
+  try {
+    watcher = watch(join10(cwd, ".git", "HEAD"), () => {
+      if (debounceTimer !== null) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(check, DEBOUNCE_MS);
+    });
+  } catch (err) {
+    logger.runner.warn("BRANCH_WATCH", `Could not watch .git/HEAD under ${cwd}:`, err instanceof Error ? err.message : err);
+    return;
+  }
+  state.watchers.push(watcher);
+  check();
+}
+async function ensureBranchWatchers(supabase, config) {
+  for (const project of config.registeredProjects) {
+    if (watchedProjects.has(project.id)) continue;
+    const state = { watchers: [], lastBranch: /* @__PURE__ */ new Map() };
+    watchedProjects.set(project.id, state);
+    let children;
+    try {
+      children = (await getProjectRepos(supabase, project.id)).map((repo) => repo.subpath);
+    } catch (err) {
+      logger.runner.error("BRANCH_WATCH", `Failed to list child repos for project ${project.id}:`, err);
+      children = [];
+    }
+    if (children.length === 0) {
+      watchTarget(project.id, "", project.repoPath, state);
+    } else {
+      for (const subpath of children) {
+        watchTarget(project.id, subpath, join10(project.repoPath, subpath), state);
+      }
+    }
+  }
+  const stillRegistered = new Set(config.registeredProjects.map((project) => project.id));
+  for (const [projectId, state] of watchedProjects) {
+    if (stillRegistered.has(projectId)) continue;
+    for (const watcher of state.watchers) watcher.close();
+    watchedProjects.delete(projectId);
+  }
+}
+
+// src/columnActions.ts
+import { exec } from "node:child_process";
+import { join as join11 } from "node:path";
+import { promisify as promisify4 } from "node:util";
+var execAsync = promisify4(exec);
 var OUTPUT_TAIL_CHARS = 4e3;
 function tail(text) {
   return text.length > OUTPUT_TAIL_CHARS ? text.slice(text.length - OUTPUT_TAIL_CHARS) : text;
@@ -2095,7 +2309,7 @@ function tail(text) {
 function resolveTargets(project, children, repoRoot, column, timing) {
   if (children.length > 0) {
     return children.flatMap(
-      (child2) => (child2.column_actions[column] ?? []).filter((action) => action.timing === timing).map((action) => ({ label: child2.subpath, cwd: join10(repoRoot, child2.subpath), command: action.command }))
+      (child2) => (child2.column_actions[column] ?? []).filter((action) => action.timing === timing).map((action) => ({ label: child2.subpath, cwd: join11(repoRoot, child2.subpath), command: action.command }))
     );
   }
   return (project.column_actions[column] ?? []).filter((action) => action.timing === timing).map((action) => ({ label: null, cwd: repoRoot, command: action.command }));
@@ -2201,7 +2415,7 @@ async function checkPendingDeployActionReruns(supabase, config) {
 }
 
 // src/deploy.ts
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 
 // src/devServer.ts
 import { spawn as spawn4 } from "node:child_process";
@@ -2210,7 +2424,7 @@ import { spawn as spawn4 } from "node:child_process";
 import { spawn as spawn3 } from "node:child_process";
 import { accessSync, constants } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { delimiter, join as join11 } from "node:path";
+import { delimiter, join as join12 } from "node:path";
 import { bin as bundledBinaryPath, install as downloadCloudflared } from "cloudflared";
 var TRYCLOUDFLARE_URL_RE = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
 var STARTUP_TIMEOUT_MS = 2e4;
@@ -2221,15 +2435,15 @@ function wellKnownDirectories() {
   const home = homedir5();
   if (IS_WINDOWS2) {
     const candidates = [
-      process.env.ProgramFiles && join11(process.env.ProgramFiles, "cloudflared"),
-      process.env["ProgramFiles(x86)"] && join11(process.env["ProgramFiles(x86)"], "cloudflared"),
-      process.env.LOCALAPPDATA && join11(process.env.LOCALAPPDATA, "Microsoft", "WinGet", "Links"),
-      join11(home, "scoop", "shims"),
-      process.env.ChocolateyInstall && join11(process.env.ChocolateyInstall, "bin")
+      process.env.ProgramFiles && join12(process.env.ProgramFiles, "cloudflared"),
+      process.env["ProgramFiles(x86)"] && join12(process.env["ProgramFiles(x86)"], "cloudflared"),
+      process.env.LOCALAPPDATA && join12(process.env.LOCALAPPDATA, "Microsoft", "WinGet", "Links"),
+      join12(home, "scoop", "shims"),
+      process.env.ChocolateyInstall && join12(process.env.ChocolateyInstall, "bin")
     ];
     return candidates.filter((dir) => Boolean(dir));
   }
-  return ["/usr/local/bin", "/usr/bin", "/opt/homebrew/bin", join11(home, ".local", "bin")];
+  return ["/usr/local/bin", "/usr/bin", "/opt/homebrew/bin", join12(home, ".local", "bin")];
 }
 function pathDirectories() {
   return (process.env.PATH ?? "").split(delimiter).map((dir) => dir.trim().replace(/^"|"$/g, "")).filter(Boolean);
@@ -2245,7 +2459,7 @@ function isExecutableFile(path) {
 function findInstalledBinary() {
   const override = process.env.AGENT_BOARD_CLOUDFLARED_PATH;
   const directories = [...pathDirectories(), ...wellKnownDirectories()];
-  const candidates = [...override ? [override] : [], ...directories.map((dir) => join11(dir, BINARY_NAME))];
+  const candidates = [...override ? [override] : [], ...directories.map((dir) => join12(dir, BINARY_NAME))];
   return candidates.find(isExecutableFile) ?? null;
 }
 async function locateCloudflared() {
@@ -2432,12 +2646,12 @@ function stopAll() {
 }
 
 // src/git.ts
-import { execFile as execFile3 } from "node:child_process";
-import { promisify as promisify4 } from "node:util";
-var execFileAsync3 = promisify4(execFile3);
+import { execFile as execFile4 } from "node:child_process";
+import { promisify as promisify5 } from "node:util";
+var execFileAsync4 = promisify5(execFile4);
 async function pushBranchToMain(repoPath) {
   try {
-    await execFileAsync3("git", ["push", "origin", "HEAD:main"], { cwd: repoPath });
+    await execFileAsync4("git", ["push", "origin", "HEAD:main"], { cwd: repoPath });
     return { ok: true };
   } catch (err) {
     const stderr = err.stderr;
@@ -2599,8 +2813,8 @@ function resumeAgentPty(repoPath, claudeSessionId, sessionId, ticket) {
 // src/cardAttachments.ts
 import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
 import { tmpdir as tmpdir6 } from "node:os";
-import { extname, join as join12 } from "node:path";
-var ATTACHMENTS_ROOT = join12(tmpdir6(), "agent-board", "card-attachments");
+import { extname, join as join13 } from "node:path";
+var ATTACHMENTS_ROOT = join13(tmpdir6(), "agent-board", "card-attachments");
 function sanitizeFileName(fileName) {
   return fileName.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
@@ -2612,13 +2826,13 @@ async function downloadCardAttachments(supabase, cardId) {
   }
   const rows = data ?? [];
   if (rows.length === 0) return [];
-  const targetDir = join12(ATTACHMENTS_ROOT, cardId);
+  const targetDir = join13(ATTACHMENTS_ROOT, cardId);
   await mkdir2(targetDir, { recursive: true });
   const paths = [];
   for (const row of rows) {
     const baseName = sanitizeFileName(row.file_name);
     const fileName = extname(baseName) ? baseName : `${baseName}${extname(row.storage_path)}`;
-    const localPath = join12(targetDir, `${row.id}-${fileName}`);
+    const localPath = join13(targetDir, `${row.id}-${fileName}`);
     try {
       const { data: blob, error: downloadError } = await supabase.storage.from(CARD_ATTACHMENTS_BUCKET).download(row.storage_path);
       if (downloadError) throw downloadError;
@@ -2653,7 +2867,7 @@ ${list}`;
 function buildInstructionsWithMcpContext(instructions, cardId, projectId) {
   return `${instructions}
 
-Agent Board MCP: this card's id is \`${cardId}\` and its project id is \`${projectId}\` \u2014 pass these directly to board tools (\`update_card\`, \`create_card\`, \`add_card_comment\`, etc.), no lookup needed. If this task turns out too large for one session, use \`create_card\` to split it into subtask cards (chain them with \`prerequisiteCardId\` when one depends on another) instead of trying to fit everything here. Before finishing, post a short summary of what you did as a comment on this card via \`add_card_comment\` so the project's humans have visibility without opening this terminal.`;
+Agent Board MCP: this card's id is \`${cardId}\` and its project id is \`${projectId}\` \u2014 pass these directly to board tools (\`update_card\`, \`create_card\`, \`add_card_comment\`, etc.), no lookup needed. If this task turns out too large for one session, use \`create_card\` to split it into subtask cards (chain them with \`prerequisiteCardId\` when one depends on another) instead of trying to fit everything here. If part of the delivery needs a human to do something you can't do yourself (rotate a secret, approve something in a third-party dashboard, delete a resource manually, etc.), register each step with \`add_manual_actions\` instead of just mentioning it in your final message \u2014 that's the only place humans will reliably see it. Before finishing, post a short summary of what you did as a comment on this card via \`add_card_comment\` so the project's humans have visibility without opening this terminal.`;
 }
 
 // src/usageResume.ts
@@ -2763,8 +2977,9 @@ async function reconcileStaleSessions(supabase, config, projectId) {
 async function dispatchRunnerQueue(supabase, config) {
   if (dispatchingRunner) return;
   dispatchingRunner = true;
+  let queued = [];
   try {
-    const queued = await listQueuedSessionsForRunner(supabase, config.ownerUserId);
+    queued = await listQueuedSessionsForRunner(supabase, config.ownerUserId);
     if (queued.length === 0) return;
     const queuedProjectIds = new Set(queued.map((entry) => entry.cards.project_id));
     const maxConcurrentProjects = await getRunnerMaxConcurrentProjects(supabase, config.runnerId);
@@ -2785,6 +3000,17 @@ async function dispatchRunnerQueue(supabase, config) {
       const projectId = entry.cards.project_id;
       if (runningProjectIds.has(projectId) || promotedThisPass.has(projectId)) continue;
       if (freeProjectSlots <= 0) break;
+      const prerequisiteCardId = entry.cards.prerequisite_card_id;
+      if (prerequisiteCardId) {
+        const prerequisiteAgentState = await getLatestAgentStateForCard(supabase, prerequisiteCardId);
+        if (prerequisiteAgentState !== "done") {
+          logger.card.info(
+            entry.card_id,
+            `Waiting on prerequisite card ${prerequisiteCardId} to reach agent state "done" (currently "${prerequisiteAgentState ?? "none"}") before starting \u2014 leaving queued.`
+          );
+          continue;
+        }
+      }
       try {
         await promoteQueuedSession(supabase, config, entry);
         promotedThisPass.add(projectId);
@@ -2794,9 +3020,33 @@ async function dispatchRunnerQueue(supabase, config) {
       }
     }
   } finally {
+    await publishQueueSnapshots(supabase, config, queued).catch(
+      (err) => logger.runner.error("ORCHESTRATOR", "Failed to publish queue snapshots:", err)
+    );
     dispatchingRunner = false;
   }
 }
+async function publishQueueSnapshots(supabase, config, queued) {
+  const paused = await listPausedSessionsForRunner(supabase, config.ownerUserId);
+  const queuedByProject = /* @__PURE__ */ new Map();
+  for (const entry of queued) {
+    const list = queuedByProject.get(entry.cards.project_id) ?? [];
+    list.push(entry.card_id);
+    queuedByProject.set(entry.cards.project_id, list);
+  }
+  const pausedByProject = /* @__PURE__ */ new Map();
+  for (const { card_id: cardId, project_id: projectId } of paused) {
+    const list = pausedByProject.get(projectId) ?? [];
+    list.push(cardId);
+    pausedByProject.set(projectId, list);
+  }
+  for (const project of config.registeredProjects) {
+    publishQueueEvent(project.id, {
+      queuedCardIds: queuedByProject.get(project.id) ?? [],
+      pausedCardIds: pausedByProject.get(project.id) ?? []
+    });
+  }
+}
 async function promoteQueuedSession(supabase, config, entry) {
   const existingHandle = getPtySession(entry.id);
   if (existingHandle) {
@@ -3045,7 +3295,7 @@ async function handleDeployRequested(supabase, config, project) {
   }
   const children = await getProjectRepos(supabase, project.id);
   const repoRoot = resolveRepoPath(config, project.repo_path);
-  const targets = children.length > 0 ? children.map((child2) => ({ label: child2.subpath, path: join13(repoRoot, child2.subpath) })) : [{ label: null, path: repoRoot }];
+  const targets = children.length > 0 ? children.map((child2) => ({ label: child2.subpath, path: join14(repoRoot, child2.subpath) })) : [{ label: null, path: repoRoot }];
   const failures = [];
   for (const target of targets) {
     const result = await pushBranchToMain(target.path);
@@ -3179,7 +3429,7 @@ async function syncRegisteredProjects(supabase, config, registeredPaths) {
 }
 
 // src/review.ts
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 var inFlightCardIds2 = /* @__PURE__ */ new Set();
 async function handleCardEnteredRevisao(supabase, config, card) {
   if (inFlightCardIds2.has(card.id)) return;
@@ -3188,7 +3438,7 @@ async function handleCardEnteredRevisao(supabase, config, card) {
     const project = await getProject(supabase, card.project_id);
     const children = await getProjectRepos(supabase, project.id);
     const repoRoot = resolveRepoPath(config, project.repo_path);
-    const targets = children.length > 0 ? children.filter((child2) => child2.dev_command).map((child2) => ({ label: child2.subpath, cwd: join14(repoRoot, child2.subpath), command: child2.dev_command })) : project.dev_command ? [{ label: "", cwd: repoRoot, command: project.dev_command }] : [];
+    const targets = children.length > 0 ? children.filter((child2) => child2.dev_command).map((child2) => ({ label: child2.subpath, cwd: join15(repoRoot, child2.subpath), command: child2.dev_command })) : project.dev_command ? [{ label: "", cwd: repoRoot, command: project.dev_command }] : [];
     if (targets.length === 0) {
       logger.card.info(card.id, `No dev_command configured for project ${project.id}, skipping automatic preview.`);
       return;
@@ -3457,6 +3707,7 @@ async function startRunner() {
   void ensureFilesTickets(supabase, config).catch((err) => logger.runner.error("FILES", "ensureFilesTickets failed:", err));
   void ensureSetupTicket(supabase, config).catch((err) => logger.runner.error("FILES", "ensureSetupTicket failed:", err));
   void ensureAgentTicket(supabase, config).catch((err) => logger.runner.error("FILES", "ensureAgentTicket failed:", err));
+  void ensureBranchWatchers(supabase, config).catch((err) => logger.runner.error("BRANCH_WATCH", "ensureBranchWatchers failed:", err));
   const presenceChannel = supabase.channel(`runner-presence:${config.runnerId}`);
   presenceChannel.subscribe((status) => {
     if (status === "SUBSCRIBED") {
@@ -3553,6 +3804,7 @@ async function startRunner() {
     await ensureFilesTickets(supabase, config);
     await ensureSetupTicket(supabase, config);
     await ensureAgentTicket(supabase, config);
+    await ensureBranchWatchers(supabase, config).catch((err) => logger.runner.error("BRANCH_WATCH", "ensureBranchWatchers failed:", err));
     await scanForWork(supabase, config);
     await reconcileUsageLimitedSessions(supabase, config).catch((err) => logger.runner.error("ORCHESTRATOR", "reconcileUsageLimitedSessions failed:", err));
     await checkPendingDeploys(supabase, config).catch((err) => logger.runner.error("DEPLOY", "checkPendingDeploys failed:", err));