@sideboard-ai/core 0.1.9

package/dist/chunk-E4PWXO2C.js

@@ -0,0 +1,4534 @@
+import {
+  addWorkspace,
+  ensureWorkspace,
+  removeWorkspace,
+  syncWorkspacesFromThreads
+} from "./chunk-TLJH3L2C.js";
+import {
+  GLOBAL_WORKSPACE_ID,
+  createGlobalChat,
+  healOrchestrationSoccerTitles,
+  isCloudCoordinatorThread,
+  isGlobalRepoPath,
+  isGlobalThread,
+  isOrchestratorThread,
+  orchestratorSessionPoisonedByBuiltins
+} from "./chunk-2M4OHXYX.js";
+import {
+  coordinatorSystemPrompt,
+  coordinatorTurnReminder,
+  enrichWorkspacesWithGithub,
+  ensureGlobalCoordinatorCwd
+} from "./chunk-2R5VV4BA.js";
+import {
+  PLAN_MODE_INSTRUCTION,
+  allAdapters,
+  getAdapter,
+  parseBrightsyCliLine
+} from "./chunk-WMCPLDW3.js";
+import {
+  childEnvWithAppSettings,
+  getLinearApiKey,
+  isLinearConnected,
+  loadAppSettings,
+  resolveEffectiveIssueSource,
+  updateAdvancedSettings
+} from "./chunk-3WF3X46L.js";
+import {
+  allocateTeamName,
+  allocateTeamSlug,
+  commitAll,
+  createOrUpdatePr,
+  createThreadWorktree,
+  fetchPrHead,
+  getPr,
+  getPrChecks,
+  getPrDetails,
+  isDirty,
+  isPlaceholderBranch,
+  listBranches,
+  listPrs,
+  listWorktrees,
+  mergePr,
+  normalizeWorktreePath,
+  pushBranch,
+  removeWorktree,
+  resolveDefaultBranch,
+  resolveDiffBaseRef,
+  resolveGithubRepoSlug,
+  resolvePrSelector,
+  resolveRepoRoot,
+  takenSlugsFromThread,
+  threadDisplayLabel,
+  worktreeNameFromPath
+} from "./chunk-LL7DTZ5B.js";
+import {
+  appendMessage,
+  createEmptyThread,
+  deleteThreadRecord,
+  findThreadByRef,
+  listThreads,
+  readThread,
+  setStatus,
+  updateThread,
+  withThreadLock,
+  writeThread
+} from "./chunk-HYRHI3QU.js";
+import {
+  loadRepoSettings,
+  loadWorkspaceSettings,
+  sideboardReposDir,
+  sideboardWorkspacesDir,
+  workspaceSettingsSourceLabel,
+  worktreesRoot
+} from "./chunk-M37RITA6.js";
+import {
+  ensureAgentPath,
+  gh,
+  git,
+  run
+} from "./chunk-AJ6ROGD7.js";
+
+// src/integrations/linear.ts
+var LINEAR_GRAPHQL = "https://api.linear.app/graphql";
+var ASSIGNED_ISSUES_QUERY = `
+query SideboardAssignedIssues($first: Int!) {
+  viewer {
+    assignedIssues(
+      first: $first
+      orderBy: updatedAt
+      filter: { state: { type: { nin: ["completed", "canceled"] } } }
+    ) {
+      nodes {
+        id
+        identifier
+        title
+        url
+        labels { nodes { name } }
+      }
+    }
+  }
+}
+`;
+async function listLinearIssuesDirect(opts) {
+  const apiKey = (opts?.apiKey ?? getLinearApiKey())?.trim();
+  if (!apiKey) {
+    throw new Error("Linear is not connected \u2014 add an API key in Account settings");
+  }
+  const first = Math.max(1, Math.min(100, opts?.limit ?? 50));
+  const res = await fetch(LINEAR_GRAPHQL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: apiKey
+    },
+    body: JSON.stringify({
+      query: ASSIGNED_ISSUES_QUERY,
+      variables: { first }
+    })
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(
+      `Linear API error ${res.status}${body ? `: ${body.slice(0, 200)}` : ""}`
+    );
+  }
+  const json = await res.json();
+  if (json.errors?.length) {
+    throw new Error(json.errors.map((e) => e.message ?? "Linear error").join("; "));
+  }
+  const nodes = json.data?.viewer?.assignedIssues?.nodes ?? [];
+  return nodes.map((node) => ({
+    id: String(node.id ?? node.identifier ?? ""),
+    identifier: String(node.identifier ?? node.id ?? ""),
+    title: String(node.title ?? ""),
+    url: String(node.url ?? ""),
+    labels: (node.labels?.nodes ?? []).map((l) => l.name).filter((n) => Boolean(n)),
+    provider: "linear"
+  }));
+}
+async function validateLinearApiKey(apiKey) {
+  const key = apiKey.trim();
+  if (!key) return false;
+  try {
+    await listLinearIssuesDirect({ limit: 1, apiKey: key });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/integrations/issues.ts
+async function listGitHubIssues(repoPath, opts) {
+  const limit = Math.max(1, Math.min(100, opts?.limit ?? 50));
+  const slug = await resolveGithubRepoSlug(repoPath);
+  const args = [
+    "issue",
+    "list",
+    "--json",
+    "number,title,url,labels",
+    "--limit",
+    String(limit),
+    "--state",
+    "open"
+  ];
+  if (slug) args.push("--repo", slug);
+  const { stdout, exitCode } = await gh(args, repoPath, { reject: false });
+  if (exitCode !== 0 || !stdout.trim()) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+  return parsed.map((raw) => {
+    const item = raw;
+    const number = Number(item.number);
+    const identifier = Number.isFinite(number) ? `#${number}` : String(item.title ?? "");
+    const labels = (item.labels ?? []).map(
+      (l) => typeof l === "string" ? l : String(l?.name ?? "")
+    ).filter(Boolean);
+    return {
+      id: Number.isFinite(number) ? `gh-${number}` : identifier,
+      identifier,
+      title: String(item.title ?? ""),
+      url: String(item.url ?? ""),
+      labels,
+      provider: "github"
+    };
+  });
+}
+async function listIssues(repoPath) {
+  const settings = loadAppSettings();
+  const preferredSource = settings.integrations.issueSource ?? "github";
+  const linearConnected = isLinearConnected(settings);
+  const source = resolveEffectiveIssueSource(settings);
+  if (source === "linear") {
+    const issues2 = await listLinearIssuesDirect();
+    return { source, preferredSource, linearConnected, issues: issues2 };
+  }
+  const issues = await listGitHubIssues(repoPath);
+  return { source, preferredSource, linearConnected, issues };
+}
+
+// src/agents/message-parts.ts
+function asRecord(input) {
+  if (input && typeof input === "object" && !Array.isArray(input)) {
+    return input;
+  }
+  return void 0;
+}
+function str(v) {
+  return typeof v === "string" && v.trim() ? v : void 0;
+}
+function toolDetail(name, input) {
+  if (!input) return void 0;
+  const command = str(input.command) ?? str(input.cmd);
+  if (command) return command;
+  const path = str(input.file_path) ?? str(input.path) ?? str(input.filePath) ?? str(input.filename);
+  if (path) return path;
+  const pattern = str(input.pattern) ?? str(input.glob) ?? str(input.glob_pattern);
+  if (pattern) return pattern;
+  const query = str(input.query) ?? str(input.prompt);
+  if (query) return query.length > 80 ? `${query.slice(0, 77)}\u2026` : query;
+  try {
+    const raw = JSON.stringify(input);
+    return raw.length > 80 ? `${raw.slice(0, 77)}\u2026` : raw;
+  } catch {
+    return name;
+  }
+}
+function toolDescription(name, input) {
+  const n = name.replace(/^mcp__/, "").replace(/__/g, " \xB7 ");
+  if (/^get_record_types$|recordTypes/i.test(name)) return "List record types";
+  if (/connectedAgentRequest/i.test(name)) {
+    return str(input?.agent_id) ? `Ask connected agent` : "Ask connected agent";
+  }
+  if (!input) return n;
+  if (/bash|shell|terminal/i.test(name) && str(input.command)) {
+    const cmd = str(input.command);
+    if (/git\s+fetch/i.test(cmd)) return "Fetch latest from origin and check status";
+    if (/git\s+status/i.test(cmd)) return "Check git status";
+    if (/git\s+log/i.test(cmd)) return "Inspect recent commits";
+    if (/git\s+branch/i.test(cmd)) return "List branches";
+    if (/grep|rg\b/i.test(cmd)) return "Search repository";
+    return "Run shell command";
+  }
+  if (/edit|write|apply/i.test(name)) {
+    const path = str(input.file_path) ?? str(input.path);
+    return path ? `Edit ${path.split("/").pop()}` : "Edit file";
+  }
+  if (/read/i.test(name)) {
+    const path = str(input.file_path) ?? str(input.path);
+    return path ? `Read ${path.split("/").pop()}` : "Read file";
+  }
+  if (/grep/i.test(name)) return "Search files";
+  if (/glob/i.test(name)) return "Find files";
+  return n;
+}
+function toolFilePath(input) {
+  if (!input) return void 0;
+  return str(input.file_path) ?? str(input.path) ?? str(input.filePath) ?? str(input.filename);
+}
+function countLines(text) {
+  if (!text) return 0;
+  return text.split("\n").length;
+}
+function diffFromInput(input) {
+  if (!input) return {};
+  const oldS = str(input.old_string) ?? str(input.oldString);
+  const newS = str(input.new_string) ?? str(input.newString) ?? str(input.content);
+  if (oldS != null || newS != null) {
+    return {
+      additions: countLines(newS),
+      deletions: countLines(oldS)
+    };
+  }
+  return {};
+}
+function parseDiffStat(result) {
+  if (!result) return {};
+  const plus = result.match(/\+(\d+)/);
+  const minus = result.match(/-(\d+)/);
+  if (plus || minus) {
+    return {
+      additions: plus ? Number(plus[1]) : void 0,
+      deletions: minus ? Number(minus[1]) : void 0
+    };
+  }
+  return {};
+}
+function applyAgentEvent(parts, event) {
+  if (event.type === "stdout") {
+    const data = event.data;
+    if (!data) return parts;
+    const next = [...parts];
+    const last = next[next.length - 1];
+    if (last?.type === "text") {
+      next[next.length - 1] = { type: "text", text: last.text + data };
+    } else {
+      next.push({ type: "text", text: data });
+    }
+    return next;
+  }
+  if (event.type === "thinking") {
+    const data = event.data;
+    if (!data) return parts;
+    const next = [...parts];
+    const last = next[next.length - 1];
+    if (last?.type === "thinking") {
+      next[next.length - 1] = { type: "thinking", text: last.text + data };
+    } else {
+      next.push({ type: "thinking", text: data });
+    }
+    return next;
+  }
+  if (event.type === "tool_use") {
+    const input = asRecord(event.input);
+    const diff = diffFromInput(input);
+    const existing = parts.findIndex((p) => p.type === "tool" && p.id === event.id);
+    if (existing >= 0) {
+      const prev = parts[existing];
+      const next = [...parts];
+      next[existing] = {
+        ...prev,
+        name: event.name || prev.name,
+        input: input ?? prev.input,
+        description: toolDescription(event.name || prev.name, input ?? prev.input),
+        detail: toolDetail(event.name || prev.name, input ?? prev.input) ?? prev.detail,
+        filePath: toolFilePath(input) ?? prev.filePath,
+        additions: diff.additions ?? prev.additions,
+        deletions: diff.deletions ?? prev.deletions
+      };
+      return next;
+    }
+    return [
+      ...parts,
+      {
+        type: "tool",
+        id: event.id,
+        name: event.name,
+        input,
+        description: toolDescription(event.name, input),
+        detail: toolDetail(event.name, input),
+        status: "running",
+        filePath: toolFilePath(input),
+        ...diff
+      }
+    ];
+  }
+  if (event.type === "tool_result") {
+    const next = parts.map((p) => {
+      if (p.type !== "tool" || p.id !== event.id) return p;
+      const fromResult = parseDiffStat(event.content);
+      return {
+        ...p,
+        status: event.isError ? "error" : "done",
+        result: event.content,
+        additions: fromResult.additions ?? p.additions,
+        deletions: fromResult.deletions ?? p.deletions
+      };
+    });
+    return next;
+  }
+  return parts;
+}
+function partsToAssistantText(parts) {
+  return parts.filter((p) => p.type === "text").map((p) => p.text).join("").trim();
+}
+function stripBrightsyNdjsonNoise(text) {
+  if (!text || !text.includes('"type"')) return text;
+  let out = text;
+  out = out.replace(
+    /\{"type":"(?:tool_use|tool_result|tool|thinking|usage|done|error)"[\s\S]*?\}\s*(?=\{"type":"|$|(?=[A-Za-z*#]))/g,
+    ""
+  );
+  out = out.replace(/\{"type":"(?:tool_use|tool_result|tool)"[\s\S]*$/g, "");
+  return out.trim();
+}
+function isBrightsyNdjsonLine(line) {
+  const t = line.trim();
+  if (!t.startsWith("{")) return false;
+  return /"type"\s*:\s*"(tool_use|tool_result|tool|thinking|usage|done|error|text)"/.test(t);
+}
+function finalizeParts(parts) {
+  return parts.map(
+    (p) => p.type === "tool" && p.status === "running" ? { ...p, status: "done" } : p
+  );
+}
+function normalizeParseResult(parsed) {
+  if (!parsed) return [];
+  return Array.isArray(parsed) ? parsed : [parsed];
+}
+
+// src/agents/usage.ts
+function sumOptional(a, b) {
+  if (a == null && b == null) return void 0;
+  return (a ?? 0) + (b ?? 0);
+}
+function mergeUsage(a, b) {
+  return {
+    inputTokens: (a?.inputTokens ?? 0) + b.inputTokens,
+    outputTokens: (a?.outputTokens ?? 0) + b.outputTokens,
+    cacheReadTokens: sumOptional(a?.cacheReadTokens, b.cacheReadTokens),
+    cacheWriteTokens: sumOptional(a?.cacheWriteTokens, b.cacheWriteTokens)
+  };
+}
+function totalTokens(u) {
+  return u.inputTokens + u.outputTokens + (u.cacheReadTokens ?? 0) + (u.cacheWriteTokens ?? 0);
+}
+
+// src/agents/spawn.ts
+import { createInterface } from "readline";
+import { execa } from "execa";
+async function spawnAgentTurn(thread, input, onEvent) {
+  ensureAgentPath();
+  if (!thread.worktreePath?.trim()) {
+    throw new Error(
+      `Cannot spawn ${thread.agent}: thread ${thread.id} has no worktreePath`
+    );
+  }
+  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-R44HGBU6.js");
+  if (isGlobalThread2(thread)) {
+    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-6R2TX4WQ.js");
+    ensureGlobalCoordinatorCwd2();
+  }
+  const adapter = getAdapter(thread.agent);
+  const cmd = await adapter.buildTurn(thread, input);
+  if (cmd.cwd !== thread.worktreePath) {
+    throw new Error(
+      `Agent cwd must be the thread worktree (got ${cmd.cwd}, expected ${thread.worktreePath})`
+    );
+  }
+  const child = execa(cmd.file, cmd.args, {
+    cwd: cmd.cwd,
+    env: childEnvWithAppSettings(cmd.env),
+    reject: false,
+    stdout: "pipe",
+    stderr: "pipe",
+    // Claude stream-json turns write a user message to stdin; otherwise ignore
+    // so Claude doesn't wait ~3s for an empty pipe.
+    stdin: cmd.stdin != null ? "pipe" : "ignore"
+  });
+  if (cmd.stdin != null && child.stdin) {
+    child.stdin.write(cmd.stdin);
+    child.stdin.end();
+  }
+  let sessionId = thread.sessionId;
+  let assistantText = "";
+  let parts = [];
+  let usage = null;
+  const consume = (stream, kind) => {
+    if (!stream) return;
+    const rl = createInterface({ input: stream, crlfDelay: Infinity });
+    rl.on("line", (line) => {
+      if (kind === "stderr") {
+        onEvent({ type: "stderr", data: line });
+        return;
+      }
+      let events = normalizeParseResult(adapter.parseEvent(line));
+      if (thread.agent === "brightsy" && kind === "stdout" && isBrightsyNdjsonLine(line)) {
+        const dumped = events.some(
+          (e) => e.type === "stdout" && isBrightsyNdjsonLine(e.data)
+        );
+        if (events.length === 0 || dumped) {
+          events = normalizeParseResult(parseBrightsyCliLine(line));
+        }
+      }
+      for (const parsed of events) {
+        if (parsed.type === "session_id") {
+          sessionId = parsed.data;
+          onEvent(parsed);
+          continue;
+        }
+        if (parsed.type === "usage") {
+          usage = mergeUsage(usage, parsed.data);
+          onEvent(parsed);
+          continue;
+        }
+        if (parsed.type === "stdout") {
+          if (thread.agent === "brightsy" && isBrightsyNdjsonLine(parsed.data)) {
+            continue;
+          }
+          if (assistantText && (parsed.data === assistantText || assistantText.endsWith(parsed.data))) {
+            continue;
+          }
+          assistantText += parsed.data;
+        }
+        parts = applyAgentEvent(parts, parsed);
+        onEvent(parsed);
+      }
+    });
+  };
+  consume(child.stdout, "stdout");
+  consume(child.stderr, "stderr");
+  const done = child.then((result) => {
+    const exitCode = result.exitCode ?? null;
+    onEvent({ type: "exit", data: exitCode });
+    const finalized = finalizeParts(parts);
+    const rawText = assistantText.trim() || partsToAssistantText(finalized);
+    const text = thread.agent === "brightsy" ? stripBrightsyNdjsonNoise(rawText) : rawText;
+    return { exitCode, sessionId, assistantText: text, parts: finalized, usage };
+  });
+  return {
+    pid: child.pid,
+    kill: () => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+    },
+    done
+  };
+}
+
+// src/agents/instructions.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import { join } from "path";
+function normPath(p) {
+  return p.replace(/\/+$/, "");
+}
+function formatRenameBranchDirective(thread, opts) {
+  if (!isPlaceholderBranch(thread.branchName, thread.worktreePath)) return null;
+  const dir = worktreeNameFromPath(thread.worktreePath);
+  const lines = [
+    "Branch naming (do this early in the turn):",
+    `- Current branch \`${thread.branchName}\` is a temporary placeholder. The worktree folder \`${dir}\` is a stable soccer-team nickname \u2014 do not rename or leave that directory.`,
+    "- Rename the git branch to a short kebab-case name that describes this task (what you are changing), e.g. `fix/panel-width` or `feat/dark-mode`:",
+    "  `git branch -m <new-name>`",
+    "- Prefer Conventional Commits style prefixes when they fit (`fix/`, `feat/`, `chore/`, `docs/`).",
+    "- Never push or merge to main/master from here."
+  ];
+  const custom = opts?.customPrompt?.trim();
+  if (custom) {
+    lines.push(`- Repository naming preference: ${custom}`);
+  }
+  return lines.join("\n");
+}
+function formatWorktreeDirective(thread) {
+  const worktree = normPath(thread.worktreePath);
+  const repo = normPath(thread.repoPath);
+  const dir = worktreeNameFromPath(thread.worktreePath);
+  const lines = [
+    "Sideboard workspace (mandatory):",
+    `- Worktree (your only working directory): ${worktree}`,
+    `- Branch: ${thread.branchName}`,
+    `- Worktree folder nickname (stable, do not rename): ${dir}`
+  ];
+  if (worktree && repo && worktree !== repo) {
+    lines.push(`- Main repo checkout (do NOT edit application code here): ${repo}`);
+    lines.push(
+      "Stay inside the worktree for all Reads, Edits, Writes, installs, tests, and git commands. The main repo is a separate checkout used as the git base/remote \u2014 changing files there breaks isolation for this thread and other worktrees."
+    );
+  } else {
+    lines.push(
+      "All file operations and shell commands must use this worktree as cwd. Do not switch to another checkout."
+    );
+  }
+  lines.push("");
+  lines.push("Pull requests (when the work is ready to share):");
+  lines.push(
+    "- Derive the PR title and body from what the changes actually do and why \u2014 inspect the diff/commits and the user request. Do not use the soccer-team worktree nickname or placeholder branch as the PR title."
+  );
+  lines.push(
+    "- Prefer a concise imperative title (Conventional Commits style when it fits: feat:/fix:/chore:/docs:). Body should summarize intent, key changes, and test notes."
+  );
+  lines.push(
+    "- Commit with messages that state the purpose of the change (same standard as the PR). Stay on this thread branch; never push or merge to main/master from here."
+  );
+  if (thread.prUrl) {
+    lines.push(
+      `- A PR already exists (${thread.prUrl}). Update it (push + edit title/body if the purpose drifted) instead of opening a duplicate.`
+    );
+  } else {
+    lines.push(
+      "- Prefer a draft PR first: `gh pr create --draft` (or update via `gh pr edit`) once the change set is coherent. Mark ready for review only when asked. Title/body must reflect the change purpose, not the worktree name."
+    );
+  }
+  return lines.join("\n");
+}
+var FILES_BY_AGENT = {
+  claude: [
+    "CLAUDE.md",
+    ".claude/CLAUDE.md",
+    "CLAUDE.local.md",
+    "AGENTS.md",
+    "AGENT.md"
+  ],
+  codex: ["AGENTS.md", "AGENT.md", ".codex/AGENTS.md", "CLAUDE.md"],
+  opencode: ["AGENTS.md", "AGENT.md", "OPENCODE.md", "CLAUDE.md"],
+  brightsy: ["AGENTS.md", "AGENT.md", "CLAUDE.md"],
+  cursor: ["AGENTS.md", "AGENT.md", ".cursor/rules", "CLAUDE.md"]
+};
+var MAX_CHARS_PER_FILE = 48e3;
+function loadAgentInstructions(worktreePath, agent) {
+  const candidates = FILES_BY_AGENT[agent] ?? FILES_BY_AGENT.claude;
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const rel of candidates) {
+    if (seen.has(rel)) continue;
+    const abs = join(worktreePath, rel);
+    if (!existsSync(abs)) continue;
+    try {
+      if (!statSync(abs).isFile()) continue;
+      let content = readFileSync(abs, "utf8");
+      if (!content.trim()) continue;
+      if (content.length > MAX_CHARS_PER_FILE) {
+        content = `${content.slice(0, MAX_CHARS_PER_FILE)}
+
+\u2026(truncated)`;
+      }
+      seen.add(rel);
+      out.push({ relativePath: rel, content });
+    } catch {
+    }
+  }
+  return out;
+}
+function formatAgentInstructions(files) {
+  if (files.length === 0) return null;
+  const parts = [
+    "Project agent instructions (from the worktree \u2014 follow these):",
+    ""
+  ];
+  for (const f of files) {
+    parts.push(`## ${f.relativePath}`);
+    parts.push("");
+    parts.push(f.content.trim());
+    parts.push("");
+    parts.push("---");
+    parts.push("");
+  }
+  return parts.join("\n").trimEnd();
+}
+function withAgentInstructions(prompt, files) {
+  const prefix = formatAgentInstructions(files);
+  if (!prefix) return prompt;
+  return `${prefix}
+
+${prompt}`;
+}
+
+// src/detect/detect.ts
+async function detectAgents() {
+  ensureAgentPath();
+  return Promise.all(allAdapters().map((a) => a.detect()));
+}
+async function requireAgent(agent, opts) {
+  const status = (await detectAgents()).find((s) => s.agent === agent);
+  if (!status) throw new Error(`Unknown agent: ${agent}`);
+  if (!status.installed || !status.authenticated) {
+    throw new Error(status.reason ?? `${agent} is not available`);
+  }
+  if (opts?.requireLinear && !status.linearMcp) {
+    throw new Error(
+      `${agent} has no Linear MCP server configured \u2014 ticket sources require it`
+    );
+  }
+  return status;
+}
+
+// src/hook/conductor.ts
+import {
+  copyFileSync,
+  existsSync as existsSync2,
+  mkdirSync,
+  readdirSync,
+  readFileSync as readFileSync2
+} from "fs";
+import { createServer } from "net";
+import { basename, dirname, join as join2 } from "path";
+import { execa as execa2 } from "execa";
+import { createInterface as createInterface2 } from "readline";
+var PORT_RANGE_SIZE = 10;
+function matchSimpleGlob(pattern, name) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${escaped}$`).test(name);
+}
+function readWorktreeInclude(repoPath) {
+  const path = join2(repoPath, ".worktreeinclude");
+  if (!existsSync2(path)) return [];
+  return readFileSync2(path, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+}
+function resolveFilesToCopy(repoPath) {
+  const fromInclude = readWorktreeInclude(repoPath);
+  if (fromInclude.length) return fromInclude;
+  const settings = loadRepoSettings(repoPath);
+  if (settings?.filesToCopy?.length) return settings.filesToCopy;
+  if (settings?.fileIncludeGlobs?.length) {
+    const matched = [];
+    try {
+      for (const entry of readdirSync(repoPath, { withFileTypes: true })) {
+        if (!entry.isFile()) continue;
+        for (const glob of settings.fileIncludeGlobs) {
+          if (matchSimpleGlob(glob, entry.name) || matchSimpleGlob(basename(glob), entry.name)) {
+            matched.push(entry.name);
+            break;
+          }
+        }
+      }
+    } catch {
+    }
+    if (matched.length) return [...new Set(matched)];
+  }
+  const defaults = [];
+  try {
+    for (const entry of readdirSync(repoPath, { withFileTypes: true })) {
+      if (entry.isFile() && entry.name.startsWith(".env")) {
+        defaults.push(entry.name);
+      }
+    }
+  } catch {
+  }
+  if (defaults.length) return defaults;
+  return [".env.local", ".env"];
+}
+function copyConfiguredFiles(repoPath, worktreePath) {
+  const patterns = resolveFilesToCopy(repoPath);
+  const copied = [];
+  for (const rel of patterns) {
+    const src = join2(repoPath, rel);
+    if (!existsSync2(src)) continue;
+    const dest = join2(worktreePath, rel);
+    mkdirSync(dirname(dest), { recursive: true });
+    copyFileSync(src, dest);
+    copied.push(rel);
+  }
+  return copied;
+}
+var cachedLoginEnv = null;
+async function captureLoginEnv() {
+  if (cachedLoginEnv) return { ...cachedLoginEnv };
+  const shell = process.env.SHELL?.trim() || (process.platform === "darwin" ? "/bin/zsh" : "/bin/bash");
+  try {
+    const result = await execa2(shell, ["-l", "-c", "env -0"], {
+      reject: false,
+      timeout: 5e3
+    });
+    if (result.exitCode === 0 && result.stdout) {
+      const env = { ...process.env };
+      for (const entry of result.stdout.split("\0")) {
+        if (!entry) continue;
+        const eq = entry.indexOf("=");
+        if (eq <= 0) continue;
+        const key = entry.slice(0, eq);
+        const value = entry.slice(eq + 1);
+        if (key) env[key] = value;
+      }
+      cachedLoginEnv = env;
+      return { ...env };
+    }
+  } catch {
+  }
+  cachedLoginEnv = { ...process.env };
+  return { ...cachedLoginEnv };
+}
+function buildWorkspaceScriptEnv(opts, baseEnv) {
+  const env = { ...baseEnv ?? process.env };
+  const name = opts.workspaceName ?? basename(opts.worktreePath);
+  const ports = opts.ports ?? [];
+  const primary = ports[0];
+  env.SIDEBOARD_WORKSPACE_NAME = name;
+  env.SIDEBOARD_WORKSPACE_PATH = opts.worktreePath;
+  env.SIDEBOARD_ROOT_PATH = opts.repoPath;
+  env.SIDEBOARD_IS_LOCAL = "1";
+  if (opts.defaultBranch) env.SIDEBOARD_DEFAULT_BRANCH = opts.defaultBranch;
+  env.CONDUCTOR_WORKSPACE_NAME = name;
+  env.CONDUCTOR_WORKSPACE_PATH = opts.worktreePath;
+  env.CONDUCTOR_ROOT_PATH = opts.repoPath;
+  env.CONDUCTOR_IS_LOCAL = "1";
+  if (opts.defaultBranch) env.CONDUCTOR_DEFAULT_BRANCH = opts.defaultBranch;
+  if (primary != null) {
+    env.SIDEBOARD_PORT = String(primary);
+    env.CONDUCTOR_PORT = String(primary);
+    env.PORT = String(primary);
+    for (let i = 1; i < ports.length; i++) {
+      const p = ports[i];
+      env[`SIDEBOARD_PORT_${i}`] = String(p);
+      env[`CONDUCTOR_PORT_${i}`] = String(p);
+    }
+  }
+  return env;
+}
+function pipeLines(stream, onLine) {
+  if (!stream || !onLine) return;
+  const rl = createInterface2({ input: stream });
+  rl.on("line", onLine);
+}
+async function spawnWorkspaceScript(command, opts) {
+  const loginEnv = await captureLoginEnv();
+  const env = buildWorkspaceScriptEnv(
+    {
+      worktreePath: opts.worktreePath,
+      repoPath: opts.repoPath,
+      workspaceName: opts.workspaceName,
+      defaultBranch: opts.defaultBranch,
+      ports: opts.ports
+    },
+    loginEnv
+  );
+  const shell = process.platform === "darwin" ? "zsh" : "bash";
+  const child = execa2(shell, ["-lc", command], {
+    cwd: opts.worktreePath,
+    reject: false,
+    env
+  });
+  pipeLines(child.stdout, opts.onLine);
+  pipeLines(child.stderr, opts.onLine);
+  return {
+    pid: child.pid,
+    kill: () => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+    },
+    done: child.then((r) => r.exitCode ?? null),
+    child
+  };
+}
+async function runSetupScript(repoPath, worktreePath, onLine, opts) {
+  const settings = loadWorkspaceSettings(worktreePath, repoPath);
+  if (!settings?.setup) return { ran: false, exitCode: null, source: null };
+  const handle = await spawnWorkspaceScript(settings.setup, {
+    worktreePath,
+    repoPath,
+    defaultBranch: opts?.defaultBranch,
+    onLine
+  });
+  if (opts?.signal) {
+    const onAbort = () => handle.kill();
+    if (opts.signal.aborted) onAbort();
+    else opts.signal.addEventListener("abort", onAbort, { once: true });
+  }
+  const exitCode = await handle.done;
+  return {
+    ran: true,
+    exitCode,
+    source: workspaceSettingsSourceLabel(worktreePath, repoPath),
+    kill: handle.kill
+  };
+}
+async function runArchiveScript(repoPath, worktreePath, onLine) {
+  const settings = loadWorkspaceSettings(worktreePath, repoPath);
+  if (!settings?.archive) return { ran: false, exitCode: null };
+  const handle = await spawnWorkspaceScript(settings.archive, {
+    worktreePath,
+    repoPath,
+    onLine
+  });
+  const exitCode = await handle.done;
+  return { ran: true, exitCode };
+}
+function listRunScripts(worktreePath, repoPath) {
+  const settings = loadWorkspaceSettings(worktreePath, repoPath);
+  if (!settings?.runScripts.length) return [];
+  return settings.runScripts.filter((s) => {
+    if (!s.availableIn?.length) return true;
+    return s.availableIn.includes("local");
+  });
+}
+function getDefaultRunScript(worktreePath, repoPath) {
+  const scripts = listRunScripts(worktreePath, repoPath);
+  if (!scripts.length) return null;
+  return scripts.find((s) => s.default === true) ?? scripts.find((s) => s.name === "dev") ?? scripts.find((s) => s.name !== "all") ?? scripts[0] ?? null;
+}
+function getRunScript(worktreePath, repoPath, name) {
+  const scripts = listRunScripts(worktreePath, repoPath);
+  if (!scripts.length) return null;
+  if (name) {
+    return scripts.find((s) => s.name === name) ?? null;
+  }
+  return getDefaultRunScript(worktreePath, repoPath);
+}
+function getRunMode(worktreePath, repoPath) {
+  return loadWorkspaceSettings(worktreePath, repoPath)?.runMode ?? "concurrent";
+}
+async function allocatePort() {
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        server.close();
+        reject(new Error("Failed to allocate port"));
+        return;
+      }
+      const port = addr.port;
+      server.close((err) => err ? reject(err) : resolve(port));
+    });
+    server.on("error", reject);
+  });
+}
+async function allocatePortRange(size = PORT_RANGE_SIZE) {
+  const base = await allocatePort();
+  const ports = [base];
+  for (let i = 1; i < size; i++) {
+    const candidate = base + i;
+    const free = await new Promise((resolve) => {
+      const server = createServer();
+      server.once("error", () => resolve(false));
+      server.listen(candidate, "127.0.0.1", () => {
+        server.close(() => resolve(true));
+      });
+    });
+    if (free) {
+      ports.push(candidate);
+    } else {
+      ports.push(await allocatePort());
+    }
+  }
+  return ports;
+}
+async function startDevServer(repoPath, worktreePath, onLine, opts) {
+  const script = getRunScript(worktreePath, repoPath, opts?.scriptName);
+  if (!script) return null;
+  const ports = await allocatePortRange(PORT_RANGE_SIZE);
+  const handle = await spawnWorkspaceScript(script.command, {
+    worktreePath,
+    repoPath,
+    ports,
+    defaultBranch: opts?.defaultBranch,
+    onLine
+  });
+  return {
+    pid: handle.pid,
+    port: ports[0],
+    ports,
+    scriptName: script.name,
+    kill: handle.kill,
+    done: handle.done
+  };
+}
+
+// src/hook/cursor-worktrees.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+import { execa as execa3 } from "execa";
+import { createInterface as createInterface3 } from "readline";
+function loadCursorWorktreesJson(rootPath) {
+  const path = join3(rootPath, ".cursor", "worktrees.json");
+  if (!existsSync3(path)) return null;
+  try {
+    return JSON.parse(readFileSync3(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function resolveSetupSpec(config) {
+  if (process.platform === "win32") {
+    return config["setup-worktree-windows"] ?? config["setup-worktree"] ?? null;
+  }
+  return config["setup-worktree-unix"] ?? config["setup-worktree"] ?? null;
+}
+async function runCursorWorktreeSetup(repoPath, worktreePath, onLine) {
+  const fromWorktree = loadCursorWorktreesJson(worktreePath);
+  const fromRepo = worktreePath !== repoPath ? loadCursorWorktreesJson(repoPath) : null;
+  const config = fromWorktree ?? fromRepo;
+  if (!config) return { ran: false, exitCode: null, source: null };
+  const spec = resolveSetupSpec(config);
+  if (!spec) return { ran: false, exitCode: null, source: null };
+  const sourceLabel = fromWorktree ? ".cursor/worktrees.json (worktree)" : ".cursor/worktrees.json (main repo)";
+  const env = {
+    ...process.env,
+    ROOT_WORKTREE_PATH: repoPath
+  };
+  if (process.platform === "win32") {
+    env.ROOT_WORKTREE_PATH = repoPath;
+  }
+  const commands = Array.isArray(spec) ? spec : [spec.endsWith(".sh") || spec.endsWith(".ps1") ? join3(
+    fromWorktree ? worktreePath : repoPath,
+    ".cursor",
+    spec
+  ) : spec];
+  let lastExit = 0;
+  for (const command of commands) {
+    const isScriptPath = typeof spec === "string" && (spec.endsWith(".sh") || spec.endsWith(".ps1"));
+    const shell = process.platform === "win32" ? "powershell" : "bash";
+    const args = process.platform === "win32" ? isScriptPath ? ["-File", command] : ["-Command", command] : isScriptPath ? [command] : ["-lc", command];
+    onLine?.(`[cursor setup] ${command}`);
+    const child = execa3(shell, args, {
+      cwd: worktreePath,
+      reject: false,
+      env
+    });
+    if (child.stdout && onLine) {
+      const rl = createInterface3({ input: child.stdout });
+      rl.on("line", onLine);
+    }
+    if (child.stderr && onLine) {
+      const rl = createInterface3({ input: child.stderr });
+      rl.on("line", onLine);
+    }
+    const result = await child;
+    lastExit = result.exitCode ?? null;
+    if (lastExit !== 0 && lastExit !== null) break;
+  }
+  return { ran: true, exitCode: lastExit, source: sourceLabel };
+}
+function hasCursorWorktreeSetup(worktreePath, repoPath) {
+  if (loadCursorWorktreesJson(worktreePath)) return true;
+  if (repoPath && repoPath !== worktreePath && loadCursorWorktreesJson(repoPath)) {
+    return true;
+  }
+  return false;
+}
+
+// src/diff/diff.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, statSync as statSync2, writeFileSync } from "fs";
+import { dirname as dirname2, join as join4 } from "path";
+async function inspectGitWorktree(worktreePath) {
+  if (!worktreePath || !existsSync4(worktreePath)) return "missing_worktree";
+  const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
+    reject: false
+  });
+  if (check.exitCode !== 0 || check.stdout.trim() !== "true") return "not_git";
+  return "ok";
+}
+async function initializeGitRepository(worktreePath) {
+  if (!worktreePath || !existsSync4(worktreePath)) {
+    throw new Error("Worktree not found");
+  }
+  const status = await inspectGitWorktree(worktreePath);
+  if (status === "ok") return;
+  const result = await git(["init"], worktreePath, { reject: false });
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr.trim() || "Failed to initialize Git repository");
+  }
+}
+async function captureTurnBaseline(worktreePath) {
+  const status = await inspectGitWorktree(worktreePath);
+  if (status !== "ok") return null;
+  const stash = await git(["stash", "create"], worktreePath, { reject: false });
+  const stashSha = stash.stdout.trim();
+  if (stashSha) return stashSha;
+  const head = await git(["rev-parse", "--verify", "HEAD"], worktreePath, {
+    reject: false
+  });
+  return head.exitCode === 0 ? head.stdout.trim() : null;
+}
+function parseNameStatus(stdout) {
+  const out = [];
+  for (const line of stdout.split("\n").filter(Boolean)) {
+    const [status, ...pathParts] = line.split("	");
+    const path = pathParts[pathParts.length - 1];
+    if (!status || !path) continue;
+    out.push({ status: status[0] ?? status, path });
+  }
+  return out;
+}
+function parseNumstat(stdout) {
+  const map = /* @__PURE__ */ new Map();
+  for (const line of stdout.split("\n").filter(Boolean)) {
+    const [addRaw, delRaw, ...pathParts] = line.split("	");
+    const path = pathParts[pathParts.length - 1];
+    if (!path) continue;
+    const additions = addRaw === "-" ? 0 : Number(addRaw);
+    const deletions = delRaw === "-" ? 0 : Number(delRaw);
+    if (!Number.isFinite(additions) && !Number.isFinite(deletions)) continue;
+    map.set(path, {
+      additions: Number.isFinite(additions) ? additions : 0,
+      deletions: Number.isFinite(deletions) ? deletions : 0
+    });
+  }
+  return map;
+}
+function emptyStat() {
+  return { files: 0, additions: 0, deletions: 0 };
+}
+function statFromNumstat(stdout, extraFiles = 0) {
+  const map = parseNumstat(stdout);
+  let additions = 0;
+  let deletions = 0;
+  for (const c of map.values()) {
+    additions += c.additions;
+    deletions += c.deletions;
+  }
+  return { files: map.size + extraFiles, additions, deletions };
+}
+function capPatch(patch, maxHunk) {
+  if (patch.length <= maxHunk) return patch;
+  return `${patch.slice(0, maxHunk)}
+
+\u2026 truncated (${patch.length - maxHunk} more chars)`;
+}
+async function resolveMergeBase(worktreePath, base, repoPath) {
+  const baseRef = await resolveDiffBaseRef(worktreePath, base, repoPath);
+  const { stdout } = await git(["merge-base", baseRef, "HEAD"], worktreePath, {
+    reject: false
+  });
+  const mb = stdout.trim();
+  return mb || baseRef;
+}
+async function countUnpushedCommits(worktreePath) {
+  const upstream = await git(
+    ["rev-list", "--count", "@{upstream}..HEAD"],
+    worktreePath,
+    { reject: false }
+  );
+  if (upstream.exitCode === 0) {
+    const n2 = Number(upstream.stdout.trim());
+    return Number.isFinite(n2) ? n2 : 0;
+  }
+  const head = await git(["rev-parse", "--abbrev-ref", "HEAD"], worktreePath, {
+    reject: false
+  });
+  const branch = head.stdout.trim();
+  if (!branch || branch === "HEAD") return 0;
+  const remote = await git(
+    ["rev-list", "--count", `origin/${branch}..HEAD`],
+    worktreePath,
+    { reject: false }
+  );
+  if (remote.exitCode !== 0) return 0;
+  const n = Number(remote.stdout.trim());
+  return Number.isFinite(n) ? n : 0;
+}
+function splitCombinedDiff(stdout) {
+  const map = /* @__PURE__ */ new Map();
+  if (!stdout.trim()) return map;
+  const parts = stdout.split(/^diff --git /m);
+  for (const part of parts) {
+    if (!part.trim()) continue;
+    const full = `diff --git ${part}`.replace(/\n$/, "");
+    const header = full.match(/^diff --git a\/(.+?) b\/(.+?)(?:\n|$)/);
+    if (!header) continue;
+    map.set(header[2], full);
+  }
+  return map;
+}
+async function untrackedPatch(worktreePath, path, maxHunk) {
+  const { stdout: patch } = await git(
+    ["diff", "--no-index", "--", "/dev/null", path],
+    worktreePath,
+    { reject: false }
+  );
+  const normalized = patch.replace(/^diff --git a\/.+? b\/.+?$/m, `diff --git a/${path} b/${path}`).replace(/^--- .*$/m, "--- /dev/null").replace(/^\+\+\+ .*$/m, `+++ b/${path}`);
+  const addLines = normalized.split("\n").filter((l) => l.startsWith("+") && !l.startsWith("+++")).length;
+  return {
+    path,
+    status: "A",
+    patch: capPatch(normalized, maxHunk),
+    additions: addLines,
+    deletions: 0
+  };
+}
+async function listUntrackedPaths(worktreePath) {
+  const { stdout } = await git(
+    ["ls-files", "-z", "--others", "--exclude-standard"],
+    worktreePath,
+    { reject: false }
+  );
+  return stdout.split("\0").filter(Boolean);
+}
+async function listUntrackedFiles(worktreePath, maxHunk) {
+  const paths = await listUntrackedPaths(worktreePath);
+  if (paths.length === 0) return [];
+  return Promise.all(paths.map((path) => untrackedPatch(worktreePath, path, maxHunk)));
+}
+function filesFromDiff(nameStatus, numstat, combinedDiff, maxHunk) {
+  const counts = parseNumstat(numstat);
+  const patches = splitCombinedDiff(combinedDiff);
+  const files = [];
+  for (const { status, path } of parseNameStatus(nameStatus)) {
+    const n = counts.get(path);
+    files.push({
+      path,
+      status,
+      patch: capPatch(patches.get(path) ?? "", maxHunk),
+      additions: n?.additions,
+      deletions: n?.deletions
+    });
+  }
+  return files;
+}
+async function computeScopeStats(worktreePath, mergeBase, lastTurnBase, untrackedCount) {
+  const [
+    { stdout: commitsNum },
+    { stdout: uncommittedNum },
+    { stdout: stagedNum },
+    { stdout: unstagedNum },
+    lastTurnNum
+  ] = await Promise.all([
+    mergeBase ? git(["diff", "--numstat", mergeBase], worktreePath, { reject: false }) : Promise.resolve({ stdout: "" }),
+    git(["diff", "--numstat", "HEAD"], worktreePath, { reject: false }),
+    git(["diff", "--numstat", "--cached"], worktreePath, { reject: false }),
+    git(["diff", "--numstat"], worktreePath, { reject: false }),
+    lastTurnBase ? git(["diff", "--numstat", lastTurnBase], worktreePath, { reject: false }) : Promise.resolve({ stdout: "" })
+  ]);
+  return {
+    commits: mergeBase ? statFromNumstat(commitsNum, untrackedCount) : emptyStat(),
+    uncommitted: statFromNumstat(uncommittedNum, untrackedCount),
+    staged: statFromNumstat(stagedNum),
+    unstaged: statFromNumstat(unstagedNum, untrackedCount),
+    last_turn: lastTurnBase ? statFromNumstat(lastTurnNum.stdout, untrackedCount) : emptyStat()
+  };
+}
+async function listBranchCommits(worktreePath, repoPath, opts) {
+  const status = await inspectGitWorktree(worktreePath);
+  if (status !== "ok") return [];
+  const head = await git(["rev-parse", "--verify", "HEAD"], worktreePath, {
+    reject: false
+  });
+  if (head.exitCode !== 0) return [];
+  let base = opts?.base;
+  try {
+    base = base ?? await resolveDefaultBranch(repoPath);
+  } catch {
+    base = "HEAD";
+  }
+  const mergeBase = await resolveMergeBase(worktreePath, base, repoPath);
+  const max = opts?.max ?? 40;
+  const { stdout } = await git(
+    [
+      "log",
+      "--date=relative",
+      `--max-count=${max}`,
+      "--format=%H%x09%h%x09%s%x09%cr",
+      `${mergeBase}..HEAD`
+    ],
+    worktreePath,
+    { reject: false }
+  );
+  const commits = [];
+  for (const line of stdout.split("\n").filter(Boolean)) {
+    const [sha, shortSha, subject, relativeTime] = line.split("	");
+    if (!sha || !shortSha) continue;
+    commits.push({
+      sha,
+      shortSha,
+      subject: subject || "(no subject)",
+      relativeTime: relativeTime || ""
+    });
+  }
+  return commits;
+}
+async function getDiff(worktreePath, repoPath, opts) {
+  const status = await inspectGitWorktree(worktreePath);
+  if (status === "missing_worktree") {
+    throw new Error("Worktree not found");
+  }
+  if (status === "not_git") {
+    throw new Error("Not a Git repository");
+  }
+  const maxHunk = opts?.maxHunkChars ?? 8e3;
+  const scope = opts?.scope ?? "commits";
+  const lastTurnBase = opts?.lastTurnBase?.trim() || null;
+  const hasLastTurnBase = Boolean(lastTurnBase);
+  const commitSha = opts?.commitSha?.trim() || null;
+  const head = await git(["rev-parse", "--verify", "HEAD"], worktreePath, {
+    reject: false
+  });
+  const hasHead = head.exitCode === 0;
+  const untrackedPaths = await listUntrackedPaths(worktreePath);
+  if (!hasHead) {
+    const files2 = scope === "staged" ? [] : (await listUntrackedFiles(worktreePath, maxHunk)).sort(
+      (a, b) => a.path.localeCompare(b.path)
+    );
+    const untrackedStat = {
+      files: files2.length,
+      additions: files2.reduce((n, f) => n + (f.additions ?? 0), 0),
+      deletions: 0
+    };
+    const zero = emptyStat();
+    return {
+      scope,
+      commitSha: null,
+      base: "(no commits)",
+      files: files2,
+      stat: files2.length ? files2.map((f) => ` ${f.path} | untracked`).join("\n") : "(no changes)",
+      dirty: files2.length > 0,
+      unpushed: 0,
+      hasLastTurnBase,
+      commits: [],
+      scopeStats: {
+        commits: untrackedStat,
+        uncommitted: untrackedStat,
+        staged: zero,
+        unstaged: untrackedStat,
+        last_turn: hasLastTurnBase ? untrackedStat : zero
+      }
+    };
+  }
+  let base = opts?.base;
+  try {
+    base = base ?? await resolveDefaultBranch(repoPath);
+  } catch {
+    base = "HEAD";
+  }
+  base = await resolveDiffBaseRef(worktreePath, base, repoPath);
+  if (base.startsWith("origin/")) {
+    const short = base.slice("origin/".length);
+    await git(["fetch", "origin", short, "--quiet"], worktreePath, {
+      reject: false
+    });
+    base = await resolveDiffBaseRef(worktreePath, short, repoPath);
+  }
+  const mergeBase = await resolveMergeBase(worktreePath, base, repoPath);
+  const scopeStats = await computeScopeStats(
+    worktreePath,
+    mergeBase,
+    lastTurnBase,
+    untrackedPaths.length
+  );
+  const includeUntracked = scope === "commits" && !commitSha || scope === "uncommitted" || scope === "unstaged" || scope === "last_turn";
+  let nameStatus = "";
+  let numstat = "";
+  let combinedDiff = "";
+  let labelBase = base;
+  if (scope === "staged") {
+    const [ns, num, diff] = await Promise.all([
+      git(["diff", "--name-status", "--cached"], worktreePath, { reject: false }),
+      git(["diff", "--numstat", "--cached"], worktreePath, { reject: false }),
+      git(["diff", "--cached"], worktreePath, { reject: false })
+    ]);
+    nameStatus = ns.stdout;
+    numstat = num.stdout;
+    combinedDiff = diff.stdout;
+    labelBase = "staged";
+  } else if (scope === "unstaged") {
+    const [ns, num, diff] = await Promise.all([
+      git(["diff", "--name-status"], worktreePath, { reject: false }),
+      git(["diff", "--numstat"], worktreePath, { reject: false }),
+      git(["diff"], worktreePath, { reject: false })
+    ]);
+    nameStatus = ns.stdout;
+    numstat = num.stdout;
+    combinedDiff = diff.stdout;
+    labelBase = "unstaged";
+  } else if (scope === "uncommitted") {
+    const [ns, num, diff] = await Promise.all([
+      git(["diff", "--name-status", "HEAD"], worktreePath, { reject: false }),
+      git(["diff", "--numstat", "HEAD"], worktreePath, { reject: false }),
+      git(["diff", "HEAD"], worktreePath, { reject: false })
+    ]);
+    nameStatus = ns.stdout;
+    numstat = num.stdout;
+    combinedDiff = diff.stdout;
+    labelBase = "HEAD";
+  } else if (scope === "last_turn") {
+    if (!lastTurnBase) {
+      const commits2 = await listBranchCommits(worktreePath, repoPath, { base });
+      return {
+        scope,
+        commitSha: null,
+        base: "last turn",
+        files: [],
+        stat: "(no last agent turn)",
+        dirty: await isDirty(worktreePath),
+        unpushed: await countUnpushedCommits(worktreePath),
+        hasLastTurnBase: false,
+        commits: commits2,
+        scopeStats
+      };
+    }
+    const [ns, num, diff] = await Promise.all([
+      git(["diff", "--name-status", lastTurnBase], worktreePath, { reject: false }),
+      git(["diff", "--numstat", lastTurnBase], worktreePath, { reject: false }),
+      git(["diff", lastTurnBase], worktreePath, { reject: false })
+    ]);
+    nameStatus = ns.stdout;
+    numstat = num.stdout;
+    combinedDiff = diff.stdout;
+    labelBase = "last turn";
+  } else if (scope === "commits" && commitSha) {
+    const range = `${commitSha}^!`;
+    const [ns, num, diff] = await Promise.all([
+      git(["diff", "--name-status", range], worktreePath, { reject: false }),
+      git(["diff", "--numstat", range], worktreePath, { reject: false }),
+      git(["diff", range], worktreePath, { reject: false })
+    ]);
+    nameStatus = ns.stdout;
+    numstat = num.stdout;
+    combinedDiff = diff.stdout;
+    labelBase = commitSha.slice(0, 7);
+  } else {
+    const [ns, num, diff] = await Promise.all([
+      git(["diff", "--name-status", mergeBase], worktreePath, { reject: false }),
+      git(["diff", "--numstat", mergeBase], worktreePath, { reject: false }),
+      git(["diff", mergeBase], worktreePath, { reject: false })
+    ]);
+    nameStatus = ns.stdout;
+    numstat = num.stdout;
+    combinedDiff = diff.stdout;
+    labelBase = base;
+  }
+  const commits = await listBranchCommits(worktreePath, repoPath, { base });
+  const filesMap = /* @__PURE__ */ new Map();
+  for (const file of filesFromDiff(nameStatus, numstat, combinedDiff, maxHunk)) {
+    filesMap.set(file.path, file);
+  }
+  if (includeUntracked) {
+    const untrackedFiles = await listUntrackedFiles(worktreePath, maxHunk);
+    for (const file of untrackedFiles) {
+      if (!filesMap.has(file.path)) filesMap.set(file.path, file);
+    }
+  }
+  const files = [...filesMap.values()].sort((a, b) => a.path.localeCompare(b.path));
+  const { stdout: statOut } = await git(
+    scope === "staged" ? ["diff", "--stat", "--cached"] : scope === "unstaged" ? ["diff", "--stat"] : scope === "uncommitted" ? ["diff", "--stat", "HEAD"] : scope === "last_turn" && lastTurnBase ? ["diff", "--stat", lastTurnBase] : scope === "commits" && commitSha ? ["diff", "--stat", `${commitSha}^!`] : ["diff", "--stat", mergeBase],
+    worktreePath,
+    { reject: false }
+  );
+  return {
+    scope,
+    commitSha: scope === "commits" ? commitSha : null,
+    base: labelBase,
+    files,
+    stat: statOut.trim() || (files.length ? `${files.length} file(s)` : "(no changes)"),
+    dirty: await isDirty(worktreePath),
+    unpushed: await countUnpushedCommits(worktreePath),
+    hasLastTurnBase,
+    commits,
+    scopeStats
+  };
+}
+async function listWorktreeFiles(worktreePath, opts) {
+  const maxFiles = opts?.maxFiles ?? 5e3;
+  const tracked = await git(["ls-files", "-z"], worktreePath, { reject: false });
+  const others = await git(
+    ["ls-files", "-z", "--others", "--exclude-standard"],
+    worktreePath,
+    { reject: false }
+  );
+  const paths = /* @__PURE__ */ new Set();
+  for (const chunk of [tracked.stdout, others.stdout]) {
+    for (const p of chunk.split("\0")) {
+      if (p) paths.add(p);
+    }
+  }
+  return [...paths].sort((a, b) => a.localeCompare(b)).slice(0, maxFiles);
+}
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "webp",
+  "svg",
+  "bmp",
+  "ico"
+]);
+function isImageRelativePath(relativePath) {
+  const base = relativePath.split("/").pop()?.toLowerCase() || "";
+  const ext = base.includes(".") ? base.split(".").pop() || "" : "";
+  return IMAGE_EXTENSIONS.has(ext);
+}
+function readWorktreeFile(worktreePath, relativePath, opts) {
+  assertSafeRelativePath(relativePath);
+  const maxBytes = opts?.maxBytes ?? 2e5;
+  const abs = join4(worktreePath, relativePath);
+  const st = statSync2(abs);
+  if (!st.isFile()) {
+    throw new Error(`Not a file: ${relativePath}`);
+  }
+  const buf = readFileSync4(abs);
+  if (isImageRelativePath(relativePath)) {
+    const maxImageBytes = Math.max(maxBytes, 15e6);
+    const truncated2 = buf.length > maxImageBytes;
+    const slice = buf.subarray(0, maxImageBytes);
+    return {
+      path: relativePath,
+      content: slice.toString("base64"),
+      truncated: truncated2,
+      binary: true,
+      encoding: "base64"
+    };
+  }
+  const sample = buf.subarray(0, Math.min(buf.length, 8e3));
+  const binary = sample.includes(0);
+  if (binary) {
+    return {
+      path: relativePath,
+      content: `(binary file, ${st.size} bytes)`,
+      truncated: false,
+      binary: true,
+      encoding: "utf8"
+    };
+  }
+  const truncated = buf.length > maxBytes;
+  const content = buf.subarray(0, maxBytes).toString("utf8");
+  return {
+    path: relativePath,
+    content: truncated ? `${content}
+
+\u2026 truncated (${buf.length - maxBytes} more bytes)` : content,
+    truncated,
+    binary: false,
+    encoding: "utf8"
+  };
+}
+function assertSafeRelativePath(relativePath) {
+  if (!relativePath || relativePath.includes("..") || relativePath.startsWith("/")) {
+    throw new Error("Invalid path");
+  }
+}
+function writeWorktreeFile(worktreePath, relativePath, content) {
+  assertSafeRelativePath(relativePath);
+  const abs = join4(worktreePath, relativePath);
+  mkdirSync2(dirname2(abs), { recursive: true });
+  writeFileSync(abs, content, "utf8");
+  return { path: relativePath };
+}
+async function getDiffSummary(worktreePath, repoPath, opts) {
+  const full = await getDiff(worktreePath, repoPath, {
+    maxHunkChars: opts?.maxHunkChars ?? 2e3,
+    scope: "commits"
+  });
+  const maxFiles = opts?.maxFiles ?? 10;
+  return {
+    base: full.base,
+    dirty: full.dirty,
+    stat: full.stat,
+    files: full.files.slice(0, maxFiles),
+    truncated: full.files.length > maxFiles
+  };
+}
+
+// src/skills/discover.ts
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync5, statSync as statSync3 } from "fs";
+import { homedir } from "os";
+import { join as join5 } from "path";
+function toCommand(name) {
+  return name.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function parseFrontmatter(content) {
+  const lines = content.split("\n");
+  if (lines[0]?.trim() !== "---") return { name: null, description: null };
+  let end = -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i]?.trim() === "---") {
+      end = i;
+      break;
+    }
+  }
+  if (end < 0) return { name: null, description: null };
+  const block = lines.slice(1, end).join("\n");
+  const nameMatch = block.match(/^name:\s*(.+)$/m);
+  let description = null;
+  const descInline = block.match(/^description:\s*(.+)$/m);
+  if (descInline && !descInline[1].startsWith("|") && !descInline[1].startsWith(">")) {
+    description = descInline[1].trim().replace(/^["']|["']$/g, "");
+  } else {
+    const descBlock = block.match(/^description:\s*[|>]?-?\s*\n((?:[ \t]+.+\n?)*)/m);
+    if (descBlock) {
+      description = descBlock[1].split("\n").map((l) => l.replace(/^[ \t]+/, "")).join(" ").trim();
+    }
+  }
+  const name = nameMatch?.[1]?.trim().replace(/^["']|["']$/g, "") ?? null;
+  return { name, description };
+}
+function readSkill(skillMd, source) {
+  try {
+    const content = readFileSync5(skillMd, "utf8");
+    const { name: fmName, description } = parseFrontmatter(content);
+    const dirName = skillMd.split("/").slice(-2, -1)[0] || "skill";
+    const name = fmName || dirName;
+    const command = toCommand(name);
+    if (!command) return null;
+    return {
+      id: `${source}:${skillMd}`,
+      name,
+      command,
+      description: (description || "").slice(0, 240),
+      path: skillMd,
+      source
+    };
+  } catch {
+    return null;
+  }
+}
+function scanSkillsDir(dir, source, out) {
+  if (!existsSync5(dir)) return;
+  let entries;
+  try {
+    entries = readdirSync2(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.startsWith(".")) continue;
+    const skillMd = join5(dir, entry, "SKILL.md");
+    if (!existsSync5(skillMd)) continue;
+    try {
+      if (!statSync3(skillMd).isFile()) continue;
+    } catch {
+      continue;
+    }
+    const skill = readSkill(skillMd, source);
+    if (skill) out.push(skill);
+  }
+}
+function scanClaudePluginSkills(pluginsRoot, out) {
+  if (!existsSync5(pluginsRoot)) return;
+  const walk = (dir, depth, lookingForSkillsDir) => {
+    if (depth > 7) return;
+    let entries;
+    try {
+      entries = readdirSync2(dir);
+    } catch {
+      return;
+    }
+    if (lookingForSkillsDir && entries.includes("SKILL.md")) {
+      const skill = readSkill(join5(dir, "SKILL.md"), "cli");
+      if (skill) out.push(skill);
+    }
+    for (const entry of entries) {
+      if (entry === "node_modules" || entry === ".git") continue;
+      const full = join5(dir, entry);
+      try {
+        if (!statSync3(full).isDirectory()) continue;
+      } catch {
+        continue;
+      }
+      if (entry === "skills") {
+        scanSkillsDir(full, "cli", out);
+        walk(full, depth + 1, true);
+      } else {
+        walk(full, depth + 1, lookingForSkillsDir);
+      }
+    }
+  };
+  walk(pluginsRoot, 0, false);
+}
+function discoverSkills(worktreePath) {
+  const home = homedir();
+  const collected = [];
+  for (const rel of [".claude/skills", ".cursor/skills", ".sideboard/skills", ".brightsy/skills", "skills"]) {
+    scanSkillsDir(join5(worktreePath, rel), "workspace", collected);
+  }
+  for (const abs of [
+    join5(home, ".claude/skills"),
+    join5(home, ".cursor/skills"),
+    join5(home, ".sideboard/skills"),
+    join5(home, ".brightsy/skills")
+  ]) {
+    scanSkillsDir(abs, "user", collected);
+  }
+  scanClaudePluginSkills(join5(home, ".claude/plugins"), collected);
+  const rank = { workspace: 0, user: 1, cli: 2 };
+  const byCommand = /* @__PURE__ */ new Map();
+  for (const skill of collected) {
+    const prev = byCommand.get(skill.command);
+    if (!prev || rank[skill.source] < rank[prev.source]) {
+      byCommand.set(skill.command, skill);
+    }
+  }
+  return [...byCommand.values()].sort((a, b) => a.command.localeCompare(b.command));
+}
+function readSkillBody(skillPath, maxChars = 12e3) {
+  const raw = readFileSync5(skillPath, "utf8");
+  if (raw.startsWith("---")) {
+    const end = raw.indexOf("\n---", 3);
+    if (end >= 0) {
+      const body = raw.slice(end + 4).trim();
+      return body.length > maxChars ? `${body.slice(0, maxChars)}
+
+\u2026(truncated)` : body;
+    }
+  }
+  return raw.length > maxChars ? `${raw.slice(0, maxChars)}
+
+\u2026(truncated)` : raw;
+}
+
+// src/composer/expand.ts
+var FILE_MENTION_RE = /(?:^|[\s])@([A-Za-z0-9_./\-]+(?:\.[A-Za-z0-9]+)?)/g;
+var SLASH_CMD_RE = /(?:^|\s)\/([a-z0-9][a-z0-9-]*)\b/g;
+function expandComposerPrompt(worktreePath, prompt, opts) {
+  const skills = opts?.skills ?? discoverSkills(worktreePath);
+  const byCommand = new Map(skills.map((s) => [s.command, s]));
+  const maxFileBytes = opts?.maxFileBytes ?? 8e4;
+  const attachments = opts?.attachments ?? [];
+  const mentionedFiles = /* @__PURE__ */ new Set();
+  for (const m of prompt.matchAll(FILE_MENTION_RE)) {
+    const p = m[1];
+    if (p) mentionedFiles.add(p);
+  }
+  const skillsUsed = [];
+  const seenSkill = /* @__PURE__ */ new Set();
+  for (const m of prompt.matchAll(SLASH_CMD_RE)) {
+    const cmd = m[1];
+    if (!cmd || seenSkill.has(cmd)) continue;
+    const skill = byCommand.get(cmd);
+    if (skill) {
+      skillsUsed.push(skill);
+      seenSkill.add(cmd);
+    }
+  }
+  if (mentionedFiles.size === 0 && skillsUsed.length === 0 && attachments.length === 0) {
+    return { agentPrompt: prompt, mentionedFiles: [], skillsUsed: [] };
+  }
+  const parts = [prompt.trim(), "", "---", "Sideboard context (auto-attached):"];
+  for (const att of attachments) {
+    parts.push("");
+    parts.push(`## Attachment: ${att.name}`);
+    parts.push(`Kind: ${att.kind}`);
+    parts.push("");
+    parts.push(att.content);
+  }
+  for (const skill of skillsUsed) {
+    let body = "";
+    try {
+      body = readSkillBody(skill.path);
+    } catch {
+      body = `(could not read skill at ${skill.path})`;
+    }
+    parts.push("");
+    parts.push(`## Skill: /${skill.command} (${skill.name})`);
+    parts.push(`Source: ${skill.source} \xB7 ${skill.path}`);
+    parts.push("Follow this skill for the request above:");
+    parts.push("");
+    parts.push(body);
+  }
+  for (const rel of mentionedFiles) {
+    parts.push("");
+    parts.push(`## Referenced file: @${rel}`);
+    try {
+      const file = readWorktreeFile(worktreePath, rel, { maxBytes: maxFileBytes });
+      if (file.binary) {
+        parts.push(`(binary file \u2014 use the Read tool on \`${rel}\`)`);
+      } else {
+        parts.push(`Path in worktree: \`${rel}\``);
+        parts.push("```");
+        parts.push(file.content);
+        parts.push("```");
+        if (file.truncated) parts.push("(truncated)");
+      }
+    } catch {
+      parts.push(`(file not found or unreadable \u2014 use the Read/Glob tools for \`${rel}\`)`);
+    }
+  }
+  return {
+    agentPrompt: parts.join("\n"),
+    mentionedFiles: [...mentionedFiles],
+    skillsUsed
+  };
+}
+
+// src/composer/summarize.ts
+var MAX_TRANSCRIPT_CHARS = 12e4;
+var MAX_SUMMARY_CHARS = 6e3;
+async function summarizeConversation(transcript, opts) {
+  const clipped = transcript.length > MAX_TRANSCRIPT_CHARS ? `${transcript.slice(0, MAX_TRANSCRIPT_CHARS)}
+
+[\u2026truncated\u2026]` : transcript;
+  const claudeSummary = await tryClaudeSummary(clipped, opts);
+  if (claudeSummary) {
+    return { summary: clipSummary(claudeSummary), method: "claude" };
+  }
+  return { summary: clipSummary(extractiveSummary(clipped)), method: "extractive" };
+}
+async function tryClaudeSummary(transcript, opts) {
+  ensureAgentPath();
+  const prompt = [
+    "Summarize this coding-agent conversation for continuity in a fresh session.",
+    "Use concise markdown bullets covering:",
+    "- Goal / request",
+    "- Key decisions and constraints",
+    "- Files / areas touched",
+    "- Current state and open tasks",
+    "- Anything the next turn must remember",
+    "Do not invent details. No preamble.",
+    "",
+    "Transcript:",
+    transcript
+  ].join("\n");
+  try {
+    const { stdout, exitCode } = await run(
+      "claude",
+      [
+        "-p",
+        prompt,
+        "--output-format",
+        "text",
+        "--permission-mode",
+        "bypassPermissions",
+        "--model",
+        "haiku"
+      ],
+      { cwd: opts?.cwd, reject: false }
+    );
+    if (exitCode !== 0) return null;
+    const text = stdout.trim();
+    if (text.length < 40) return null;
+    return text;
+  } catch {
+    return null;
+  }
+}
+function extractiveSummary(transcript) {
+  const lines = transcript.split("\n").map((l) => l.trim()).filter(Boolean);
+  const users = [];
+  const tools = [];
+  const agents = [];
+  let mode = "none";
+  for (const line of lines) {
+    if (line.startsWith("### User")) {
+      mode = "user";
+      continue;
+    }
+    if (line.startsWith("### Agent") || line.startsWith("## Prior")) {
+      mode = "agent";
+      continue;
+    }
+    if (line.startsWith("- ") && line.includes(":")) {
+      tools.push(line.replace(/^- /, ""));
+      continue;
+    }
+    if (mode === "user" && users.length < 8) {
+      users.push(line.slice(0, 240));
+    } else if (mode === "agent" && agents.length < 6) {
+      agents.push(line.slice(0, 240));
+    }
+  }
+  const uniqueTools = [...new Set(tools)].slice(0, 20);
+  const parts = [
+    "## Compacted context (extractive)",
+    "",
+    "### User goals",
+    ...users.length ? users.map((u) => `- ${u}`) : ["- (none captured)"],
+    "",
+    "### Recent agent notes",
+    ...agents.length ? agents.map((a) => `- ${a}`) : ["- (none captured)"]
+  ];
+  if (uniqueTools.length) {
+    parts.push("", "### Tools / files", ...uniqueTools.map((t) => `- ${t}`));
+  }
+  parts.push(
+    "",
+    "_Automatic extractive summary \u2014 Claude summarizer was unavailable._"
+  );
+  return parts.join("\n");
+}
+function clipSummary(text) {
+  if (text.length <= MAX_SUMMARY_CHARS) return text;
+  return `${text.slice(0, MAX_SUMMARY_CHARS)}
+
+[\u2026summary truncated\u2026]`;
+}
+
+// src/composer/context-compact.ts
+var CONTEXT_COMPACT_CHARS = 1e5;
+var CONTEXT_KEEP_RECENT_CHARS = 24e3;
+var CONTEXT_KEEP_RECENT_MESSAGES = 12;
+var CONTEXT_MIN_MESSAGES = 10;
+function estimateMessageChars(message) {
+  let n = message.text.length + 16;
+  for (const part of message.parts ?? []) {
+    n += estimatePartChars(part);
+  }
+  return n;
+}
+function estimatePartChars(part) {
+  switch (part.type) {
+    case "text":
+    case "thinking":
+      return part.text.length;
+    case "tool": {
+      const input = part.input ? JSON.stringify(part.input) : "";
+      return part.name.length + (part.description?.length ?? 0) + (part.detail?.length ?? 0) + (part.result?.length ?? 0) + input.length + 32;
+    }
+    default:
+      return 0;
+  }
+}
+function estimateThreadChars(messages) {
+  return messages.reduce((sum, m) => sum + estimateMessageChars(m), 0);
+}
+function shouldCompactContext(messages, thresholds = {}) {
+  const maxChars = thresholds.maxChars ?? CONTEXT_COMPACT_CHARS;
+  const minMessages = thresholds.minMessages ?? CONTEXT_MIN_MESSAGES;
+  if (messages.length < minMessages) return false;
+  return estimateThreadChars(messages) >= maxChars;
+}
+function splitForCompaction(messages, thresholds = {}) {
+  const keepChars = thresholds.keepRecentChars ?? CONTEXT_KEEP_RECENT_CHARS;
+  const keepCount = thresholds.keepRecentMessages ?? CONTEXT_KEEP_RECENT_MESSAGES;
+  if (messages.length === 0) return { older: [], recent: [] };
+  let recentChars = 0;
+  let cut = messages.length;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const next = recentChars + estimateMessageChars(messages[i]);
+    const kept = messages.length - i;
+    if (kept >= keepCount && next > keepChars) break;
+    recentChars = next;
+    cut = i;
+  }
+  const minRecent = Math.min(keepCount, messages.length);
+  cut = Math.min(cut, messages.length - minRecent);
+  if (cut <= 0) return { older: [], recent: messages };
+  return {
+    older: messages.slice(0, cut),
+    recent: messages.slice(cut)
+  };
+}
+function formatToolPart(t, detail) {
+  if (detail === "summary") {
+    const label = t.description || t.detail || t.name;
+    const path = t.filePath ? ` (${t.filePath})` : "";
+    return `- ${t.name}: ${label}${path}`;
+  }
+  const lines = [`#### Tool: ${t.name}`, `Status: ${t.status}`];
+  if (t.description) lines.push(`Description: ${t.description}`);
+  if (t.filePath) lines.push(`Path: ${t.filePath}`);
+  if (t.input && Object.keys(t.input).length > 0) {
+    lines.push("Input:");
+    lines.push("```json");
+    lines.push(JSON.stringify(t.input, null, 2));
+    lines.push("```");
+  } else if (t.detail) {
+    lines.push(`Detail: ${t.detail}`);
+  }
+  if (t.result != null && t.result !== "") {
+    lines.push("Result:");
+    lines.push("```");
+    lines.push(t.result);
+    lines.push("```");
+  }
+  return lines.join("\n");
+}
+function formatMessagesAsTranscript(messages, opts) {
+  const tools = opts?.tools ?? "full";
+  const blocks = [];
+  for (const m of messages) {
+    if (m.role === "summary") {
+      blocks.push(`## Prior summary
+${m.text}`);
+      continue;
+    }
+    if (m.role === "user") {
+      blocks.push(`### User
+${m.text}`);
+      continue;
+    }
+    const bits = [];
+    if (m.text?.trim()) {
+      bits.push(`### Agent
+${m.text}`);
+    } else {
+      bits.push("### Agent");
+    }
+    const thinking = (m.parts ?? []).filter((p) => p.type === "thinking");
+    for (const th of thinking) {
+      if (th.type !== "thinking" || !th.text.trim()) continue;
+      bits.push("Thinking:");
+      bits.push(th.text);
+    }
+    const toolParts = (m.parts ?? []).filter(
+      (p) => p.type === "tool"
+    );
+    if (tools !== "none" && toolParts.length > 0) {
+      if (tools === "summary") bits.push("Tools:");
+      for (const t of toolParts) {
+        bits.push(formatToolPart(t, tools));
+      }
+    }
+    blocks.push(bits.join("\n"));
+  }
+  return blocks.join("\n\n");
+}
+function buildSessionSeed(messages, opts) {
+  if (messages.length === 0) return null;
+  const body = formatMessagesAsTranscript(messages, { tools: opts?.tools ?? "full" });
+  if (!body.trim()) return null;
+  return [
+    "Sideboard conversation context (restored after compaction or a new session):",
+    "",
+    body,
+    "",
+    "Continue from this context. Do not repeat the summary unless asked."
+  ].join("\n");
+}
+function applyCompaction(messages, summaryText, thresholds = {}) {
+  const { older, recent } = splitForCompaction(messages, thresholds);
+  if (older.length === 0) return messages;
+  const summary = {
+    role: "summary",
+    text: summaryText.trim(),
+    ts: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return [summary, ...recent];
+}
+async function maybeCompactContext(thread, thresholds = {}, summarize = summarizeConversation) {
+  if (!shouldCompactContext(thread.messages, thresholds)) {
+    return { didCompact: false, thread };
+  }
+  const { older } = splitForCompaction(thread.messages, thresholds);
+  if (older.length === 0) {
+    return { didCompact: false, thread };
+  }
+  const transcript = formatMessagesAsTranscript(older, { tools: "summary" });
+  const { summary, method } = await summarize(transcript, {
+    cwd: thread.worktreePath
+  });
+  const messages = applyCompaction(thread.messages, summary, thresholds);
+  const next = {
+    ...thread,
+    messages,
+    sessionId: null,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return {
+    didCompact: true,
+    thread: next,
+    summary,
+    method,
+    olderCount: older.length
+  };
+}
+
+// src/land/pr-metadata.ts
+var GENERIC_TITLE_RE = /^(sideboard:|thread\/|wip\b|tmp\b|update\b|changes?\b|misc\b|stuff\b)/i;
+function looksGeneric(title) {
+  const t = title.trim();
+  if (!t) return true;
+  if (t.length < 4) return true;
+  if (GENERIC_TITLE_RE.test(t)) return true;
+  if (!/[\s:/\-_]/.test(t) && t.length <= 24) return true;
+  return false;
+}
+function truncateTitle(title, max = 72) {
+  const t = title.trim().replace(/\s+/g, " ");
+  if (t.length <= max) return t;
+  return `${t.slice(0, max - 1).trimEnd()}\u2026`;
+}
+function titleFromPaths(paths) {
+  if (paths.length === 0) return null;
+  const top = paths.slice(0, 3).map((p) => p.replace(/\/$/, ""));
+  if (paths.length === 1) return truncateTitle(`Update ${top[0]}`);
+  if (paths.length <= 3) return truncateTitle(`Update ${top.join(", ")}`);
+  return truncateTitle(`Update ${top[0]} and ${paths.length - 1} more files`);
+}
+async function suggestPrMetadata(worktreePath, opts) {
+  const [{ stdout: logOut }, { stdout: nameStatus }, { stdout: statOut }] = await Promise.all([
+    git(["log", "--format=%s", `${opts.base}..HEAD`], worktreePath, {
+      reject: false
+    }),
+    git(["diff", "--name-only", `${opts.base}...HEAD`], worktreePath, {
+      reject: false
+    }),
+    git(["diff", "--stat", `${opts.base}...HEAD`], worktreePath, {
+      reject: false
+    })
+  ]);
+  const { stdout: dirtyNames } = await git(["diff", "--name-only", "HEAD"], worktreePath, {
+    reject: false
+  });
+  const { stdout: untracked } = await git(
+    ["ls-files", "--others", "--exclude-standard"],
+    worktreePath,
+    { reject: false }
+  );
+  const subjects = logOut.split("\n").map((s) => s.trim()).filter(Boolean);
+  const paths = [
+    ...new Set(
+      [...nameStatus.split("\n"), ...dirtyNames.split("\n"), ...untracked.split("\n")].map((p) => p.trim()).filter(Boolean)
+    )
+  ].sort((a, b) => a.localeCompare(b));
+  const meaningfulSubjects = subjects.filter((s) => !looksGeneric(s));
+  const fallback = opts.fallbackTitle?.trim() || null;
+  const fallbackOk = fallback && !looksGeneric(fallback) ? fallback : null;
+  const title = truncateTitle(
+    meaningfulSubjects[0] ?? fallbackOk ?? titleFromPaths(paths) ?? "Sideboard changes"
+  );
+  const commitMessage = meaningfulSubjects[0] ?? fallbackOk ?? titleFromPaths(paths) ?? `sideboard: ${title}`;
+  const summaryLines = meaningfulSubjects.length > 0 ? meaningfulSubjects.slice(0, 12).map((s) => `- ${s}`) : paths.slice(0, 20).map((p) => `- \`${p}\``);
+  const bodyParts = [
+    "## Summary",
+    summaryLines.length > 0 ? summaryLines.join("\n") : "- Changes landed via Sideboard.",
+    ""
+  ];
+  if (statOut.trim()) {
+    bodyParts.push("## Diff", "```", statOut.trim(), "```", "");
+  }
+  if (opts.sourceLabel) {
+    bodyParts.push(`_Landed via Sideboard from ${opts.sourceLabel}_`);
+  }
+  return {
+    title,
+    body: bodyParts.join("\n").trim() + "\n",
+    commitMessage: truncateTitle(commitMessage, 72)
+  };
+}
+
+// src/land/land.ts
+async function previewLand(thread) {
+  if (thread.sourceIsFork) {
+    return {
+      branch: thread.branchName,
+      target: "(unknown)",
+      diffStat: "",
+      dirty: await isDirty(thread.worktreePath),
+      blocked: true,
+      blockReason: "Cross-repository (fork) PR sources cannot be landed in v1",
+      isFork: true
+    };
+  }
+  const target = await resolveDefaultBranch(thread.repoPath);
+  if (thread.branchName === target || thread.branchName === "main" || thread.branchName === "master") {
+  }
+  const { stdout: head } = await import("./run-LF6E5IKL.js").then(
+    ({ git: git2 }) => git2(["rev-parse", "--abbrev-ref", "HEAD"], thread.worktreePath)
+  );
+  const current = head.trim();
+  if (current === target) {
+    return {
+      branch: current,
+      target,
+      diffStat: "",
+      dirty: await isDirty(thread.worktreePath),
+      blocked: true,
+      blockReason: `Hard-blocked: branch resolves to default branch "${target}"`,
+      isFork: false
+    };
+  }
+  const diff = await getDiff(thread.worktreePath, thread.repoPath, { base: target });
+  return {
+    branch: thread.branchName,
+    target,
+    diffStat: diff.stat,
+    dirty: diff.dirty,
+    blocked: false,
+    isFork: false
+  };
+}
+async function confirmLand(thread, opts) {
+  const preview = await previewLand(thread);
+  if (preview.blocked) {
+    throw new Error(preview.blockReason ?? "Land blocked");
+  }
+  const meta = await suggestPrMetadata(thread.worktreePath, {
+    base: preview.target,
+    fallbackTitle: thread.title,
+    sourceLabel: `${thread.sourceType}:${thread.sourceRef}`
+  });
+  let committed = false;
+  if (preview.dirty) {
+    committed = await commitAll(thread.worktreePath, meta.commitMessage);
+  }
+  const { git: git2 } = await import("./run-LF6E5IKL.js");
+  const { stdout: headOut } = await git2(
+    ["rev-parse", "--abbrev-ref", "HEAD"],
+    thread.worktreePath,
+    { reject: false }
+  );
+  const head = headOut.trim();
+  const branch = head && head !== "HEAD" ? head : thread.branchName;
+  await pushBranch(thread.worktreePath, branch);
+  const prUrl = await createOrUpdatePr(thread.worktreePath, {
+    title: meta.title,
+    body: meta.body,
+    base: preview.target,
+    head: branch,
+    draft: opts?.draft,
+    web: opts?.web
+  });
+  return { prUrl, pushed: true, committed };
+}
+
+// src/threads/create.ts
+import { existsSync as existsSync6 } from "fs";
+async function createThread(input, onSetupLine) {
+  await requireAgent(input.agent);
+  const repoPath = await resolveRepoRoot(input.repoPath);
+  if (!existsSync6(repoPath)) {
+    throw new Error(`Repo not found: ${repoPath}`);
+  }
+  let sourceRef = input.sourceRef;
+  let sourceIsFork = false;
+  let prUrl = null;
+  if (input.sourceType === "pr") {
+    const num = Number(input.sourceRef.replace(/^#/, ""));
+    if (!Number.isFinite(num)) throw new Error(`Invalid PR number: ${input.sourceRef}`);
+    const pr = await getPr(repoPath, num);
+    if (!pr) throw new Error(`PR #${num} not found`);
+    sourceIsFork = pr.isCrossRepository;
+    prUrl = pr.url;
+    const localFetchBranch = `sideboard-pr-${pr.number}`;
+    await fetchPrHead(repoPath, pr.number, localFetchBranch);
+    sourceRef = localFetchBranch;
+  } else if (input.sourceType === "ticket") {
+    sourceRef = await resolveDefaultBranch(repoPath);
+  } else if (input.sourceType === "branch") {
+    if (!sourceRef || sourceRef === "HEAD" || sourceRef === "default") {
+      sourceRef = await resolveDefaultBranch(repoPath);
+    }
+  } else if (input.sourceType === "adopt") {
+    throw new Error("Use adoptThread() for adopt sources");
+  }
+  const team = allocateTeamSlug(repoPath);
+  const { branchName, worktreePath } = await createThreadWorktree({
+    repoPath,
+    sourceRef,
+    slug: team.slug
+  });
+  copyConfiguredFiles(repoPath, worktreePath);
+  const explicitTitle = input.title?.trim();
+  const thread = createEmptyThread({
+    title: explicitTitle || team.name,
+    userSetTitle: Boolean(explicitTitle),
+    sourceType: input.sourceType,
+    sourceRef: input.sourceRef === "default" ? sourceRef : input.sourceRef,
+    branchName,
+    worktreePath,
+    repoPath,
+    agent: input.agent,
+    autonomy: input.autonomy ?? "default",
+    model: input.model ?? null,
+    fast: Boolean(input.fast),
+    planMode: Boolean(input.planMode),
+    attachments: input.attachments ?? [],
+    sourceIsFork,
+    parentThreadId: input.parentThreadId ?? null,
+    status: "idle",
+    prUrl
+  });
+  writeThread(thread);
+  await ensureWorkspace(repoPath);
+  try {
+    let setup = await runSetupScript(repoPath, worktreePath, onSetupLine);
+    if (!setup.ran) {
+      setup = await runCursorWorktreeSetup(repoPath, worktreePath, onSetupLine);
+    }
+    if (setup.ran && setup.exitCode !== 0 && setup.exitCode !== null) {
+      updateThread(thread.id, {
+        lastError: `Setup exited ${setup.exitCode} (thread is still usable)`
+      });
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    updateThread(thread.id, {
+      lastError: `Setup failed: ${message}`
+    });
+  }
+  return readThread(thread.id) ?? thread;
+}
+async function listLinearIssues(agent, repoPath) {
+  const { getAdapter: getAdapter2 } = await import("./agents-OAX7XPKX.js");
+  await requireAgent(agent, { requireLinear: true });
+  const adapter = getAdapter2(agent);
+  if (!adapter.listLinearIssues) {
+    throw new Error(`${agent} does not support Linear issue listing`);
+  }
+  return adapter.listLinearIssues(repoPath);
+}
+
+// src/threads/chat-tabs.ts
+import { randomUUID } from "crypto";
+function sameWorktreePath(a, b) {
+  return normalizeWorktreePath(a) === normalizeWorktreePath(b);
+}
+function takenTeamSlugsForChatTab(worktreePath) {
+  const key = normalizeWorktreePath(worktreePath);
+  const taken = /* @__PURE__ */ new Set();
+  const dir = worktreeNameFromPath(key);
+  if (dir) taken.add(dir.toLowerCase());
+  for (const sibling of threadsSharingWorktree(key)) {
+    for (const slug of takenSlugsFromThread(sibling)) {
+      taken.add(slug);
+    }
+  }
+  return [...taken];
+}
+function requireThread(idOrRef) {
+  const thread = findThreadByRef(idOrRef) ?? null;
+  if (!thread) throw new Error(`Thread not found: ${idOrRef}`);
+  return thread;
+}
+function worktreeBindingFrom(from) {
+  return {
+    worktreePath: normalizeWorktreePath(from.worktreePath),
+    repoPath: from.repoPath,
+    branchName: from.branchName,
+    sourceRef: from.sourceRef,
+    // Legacy pinned-repo orchestration: new tabs become normal worktree agents.
+    // Global: keep orchestration so chat tabs stay fleet orchestrators (MCP + Bash).
+    sourceType: isGlobalThread(from) ? "orchestration" : from.sourceType === "orchestration" ? "branch" : from.sourceType,
+    sourceIsFork: from.sourceIsFork,
+    parentThreadId: from.parentThreadId,
+    prUrl: from.prUrl,
+    prTitle: from.prTitle
+  };
+}
+function threadsSharingWorktree(worktreePath) {
+  const key = normalizeWorktreePath(worktreePath);
+  return listThreads({ includeArchived: true }).filter((t) => sameWorktreePath(t.worktreePath, key) && t.status !== "archived").sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+function formatTranscriptMarkdown(title, messages) {
+  const body = formatMessagesAsTranscript(messages, { tools: "full" });
+  return [`# Transcript: ${title}`, "", `Forked ${(/* @__PURE__ */ new Date()).toISOString()}`, "", body].join("\n");
+}
+function forkMessageSlice(from, throughIndex) {
+  const through = throughIndex === void 0 ? from.messages.length - 1 : Math.min(throughIndex, from.messages.length - 1);
+  return through >= 0 ? from.messages.slice(0, through + 1) : [];
+}
+function buildForkTranscriptAttachment(baseTitle, messages) {
+  const title = baseTitle || "Chat";
+  return {
+    id: randomUUID(),
+    name: `Transcript of ${title}.md`,
+    kind: "transcript",
+    content: formatTranscriptMarkdown(title, messages)
+  };
+}
+function createChatTab(input) {
+  const from = requireThread(input.fromThreadId);
+  const binding = worktreeBindingFrom(from);
+  const explicitTitle = input.title?.trim();
+  const title = explicitTitle || allocateTeamName(takenTeamSlugsForChatTab(binding.worktreePath)).name;
+  const thread = createEmptyThread({
+    title,
+    // Chat-tab nicknames (soccer team or explicit) must stick. Post-turn
+    // syncThreadBranchFromGit would otherwise rewrite every sibling to the
+    // shared worktree folder name (e.g. fork "Arsenal" → "Monaco").
+    userSetTitle: true,
+    ...binding,
+    agent: input.agent ?? from.agent,
+    model: input.agent && input.agent !== from.agent ? null : from.model,
+    fast: from.fast,
+    planMode: from.planMode,
+    autonomy: from.autonomy,
+    attachments: input.attachments ?? [],
+    status: "idle"
+  });
+  writeThread(thread);
+  return thread;
+}
+function forkChatTab(input) {
+  const from = requireThread(input.threadId);
+  const slice = forkMessageSlice(from, input.throughIndex);
+  const attachment = buildForkTranscriptAttachment(from.title || "Chat", slice);
+  return createChatTab({
+    fromThreadId: input.threadId,
+    agent: input.agent ?? from.agent,
+    title: input.title?.trim() || void 0,
+    attachments: [attachment]
+  });
+}
+
+// src/threads/fork-worktree.ts
+function requireThread2(idOrRef) {
+  const thread = findThreadByRef(idOrRef) ?? null;
+  if (!thread) throw new Error(`Thread not found: ${idOrRef}`);
+  return thread;
+}
+async function forkThreadWorktree(input, onSetupLine) {
+  const from = requireThread2(input.threadId);
+  const slice = forkMessageSlice(from, input.throughIndex);
+  const attachment = buildForkTranscriptAttachment(from.title || "Chat", slice);
+  const thread = await createThread(
+    {
+      sourceType: "branch",
+      sourceRef: from.branchName,
+      repoPath: from.repoPath,
+      agent: input.agent ?? from.agent,
+      autonomy: from.autonomy,
+      title: input.title?.trim() || void 0,
+      parentThreadId: from.id
+    },
+    onSetupLine
+  );
+  return updateThread(thread.id, { attachments: [attachment] });
+}
+
+// src/threads/adopt.ts
+import { execFileSync } from "child_process";
+import {
+  copyFileSync as copyFileSync2,
+  existsSync as existsSync7,
+  mkdtempSync,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync6,
+  rmSync
+} from "fs";
+import { tmpdir } from "os";
+import { join as join6 } from "path";
+import Database from "better-sqlite3";
+var CONDUCTOR_APP_SUPPORT = join6(
+  process.env.HOME ?? "",
+  "Library",
+  "Application Support",
+  "com.conductor.app"
+);
+var CONDUCTOR_DB = join6(CONDUCTOR_APP_SUPPORT, "conductor.db");
+var CURSOR_SDK_STORE = join6(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
+function mapAgentType(raw) {
+  if (!raw) return null;
+  const v = raw.toLowerCase();
+  if (v.includes("cursor")) return "cursor";
+  if (v.includes("claude")) return "claude";
+  if (v.includes("codex")) return "codex";
+  if (v.includes("opencode") || v.includes("open-code")) return "opencode";
+  if (v.includes("brightsy")) return "brightsy";
+  return null;
+}
+function resolveConductorCursorAgentId(workspacePath) {
+  if (!workspacePath || !existsSync7(CURSOR_SDK_STORE)) return null;
+  const normalized = workspacePath.replace(/\/$/, "");
+  let best = null;
+  let hashes;
+  try {
+    hashes = readdirSync3(CURSOR_SDK_STORE);
+  } catch {
+    return null;
+  }
+  for (const hash of hashes) {
+    const agentsFile = join6(CURSOR_SDK_STORE, hash, "agents.ndjson");
+    if (!existsSync7(agentsFile)) continue;
+    let text;
+    try {
+      text = readFileSync6(agentsFile, "utf8");
+    } catch {
+      continue;
+    }
+    for (const line of text.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const row = JSON.parse(trimmed);
+        if (!row.agentId || !row.cwd) continue;
+        if (row.agentId.startsWith("conductor-one-shot-")) continue;
+        const cwd = String(row.cwd).replace(/\/$/, "");
+        if (cwd !== normalized) continue;
+        const updatedAt = Number(row.updatedAt ?? 0);
+        if (!best || updatedAt >= best.updatedAt) {
+          best = { agentId: row.agentId, updatedAt };
+        }
+      } catch {
+      }
+    }
+  }
+  return best?.agentId ?? null;
+}
+async function adoptThread(input) {
+  if (!existsSync7(input.worktreePath)) {
+    throw new Error(`Worktree not found: ${input.worktreePath}`);
+  }
+  const repoPath = await resolveRepoRoot(input.worktreePath);
+  const { stdout: branch } = await import("./run-LF6E5IKL.js").then(
+    ({ git: git2 }) => git2(["rev-parse", "--abbrev-ref", "HEAD"], input.worktreePath)
+  );
+  const thread = createEmptyThread({
+    title: input.title ?? `Adopted ${branch.trim()}`,
+    sourceType: "adopt",
+    sourceRef: input.sourceRef ?? input.worktreePath,
+    branchName: branch.trim(),
+    worktreePath: input.worktreePath,
+    repoPath,
+    agent: input.agent,
+    sessionId: input.sessionId ?? null,
+    messages: input.messages ?? []
+  });
+  writeThread(thread);
+  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-TCJFYI35.js");
+  await ensureWorkspace2(repoPath);
+  return thread;
+}
+function conductorDbPath() {
+  return CONDUCTOR_DB;
+}
+function listConductorWorkspaces() {
+  if (!existsSync7(CONDUCTOR_DB)) {
+    throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
+  }
+  const tmp = mkdtempSync(join6(tmpdir(), "sideboard-conductor-"));
+  const snapshot = join6(tmp, "conductor.db");
+  try {
+    copyFileSync2(CONDUCTOR_DB, snapshot);
+    for (const suffix of ["-wal", "-shm"]) {
+      const src = `${CONDUCTOR_DB}${suffix}`;
+      if (existsSync7(src)) {
+        try {
+          copyFileSync2(src, `${snapshot}${suffix}`);
+        } catch {
+        }
+      }
+    }
+    const db = new Database(snapshot, { readonly: true, fileMustExist: true });
+    try {
+      const tables = db.prepare(`SELECT name FROM sqlite_master WHERE type='table'`).all();
+      const names = new Set(tables.map((t) => t.name));
+      if (!names.has("workspaces")) {
+        throw new Error("Conductor schema missing workspaces table");
+      }
+      const rows = db.prepare(
+        `SELECT
+            w.id as id,
+            w.workspace_path as workspacePath,
+            w.branch as branch,
+            COALESCE(w.workspace_name, w.directory_name, w.branch) as workspaceName,
+            w.pr_title as prTitle,
+            w.pr_description as prDescription,
+            w.intended_target_branch as intendedTargetBranch,
+            w.notes as notes,
+            w.active_session_id as activeSessionId
+          FROM workspaces w
+          WHERE w.state IS NULL OR w.state != 'archived'
+          ORDER BY w.updated_at DESC`
+      ).all();
+      return rows.map((row) => {
+        let claudeSessionId = null;
+        let agentType = null;
+        let messageCount = 0;
+        const activeSessionId = row.activeSessionId;
+        if (names.has("sessions") && activeSessionId) {
+          try {
+            const session = db.prepare(
+              `SELECT claude_session_id as claudeSessionId, agent_type as agentType
+                 FROM sessions WHERE id = ?`
+            ).get(activeSessionId);
+            claudeSessionId = session?.claudeSessionId ?? null;
+            agentType = mapAgentType(session?.agentType) ?? "claude";
+          } catch {
+            agentType = "claude";
+          }
+        }
+        if (names.has("session_messages") && activeSessionId) {
+          try {
+            const count = db.prepare(
+              `SELECT COUNT(*) as c FROM session_messages WHERE session_id = ?`
+            ).get(activeSessionId);
+            messageCount = count.c;
+          } catch {
+            messageCount = 0;
+          }
+        }
+        const workspacePath = String(row.workspacePath ?? "");
+        if (agentType === "cursor" && !claudeSessionId) {
+          claudeSessionId = resolveConductorCursorAgentId(workspacePath);
+        }
+        return {
+          id: String(row.id),
+          workspacePath,
+          branch: String(row.branch ?? ""),
+          workspaceName: String(row.workspaceName ?? row.branch ?? "workspace"),
+          prTitle: row.prTitle ?? null,
+          prDescription: row.prDescription ?? null,
+          intendedTargetBranch: row.intendedTargetBranch ?? null,
+          notes: row.notes ?? null,
+          claudeSessionId,
+          agentType,
+          messageCount
+        };
+      });
+    } finally {
+      db.close();
+    }
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}
+function importConductorWorkspace(workspaceId) {
+  if (!existsSync7(CONDUCTOR_DB)) {
+    throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
+  }
+  const tmp = mkdtempSync(join6(tmpdir(), "sideboard-conductor-"));
+  const snapshot = join6(tmp, "conductor.db");
+  try {
+    copyFileSync2(CONDUCTOR_DB, snapshot);
+    for (const suffix of ["-wal", "-shm"]) {
+      const src = `${CONDUCTOR_DB}${suffix}`;
+      if (existsSync7(src)) {
+        try {
+          copyFileSync2(src, `${snapshot}${suffix}`);
+        } catch {
+        }
+      }
+    }
+    const db = new Database(snapshot, { readonly: true, fileMustExist: true });
+    try {
+      const row = db.prepare(
+        `SELECT
+            w.id as id,
+            w.workspace_path as workspacePath,
+            w.branch as branch,
+            COALESCE(w.workspace_name, w.directory_name, w.branch) as workspaceName,
+            w.active_session_id as activeSessionId
+          FROM workspaces w WHERE w.id = ?`
+      ).get(workspaceId);
+      if (!row) throw new Error(`Conductor workspace not found: ${workspaceId}`);
+      const worktreePath = String(row.workspacePath);
+      if (!existsSync7(worktreePath)) {
+        throw new Error(`Conductor worktree missing on disk: ${worktreePath}`);
+      }
+      let sessionId = null;
+      let agent = "claude";
+      const messages = [];
+      const activeSessionId = row.activeSessionId;
+      if (activeSessionId) {
+        try {
+          const session = db.prepare(
+            `SELECT claude_session_id as claudeSessionId, agent_type as agentType
+               FROM sessions WHERE id = ?`
+          ).get(activeSessionId);
+          sessionId = session?.claudeSessionId ?? null;
+          agent = mapAgentType(session?.agentType) ?? "claude";
+        } catch {
+        }
+        try {
+          const rows = db.prepare(
+            `SELECT role, content, COALESCE(sent_at, created_at) as ts
+               FROM session_messages
+               WHERE session_id = ?
+               ORDER BY COALESCE(sent_at, created_at) ASC`
+          ).all(activeSessionId);
+          for (const m of rows) {
+            const role = m.role === "assistant" || m.role === "agent" ? "agent" : "user";
+            messages.push({
+              role,
+              text: m.content ?? "",
+              ts: m.ts ?? (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        } catch {
+        }
+      }
+      if (agent === "cursor" && !sessionId) {
+        sessionId = resolveConductorCursorAgentId(worktreePath);
+      }
+      let repoPath = worktreePath;
+      try {
+        repoPath = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+          cwd: worktreePath,
+          encoding: "utf8"
+        }).trim();
+      } catch {
+      }
+      const thread = createEmptyThread({
+        title: String(row.workspaceName ?? row.branch),
+        sourceType: "adopt",
+        sourceRef: `conductor:${workspaceId}`,
+        branchName: String(row.branch ?? ""),
+        worktreePath,
+        repoPath,
+        agent,
+        sessionId,
+        messages
+      });
+      writeThread(thread);
+      return thread;
+    } finally {
+      db.close();
+    }
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}
+async function importConductorWorkspaceAsync(workspaceId) {
+  return importConductorWorkspace(workspaceId);
+}
+
+// src/git/orphan-cleanup.ts
+import { existsSync as existsSync8, readdirSync as readdirSync4, statSync as statSync4 } from "fs";
+import { join as join7 } from "path";
+function isSideboardWorktreePath(path) {
+  return path.includes("/.sideboard/worktrees/") || path.includes("/sideboard/workspaces/");
+}
+async function findOrphanWorktrees(repoPaths) {
+  const threads = listThreads({ includeArchived: true });
+  const known = new Set(threads.map((t) => t.worktreePath.replace(/\/$/, "")));
+  const repos = new Set(
+    repoPaths?.length ? repoPaths : threads.map((t) => t.repoPath).filter(Boolean)
+  );
+  const homeRoot = sideboardWorkspacesDir();
+  if (existsSync8(homeRoot)) {
+    try {
+      for (const entry of readdirSync4(homeRoot, { withFileTypes: true })) {
+        if (!entry.isDirectory()) continue;
+        void entry;
+      }
+    } catch {
+    }
+  }
+  const orphans = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const repoPath of repos) {
+    if (!repoPath || !existsSync8(repoPath)) continue;
+    try {
+      const wts = await listWorktrees(repoPath);
+      for (const wt of wts) {
+        const path = wt.path.replace(/\/$/, "");
+        if (!isSideboardWorktreePath(path)) continue;
+        if (known.has(path)) continue;
+        if (seen.has(path)) continue;
+        seen.add(path);
+        let mtimeMs = 0;
+        try {
+          mtimeMs = statSync4(path).mtimeMs;
+        } catch {
+          mtimeMs = 0;
+        }
+        orphans.push({ path, repoPath, mtimeMs });
+      }
+    } catch {
+    }
+    try {
+      const root = worktreesRoot(repoPath);
+      if (existsSync8(root)) {
+        for (const entry of readdirSync4(root, { withFileTypes: true })) {
+          if (!entry.isDirectory()) continue;
+          const path = join7(root, entry.name).replace(/\/$/, "");
+          if (known.has(path) || seen.has(path)) continue;
+          if (!existsSync8(join7(path, ".git"))) continue;
+          seen.add(path);
+          let mtimeMs = 0;
+          try {
+            mtimeMs = statSync4(path).mtimeMs;
+          } catch {
+            mtimeMs = Date.now();
+          }
+          orphans.push({ path, repoPath, mtimeMs });
+        }
+      }
+    } catch {
+    }
+  }
+  return orphans.sort((a, b) => a.mtimeMs - b.mtimeMs);
+}
+async function cleanupOrphanWorktrees(opts) {
+  const settings = loadAppSettings();
+  const maxCount = opts?.maxCount ?? settings.advanced.worktreeMaxCount ?? 25;
+  const orphans = await findOrphanWorktrees(opts?.repoPaths);
+  const activeCount = listThreads().filter((t) => t.status !== "archived").length;
+  const budget = Math.max(0, maxCount - activeCount);
+  const sortedNewestFirst = [...orphans].sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const keep = new Set(sortedNewestFirst.slice(0, budget).map((o) => o.path));
+  const removed = [];
+  const kept = [];
+  for (const orphan of orphans) {
+    if (keep.has(orphan.path)) {
+      kept.push(orphan.path);
+      continue;
+    }
+    if (opts?.dryRun) {
+      removed.push(orphan.path);
+      continue;
+    }
+    try {
+      await removeWorktree(orphan.repoPath, orphan.path);
+      removed.push(orphan.path);
+    } catch {
+      kept.push(orphan.path);
+    }
+  }
+  if (!opts?.dryRun) {
+    updateAdvancedSettings({
+      worktreeLastCleanupAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  return { removed, kept, orphans };
+}
+function shouldRunWorktreeCleanup(settings = loadAppSettings()) {
+  const intervalHours = settings.advanced.worktreeCleanupIntervalHours ?? 6;
+  const last = settings.advanced.worktreeLastCleanupAt;
+  if (!last) return true;
+  const elapsed = Date.now() - Date.parse(last);
+  return elapsed >= intervalHours * 36e5;
+}
+function worktreeCleanupSettings() {
+  const a = loadAppSettings().advanced;
+  return {
+    worktreeMaxCount: a.worktreeMaxCount,
+    worktreeCleanupIntervalHours: a.worktreeCleanupIntervalHours,
+    worktreeLastCleanupAt: a.worktreeLastCleanupAt,
+    autoCleanupOrphans: a.autoCleanupOrphans
+  };
+}
+
+// src/git/apply-into-main.ts
+import { execa as execa4 } from "execa";
+async function applyThreadIntoMain(thread, opts) {
+  const method = opts?.method ?? "merge";
+  const target = opts?.targetBranch?.trim() || await resolveDefaultBranch(thread.repoPath);
+  const status = await execa4("git", ["status", "--porcelain"], {
+    cwd: thread.repoPath,
+    reject: false
+  });
+  if (status.stdout.trim()) {
+    throw new Error(
+      `Main checkout is dirty \u2014 commit or stash before apply-into-main (${thread.repoPath})`
+    );
+  }
+  const checkout = await execa4("git", ["checkout", target], {
+    cwd: thread.repoPath,
+    reject: false
+  });
+  if (checkout.exitCode !== 0) {
+    throw new Error(
+      `Failed to checkout ${target}: ${checkout.stderr.trim() || checkout.stdout.trim()}`
+    );
+  }
+  if (method === "cherry-pick") {
+    const log = await execa4(
+      "git",
+      ["log", "--reverse", "--format=%H", `${target}..${thread.branchName}`],
+      { cwd: thread.repoPath, reject: false }
+    );
+    const shas = log.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+    if (!shas.length) {
+      return {
+        applied: false,
+        method,
+        targetBranch: target,
+        message: `No commits on ${thread.branchName} not already in ${target}`
+      };
+    }
+    for (const sha of shas) {
+      const cp = await execa4("git", ["cherry-pick", sha], {
+        cwd: thread.repoPath,
+        reject: false
+      });
+      if (cp.exitCode !== 0) {
+        await execa4("git", ["cherry-pick", "--abort"], {
+          cwd: thread.repoPath,
+          reject: false
+        });
+        throw new Error(
+          `Cherry-pick ${sha.slice(0, 8)} failed: ${cp.stderr.trim() || cp.stdout.trim()}`
+        );
+      }
+    }
+    return {
+      applied: true,
+      method,
+      targetBranch: target,
+      message: `Cherry-picked ${shas.length} commit(s) from ${thread.branchName} into ${target}`
+    };
+  }
+  const merge = await execa4(
+    "git",
+    ["merge", "--no-ff", "-m", `Apply Sideboard thread ${thread.branchName}`, thread.branchName],
+    { cwd: thread.repoPath, reject: false }
+  );
+  if (merge.exitCode !== 0) {
+    await execa4("git", ["merge", "--abort"], {
+      cwd: thread.repoPath,
+      reject: false
+    });
+    throw new Error(
+      `Merge failed: ${merge.stderr.trim() || merge.stdout.trim()}`
+    );
+  }
+  return {
+    applied: true,
+    method: "merge",
+    targetBranch: target,
+    message: `Merged ${thread.branchName} into ${target} at ${thread.repoPath}`
+  };
+}
+
+// src/git/clone-repo.ts
+import { existsSync as existsSync9 } from "fs";
+import { basename as basename2, join as join8 } from "path";
+import { execa as execa5 } from "execa";
+async function cloneRepoIntoSideboard(opts) {
+  const url = opts.url.trim();
+  if (!url) throw new Error("Clone URL is required");
+  let name = opts.name?.trim();
+  if (!name) {
+    const leaf = basename2(url.replace(/\/$/, "").replace(/\.git$/, ""));
+    name = leaf || "repo";
+  }
+  name = name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
+  const dest = join8(sideboardReposDir(), name);
+  if (existsSync9(dest)) {
+    const repoPath2 = await resolveRepoRoot(dest);
+    const workspace2 = await ensureWorkspace(repoPath2);
+    return { repoPath: repoPath2, workspace: workspace2 };
+  }
+  const result = await execa5("git", ["clone", url, dest], { reject: false });
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `git clone failed: ${result.stderr?.trim() || result.stdout?.trim() || `exit ${result.exitCode}`}`
+    );
+  }
+  const repoPath = await resolveRepoRoot(dest);
+  const workspace = await ensureWorkspace(repoPath);
+  return { repoPath, workspace };
+}
+
+// src/orchestrator/orchestrator.ts
+import { EventEmitter } from "events";
+import { existsSync as existsSync10 } from "fs";
+
+// src/threads/sync-branch.ts
+async function syncThreadBranchFromGit(threadId) {
+  const thread = readThread(threadId);
+  if (!thread?.worktreePath?.trim()) return;
+  const { stdout, exitCode } = await git(
+    ["rev-parse", "--abbrev-ref", "HEAD"],
+    thread.worktreePath,
+    { reject: false }
+  );
+  if (exitCode !== 0) return;
+  const branch = stdout.trim();
+  if (!branch || branch === "HEAD") return;
+  const siblings = threadsSharingWorktree(thread.worktreePath);
+  const canonicalId = siblings[0]?.id ?? null;
+  for (const sibling of siblings) {
+    const patch = {};
+    if (sibling.branchName !== branch) patch.branchName = branch;
+    if (sibling.id === canonicalId && !sibling.userSetTitle) {
+      const nextTitle = threadDisplayLabel({
+        ...sibling,
+        branchName: branch
+      });
+      if (sibling.title !== nextTitle) patch.title = nextTitle;
+    }
+    if (Object.keys(patch).length > 0) {
+      updateThread(sibling.id, patch);
+    }
+  }
+}
+
+// src/orchestrator/orchestrator.ts
+var Orchestrator = class {
+  events = new EventEmitter();
+  processes = /* @__PURE__ */ new Map();
+  activeTurns = /* @__PURE__ */ new Map();
+  draining = /* @__PURE__ */ new Set();
+  /** Threads past setStatus(running) but not yet in activeTurns (spawn in flight). */
+  startingTurns = /* @__PURE__ */ new Set();
+  /**
+   * Threads intentionally force-stopped. Prevents runTurn from re-asserting
+   * `running` after spawn, and from overwriting `stopped` with idle/error when
+   * the killed turn's handle.done resolves.
+   */
+  stoppedTurns = /* @__PURE__ */ new Set();
+  /** WIP snapshot SHA at the start of the latest agent turn (per thread). */
+  turnBaselines = /* @__PURE__ */ new Map();
+  maxConcurrent;
+  runningCount = 0;
+  constructor(opts) {
+    this.maxConcurrent = opts?.maxConcurrent ?? 3;
+  }
+  on(listener) {
+    this.events.on("event", listener);
+    return () => this.events.off("event", listener);
+  }
+  emit(event) {
+    this.events.emit("event", event);
+  }
+  /** True when disk says running but this process is not actually turning. */
+  isStaleRunningThread(threadId, status) {
+    return status === "running" && !this.activeTurns.has(threadId) && !this.startingTurns.has(threadId);
+  }
+  async reconcile(repoPath, opts) {
+    const reclaimStaleTurns = opts?.reclaimStaleTurns !== false;
+    healOrchestrationSoccerTitles();
+    for (const thread of listThreads({ includeArchived: true })) {
+      if (thread.status === "archived") continue;
+      if (isGlobalThread(thread)) {
+        ensureGlobalCoordinatorCwd();
+        const heal = {};
+        if (thread.sourceType !== "orchestration") {
+          heal.sourceType = "orchestration";
+        }
+        if (thread.sessionId && orchestratorSessionPoisonedByBuiltins(thread)) {
+          heal.sessionId = null;
+        }
+        if (Object.keys(heal).length) {
+          updateThread(thread.id, heal);
+        }
+        if (reclaimStaleTurns && this.isStaleRunningThread(thread.id, thread.status)) {
+          setStatus(thread.id, "stopped", "Process died (reconciled on startup)");
+          this.emit({ type: "status_changed", threadId: thread.id, status: "stopped" });
+        }
+        continue;
+      }
+      if (!existsSync10(thread.worktreePath)) {
+        setStatus(thread.id, "broken", "Worktree missing on disk");
+        this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
+        continue;
+      }
+      if (reclaimStaleTurns && this.isStaleRunningThread(thread.id, thread.status)) {
+        setStatus(thread.id, "stopped", "Process died (reconciled on startup)");
+        this.emit({ type: "status_changed", threadId: thread.id, status: "stopped" });
+      }
+    }
+    const repoPaths = (repoPath ? [repoPath] : [...new Set(listThreads({ includeArchived: true }).map((t) => t.repoPath))]).filter((p) => !isGlobalRepoPath(p));
+    try {
+      const orphans = await findOrphanWorktrees(repoPaths);
+      if (orphans.length) {
+        this.emit({
+          type: "orphan_worktrees",
+          orphans: orphans.map((o) => ({ path: o.path, repoPath: o.repoPath }))
+        });
+      }
+      const { autoCleanupOrphansEnabled } = await import("./app-settings-BDMLWCWI.js");
+      if (autoCleanupOrphansEnabled() && shouldRunWorktreeCleanup() && orphans.length > 0) {
+        await cleanupOrphanWorktrees({ repoPaths });
+      }
+    } catch {
+    }
+    for (const thread of listThreads()) {
+      if (thread.queue.length > 0) {
+        void this.drainQueue(thread.id);
+      }
+    }
+  }
+  getThreads(includeArchived = false) {
+    return listThreads({ includeArchived });
+  }
+  getThread(idOrRef) {
+    return findThreadByRef(idOrRef) ?? readThread(idOrRef);
+  }
+  async createThread(input) {
+    let thread = await createThread(input, (line) => {
+      this.emit({
+        type: "turn_output",
+        threadId: "pending",
+        event: { type: "stdout", data: line }
+      });
+    });
+    this.emit({ type: "status_changed", threadId: thread.id, status: thread.status });
+    const { autoRunAfterSetupEnabled } = await import("./app-settings-BDMLWCWI.js");
+    if (autoRunAfterSetupEnabled()) {
+      try {
+        await this.startDev(thread.id);
+      } catch {
+      }
+    }
+    const prompt = input.prompt?.trim();
+    if (prompt) {
+      thread = await this.send(thread.id, prompt);
+    }
+    return thread;
+  }
+  listWorkspaces() {
+    const fromThreads = listThreads({ includeArchived: true }).map((t) => t.repoPath);
+    return syncWorkspacesFromThreads(fromThreads);
+  }
+  async addWorkspace(repoPath) {
+    return addWorkspace(repoPath);
+  }
+  removeWorkspace(repoPath) {
+    removeWorkspace(repoPath);
+  }
+  async adopt(input) {
+    const thread = await adoptThread(input);
+    this.emit({ type: "status_changed", threadId: thread.id, status: thread.status });
+    return thread;
+  }
+  listConductor() {
+    return listConductorWorkspaces();
+  }
+  async adoptFromConductor(workspaceId) {
+    const thread = await importConductorWorkspaceAsync(workspaceId);
+    this.emit({ type: "status_changed", threadId: thread.id, status: thread.status });
+    return thread;
+  }
+  async send(threadRef, prompt) {
+    const thread = this.requireThread(threadRef);
+    return withThreadLock(thread.id, async () => {
+      const current = this.requireThread(thread.id);
+      const queue = [...current.queue, prompt];
+      updateThread(thread.id, { queue, status: "queued" });
+      this.emit({ type: "queue_changed", threadId: thread.id, queue });
+      this.emit({ type: "status_changed", threadId: thread.id, status: "queued" });
+      void this.drainQueue(thread.id);
+      return this.requireThread(thread.id);
+    });
+  }
+  async fanOut(threadRefs, prompt) {
+    const results = [];
+    for (const ref of threadRefs) {
+      results.push(await this.send(ref, prompt));
+    }
+    return results;
+  }
+  async drainQueue(threadId) {
+    if (this.draining.has(threadId)) return;
+    this.draining.add(threadId);
+    try {
+      while (true) {
+        const thread = readThread(threadId);
+        if (!thread || thread.queue.length === 0) {
+          if (thread && thread.status === "queued") {
+            setStatus(threadId, "idle");
+            this.emit({ type: "status_changed", threadId, status: "idle" });
+          }
+          break;
+        }
+        if (this.runningCount >= this.maxConcurrent) {
+          await new Promise((r) => setTimeout(r, 250));
+          continue;
+        }
+        if (this.activeTurns.has(threadId)) {
+          await new Promise((r) => setTimeout(r, 100));
+          continue;
+        }
+        const prompt = thread.queue[0];
+        const remaining = thread.queue.slice(1);
+        updateThread(threadId, { queue: remaining });
+        this.emit({ type: "queue_changed", threadId, queue: remaining });
+        await this.runTurn(threadId, prompt);
+      }
+    } finally {
+      this.draining.delete(threadId);
+    }
+  }
+  async runTurn(threadId, prompt) {
+    let thread = this.requireThread(threadId);
+    if (isGlobalThread(thread) && thread.sessionId && orchestratorSessionPoisonedByBuiltins(thread)) {
+      thread = updateThread(threadId, { sessionId: null });
+    }
+    this.runningCount += 1;
+    const turnStartedAt = Date.now();
+    this.startingTurns.add(threadId);
+    setStatus(threadId, "running");
+    this.emit({ type: "status_changed", threadId, status: "running" });
+    this.emit({ type: "turn_started", threadId, prompt });
+    try {
+      const baseline = await captureTurnBaseline(thread.worktreePath);
+      if (baseline) this.turnBaselines.set(threadId, baseline);
+    } catch {
+    }
+    try {
+      const compact = await maybeCompactContext(thread);
+      if (compact.didCompact) {
+        thread = updateThread(threadId, {
+          messages: compact.thread.messages,
+          sessionId: null
+        });
+        this.emit({
+          type: "context_compacted",
+          threadId,
+          olderCount: compact.olderCount ?? 0,
+          method: compact.method ?? "extractive"
+        });
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.emit({ type: "error", threadId, message: `context compact failed: ${message}` });
+      thread = this.requireThread(threadId);
+    }
+    appendMessage(threadId, {
+      role: "user",
+      text: prompt,
+      ts: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    thread = this.requireThread(threadId);
+    const { agentPrompt: expandedPrompt } = expandComposerPrompt(
+      thread.worktreePath,
+      prompt,
+      {
+        attachments: thread.attachments
+      }
+    );
+    const orchestrationReminder = isOrchestratorThread(thread) ? coordinatorTurnReminder({
+      parentId: threadId,
+      goal: thread.sourceRef || thread.title
+    }) : null;
+    const agentPrompt = [
+      thread.planMode ? PLAN_MODE_INSTRUCTION : null,
+      orchestrationReminder,
+      expandedPrompt
+    ].filter(Boolean).join("\n\n");
+    const instructionFiles = loadAgentInstructions(thread.worktreePath, thread.agent);
+    if (thread.attachments.length > 0) {
+      updateThread(threadId, { attachments: [] });
+    }
+    const adapter = getAdapter(thread.agent);
+    const resolved = await adapter.resolveSessionId(thread.worktreePath, thread.sessionId);
+    if (resolved && resolved !== thread.sessionId) {
+      updateThread(threadId, { sessionId: resolved });
+    }
+    const fresh = this.requireThread(threadId);
+    if (!fresh.worktreePath?.trim()) {
+      throw new Error(
+        `Thread ${threadId} has no worktreePath \u2014 refusing to start an agent outside an isolated worktree`
+      );
+    }
+    const isBrightsy = fresh.agent === "brightsy";
+    const isOrchestration = isOrchestratorThread(fresh);
+    const worktreeDirective = isBrightsy || isOrchestration ? null : formatWorktreeDirective(fresh);
+    const settings = loadWorkspaceSettings(fresh.worktreePath, fresh.repoPath);
+    const { autoRenameBranchEnabled } = await import("./app-settings-BDMLWCWI.js");
+    const renameBranchDirective = !isBrightsy && !isOrchestration && autoRenameBranchEnabled() ? formatRenameBranchDirective(fresh, {
+      customPrompt: settings?.prompts?.renameBranch
+    }) : null;
+    const instructions = fresh.agent === "claude" || isBrightsy ? null : formatAgentInstructions(instructionFiles);
+    let seed = null;
+    if (!fresh.sessionId) {
+      const prior = fresh.messages.slice(0, -1);
+      seed = isBrightsy ? buildSessionSeed(prior.slice(-6), { tools: "none" }) : buildSessionSeed(prior);
+    }
+    let coordinatorDirective = null;
+    if (isOrchestration) {
+      if (isGlobalThread(fresh)) ensureGlobalCoordinatorCwd();
+      if (!fresh.sessionId) {
+        const inventory = await enrichWorkspacesWithGithub(this.listWorkspaces());
+        coordinatorDirective = coordinatorSystemPrompt({
+          goal: fresh.sourceRef || fresh.title || "Orchestration",
+          parentId: fresh.id,
+          workspaces: inventory,
+          audience: "desktop"
+        });
+      }
+    }
+    const cachedPrefix = [
+      coordinatorDirective,
+      worktreeDirective,
+      renameBranchDirective,
+      ...fresh.agent === "claude" && fresh.sessionId ? [] : [instructions, seed]
+    ].filter(Boolean).join("\n\n---\n\n");
+    try {
+      const handle = await spawnAgentTurn(
+        fresh,
+        { cachedPrefix, prompt: agentPrompt },
+        (event) => {
+          this.emit({ type: "turn_output", threadId, event });
+          if (event.type === "session_id") {
+            updateThread(threadId, { sessionId: event.data });
+          }
+        }
+      );
+      this.activeTurns.set(threadId, handle);
+      this.startingTurns.delete(threadId);
+      if (this.stoppedTurns.has(threadId)) {
+        handle.kill();
+      } else {
+        const live = readThread(threadId);
+        if (live && (live.status !== "running" || live.lastError)) {
+          setStatus(threadId, "running");
+          this.emit({ type: "status_changed", threadId, status: "running" });
+        }
+      }
+      this.processes.set(`${threadId}:agent`, {
+        kind: "agent",
+        pid: handle.pid,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        kill: handle.kill
+      });
+      const result = await handle.done;
+      if (result.sessionId) {
+        updateThread(threadId, { sessionId: result.sessionId });
+      }
+      if (result.assistantText.trim() || result.parts.length > 0) {
+        appendMessage(threadId, {
+          role: "agent",
+          text: result.assistantText.trim(),
+          parts: result.parts.length > 0 ? result.parts : void 0,
+          durationMs: Math.max(0, Date.now() - turnStartedAt),
+          usage: result.usage ?? void 0,
+          ts: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+      const afterTurn = this.requireThread(threadId);
+      if (afterTurn.planMode && afterTurn.agent === "claude" && result.parts.some(
+        (p) => p.type === "tool" && /exitplanmode/i.test(p.name)
+      )) {
+        updateThread(threadId, { sessionId: null });
+      }
+      await syncThreadBranchFromGit(threadId);
+      if (this.stoppedTurns.has(threadId)) {
+        setStatus(threadId, "stopped");
+        this.emit({ type: "status_changed", threadId, status: "stopped" });
+        this.emit({ type: "turn_finished", threadId, exitCode: result.exitCode });
+      } else {
+        setStatus(threadId, result.exitCode === 0 ? "idle" : "error", result.exitCode === 0 ? null : `exit ${result.exitCode}`);
+        this.emit({
+          type: "status_changed",
+          threadId,
+          status: result.exitCode === 0 ? "idle" : "error"
+        });
+        this.emit({ type: "turn_finished", threadId, exitCode: result.exitCode });
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      await syncThreadBranchFromGit(threadId).catch(() => void 0);
+      if (this.stoppedTurns.has(threadId)) {
+        setStatus(threadId, "stopped");
+        this.emit({ type: "status_changed", threadId, status: "stopped" });
+        this.emit({ type: "turn_finished", threadId, exitCode: 1 });
+      } else {
+        setStatus(threadId, "error", message);
+        this.emit({ type: "error", threadId, message });
+        this.emit({ type: "status_changed", threadId, status: "error" });
+        this.emit({ type: "turn_finished", threadId, exitCode: 1 });
+      }
+    } finally {
+      this.startingTurns.delete(threadId);
+      this.activeTurns.delete(threadId);
+      this.processes.delete(`${threadId}:agent`);
+      this.stoppedTurns.delete(threadId);
+      this.runningCount = Math.max(0, this.runningCount - 1);
+    }
+  }
+  /**
+   * Stop an in-flight agent turn.
+   * Default `clearQueue: true` (force-stop): kills the turn AND empties queued prompts
+   * so drainQueue cannot continue / re-start work after an intentional stop. Desktop,
+   * CLI, MCP, and cloud-connect all share this default.
+   */
+  stop(threadRef, opts) {
+    const clearQueue = opts?.clearQueue !== false;
+    const thread = this.requireThread(threadRef);
+    const inFlight = this.activeTurns.has(thread.id) || this.startingTurns.has(thread.id);
+    if (inFlight) {
+      this.stoppedTurns.add(thread.id);
+    }
+    if (clearQueue && thread.queue.length > 0) {
+      updateThread(thread.id, { queue: [] });
+      this.emit({ type: "queue_changed", threadId: thread.id, queue: [] });
+    }
+    const handle = this.activeTurns.get(thread.id);
+    if (handle) handle.kill();
+    const proc = this.processes.get(`${thread.id}:agent`);
+    if (proc) proc.kill();
+    setStatus(thread.id, "stopped");
+    this.emit({ type: "status_changed", threadId: thread.id, status: "stopped" });
+    return this.requireThread(thread.id);
+  }
+  async startDev(threadRef, scriptName) {
+    const thread = this.requireThread(threadRef);
+    this.assertNotGlobal(thread, "Run script");
+    const scripts = listRunScripts(thread.worktreePath, thread.repoPath);
+    const resolvedName = scriptName ?? scripts.find((s) => s.default === true)?.name ?? scripts.find((s) => s.name === "dev")?.name ?? scripts.find((s) => s.name !== "all")?.name ?? scripts[0]?.name;
+    if (!resolvedName) {
+      throw new Error(
+        "No run script found for this worktree. Add [scripts.run.*] in the worktree\u2019s .sideboard/settings.toml or .conductor/settings.toml (or settings.local.toml on the main repo)."
+      );
+    }
+    const runKey = `${thread.id}:run:${resolvedName}`;
+    const existing = this.processes.get(runKey);
+    const active = (thread.activeRuns ?? []).find((r) => r.scriptName === resolvedName);
+    if (existing && active) {
+      return { port: active.port, scriptName: resolvedName, ports: active.ports };
+    }
+    if (!scriptName) {
+      const legacy = this.processes.get(`${thread.id}:dev`);
+      if (legacy && thread.devPort) {
+        return { port: thread.devPort, scriptName: resolvedName, ports: [thread.devPort] };
+      }
+    }
+    const mode = getRunMode(thread.worktreePath, thread.repoPath);
+    if (mode === "nonconcurrent") {
+      for (const t of listThreads()) {
+        if (t.id === thread.id) continue;
+        const runs = t.activeRuns ?? [];
+        if (runs.length > 0 || t.devPort) {
+          throw new Error(
+            `run_mode is nonconcurrent \u2014 stop running scripts on thread ${t.id.slice(0, 8)} first`
+          );
+        }
+      }
+    }
+    const handle = await startDevServer(
+      thread.repoPath,
+      thread.worktreePath,
+      (line) => {
+        this.emit({
+          type: "run_output",
+          threadId: thread.id,
+          scriptName: resolvedName,
+          line
+        });
+      },
+      { scriptName: resolvedName }
+    );
+    if (!handle) {
+      throw new Error(`Run script not found: ${resolvedName}`);
+    }
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.processes.set(runKey, {
+      kind: "dev",
+      pid: handle.pid,
+      startedAt,
+      scriptName: resolvedName,
+      kill: handle.kill
+    });
+    const isDefault = scripts.find((s) => s.default)?.name === resolvedName || !scripts.some((s) => s.default) && (resolvedName === "dev" || resolvedName === scripts[0]?.name);
+    if (isDefault) {
+      this.processes.set(`${thread.id}:dev`, {
+        kind: "dev",
+        pid: handle.pid,
+        startedAt,
+        scriptName: resolvedName,
+        kill: handle.kill
+      });
+    }
+    const run2 = {
+      scriptName: resolvedName,
+      port: handle.port,
+      ports: handle.ports,
+      startedAt
+    };
+    const nextRuns = [
+      ...(thread.activeRuns ?? []).filter((r) => r.scriptName !== resolvedName),
+      run2
+    ];
+    updateThread(thread.id, {
+      activeRuns: nextRuns,
+      devPort: isDefault ? handle.port : thread.devPort
+    });
+    this.emit({
+      type: "dev_server_started",
+      threadId: thread.id,
+      port: handle.port,
+      scriptName: resolvedName
+    });
+    void handle.done.then(() => {
+      this.processes.delete(runKey);
+      if (isDefault) this.processes.delete(`${thread.id}:dev`);
+      const latest = readThread(thread.id);
+      const remaining = (latest?.activeRuns ?? []).filter(
+        (r) => r.scriptName !== resolvedName
+      );
+      updateThread(thread.id, {
+        activeRuns: remaining,
+        devPort: isDefault ? null : latest?.devPort ?? null
+      });
+      this.emit({
+        type: "dev_server_stopped",
+        threadId: thread.id,
+        scriptName: resolvedName
+      });
+    });
+    return { port: handle.port, scriptName: resolvedName, ports: handle.ports };
+  }
+  stopDev(threadRef, scriptName) {
+    const thread = this.requireThread(threadRef);
+    if (scriptName) {
+      const runKey = `${thread.id}:run:${scriptName}`;
+      const proc = this.processes.get(runKey);
+      if (proc) proc.kill();
+      this.processes.delete(runKey);
+      const remaining = (thread.activeRuns ?? []).filter((r) => r.scriptName !== scriptName);
+      const isPrimary = thread.devPort != null && thread.activeRuns?.find((r) => r.scriptName === scriptName)?.port === thread.devPort;
+      updateThread(thread.id, {
+        activeRuns: remaining,
+        devPort: isPrimary ? null : thread.devPort
+      });
+      this.emit({ type: "dev_server_stopped", threadId: thread.id, scriptName });
+      return;
+    }
+    for (const [key, proc] of [...this.processes.entries()]) {
+      if (key.startsWith(`${thread.id}:run:`) || key === `${thread.id}:dev`) {
+        proc.kill();
+        this.processes.delete(key);
+      }
+    }
+    updateThread(thread.id, { activeRuns: [], devPort: null });
+    this.emit({ type: "dev_server_stopped", threadId: thread.id });
+  }
+  listThreadRunScripts(threadRef) {
+    const thread = this.requireThread(threadRef);
+    return listRunScripts(thread.worktreePath, thread.repoPath);
+  }
+  getActiveRuns(threadRef) {
+    return this.requireThread(threadRef).activeRuns ?? [];
+  }
+  async runSetup(threadRef) {
+    const thread = this.requireThread(threadRef);
+    this.assertNotGlobal(thread, "Setup");
+    const key = `${thread.id}:setup`;
+    if (this.processes.has(key)) {
+      throw new Error("Setup already running for this thread");
+    }
+    const abort = new AbortController();
+    this.processes.set(key, {
+      kind: "setup",
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      kill: () => abort.abort()
+    });
+    this.emit({ type: "setup_started", threadId: thread.id });
+    try {
+      let setup = await runSetupScript(
+        thread.repoPath,
+        thread.worktreePath,
+        (line) => {
+          this.emit({ type: "setup_output", threadId: thread.id, line });
+        },
+        { signal: abort.signal }
+      );
+      if (!setup.ran) {
+        setup = await runCursorWorktreeSetup(
+          thread.repoPath,
+          thread.worktreePath,
+          (line) => {
+            this.emit({ type: "setup_output", threadId: thread.id, line });
+          }
+        );
+      }
+      if (!setup.ran) {
+        throw new Error(
+          "No setup script in .sideboard/settings.toml, .conductor/settings.toml, or .cursor/worktrees.json"
+        );
+      }
+      if (setup.exitCode !== 0 && setup.exitCode !== null) {
+        updateThread(thread.id, {
+          lastError: `Setup exited ${setup.exitCode}`
+        });
+      }
+      this.emit({ type: "setup_finished", threadId: thread.id, exitCode: setup.exitCode });
+      return { exitCode: setup.exitCode, source: setup.source };
+    } finally {
+      this.processes.delete(key);
+    }
+  }
+  cancelSetup(threadRef) {
+    const thread = this.requireThread(threadRef);
+    const proc = this.processes.get(`${thread.id}:setup`);
+    if (proc) proc.kill();
+  }
+  async applyIntoMain(threadRef, opts) {
+    const thread = this.requireThread(threadRef);
+    return applyThreadIntoMain(thread, opts);
+  }
+  async cloneRepo(url, name) {
+    return cloneRepoIntoSideboard({ url, name });
+  }
+  async listOrphanWorktrees(repoPath) {
+    const repos = repoPath ? [repoPath] : [...new Set(listThreads({ includeArchived: true }).map((t) => t.repoPath))];
+    return findOrphanWorktrees(repos);
+  }
+  async cleanupOrphans(opts) {
+    const repoPaths = opts?.repoPath ? [opts.repoPath] : [...new Set(listThreads({ includeArchived: true }).map((t) => t.repoPath))];
+    return cleanupOrphanWorktrees({
+      dryRun: opts?.dryRun,
+      maxCount: opts?.maxCount,
+      repoPaths
+    });
+  }
+  /**
+   * Best-of-n / fanout: create N threads (one per agent) with the same prompt.
+   */
+  async bestOfN(opts) {
+    const agents = opts.agents.length ? opts.agents : ["claude"];
+    const sourceType = opts.sourceType ?? "branch";
+    const sourceRef = opts.sourceRef ?? "default";
+    const created = [];
+    for (const agent of agents) {
+      const thread = await this.createThread({
+        sourceType,
+        sourceRef,
+        agent,
+        repoPath: opts.repoPath,
+        title: opts.title ? `${opts.title} (${agent})` : `best-of-n: ${opts.prompt.slice(0, 48)} (${agent})`,
+        prompt: opts.prompt
+      });
+      created.push(thread);
+    }
+    return created;
+  }
+  async waitForTurn(threadRef, timeoutMs = 6e5) {
+    const thread = this.requireThread(threadRef);
+    const start = Date.now();
+    return new Promise((resolve, reject) => {
+      if (!["running", "queued"].includes(thread.status)) {
+        resolve(thread);
+        return;
+      }
+      const off = this.on((event) => {
+        if (event.type === "turn_finished" && event.threadId === thread.id) {
+          off();
+          resolve(this.requireThread(thread.id));
+        }
+        if (event.type === "error" && event.threadId === thread.id) {
+          off();
+          resolve(this.requireThread(thread.id));
+        }
+      });
+      const timer = setInterval(() => {
+        if (Date.now() - start > timeoutMs) {
+          clearInterval(timer);
+          off();
+          reject(new Error("wait_for_turn timed out"));
+        }
+        const current = readThread(thread.id);
+        if (current && !["running", "queued"].includes(current.status)) {
+          clearInterval(timer);
+          off();
+          resolve(current);
+        }
+      }, 200);
+    });
+  }
+  getTurnResult(threadRef) {
+    const thread = this.requireThread(threadRef);
+    const lastAgent = [...thread.messages].reverse().find((m) => m.role === "agent");
+    return {
+      text: lastAgent?.text ?? "",
+      status: thread.status,
+      sessionId: thread.sessionId
+    };
+  }
+  assertNotGlobal(thread, action) {
+    if (isGlobalThread(thread)) {
+      throw new Error(`${action} is not available on the global coordinator`);
+    }
+  }
+  async diff(threadRef, opts) {
+    const thread = this.requireThread(threadRef);
+    this.assertNotGlobal(thread, "Diff");
+    return getDiff(thread.worktreePath, thread.repoPath, {
+      scope: opts?.scope,
+      commitSha: opts?.commitSha,
+      lastTurnBase: this.turnBaselines.get(thread.id) ?? null
+    });
+  }
+  async diffSummary(threadRef) {
+    const thread = this.requireThread(threadRef);
+    this.assertNotGlobal(thread, "Diff");
+    return getDiffSummary(thread.worktreePath, thread.repoPath);
+  }
+  async initializeGit(threadRef) {
+    const thread = this.requireThread(threadRef);
+    this.assertNotGlobal(thread, "Initialize git");
+    await initializeGitRepository(thread.worktreePath);
+  }
+  async listFiles(threadRef) {
+    const thread = this.requireThread(threadRef);
+    return listWorktreeFiles(thread.worktreePath);
+  }
+  async readFile(threadRef, relativePath) {
+    const thread = this.requireThread(threadRef);
+    if (relativePath.includes("..") || relativePath.startsWith("/")) {
+      throw new Error("Invalid path");
+    }
+    return readWorktreeFile(thread.worktreePath, relativePath);
+  }
+  async writeFile(threadRef, relativePath, content) {
+    const thread = this.requireThread(threadRef);
+    if (relativePath.includes("..") || relativePath.startsWith("/")) {
+      throw new Error("Invalid path");
+    }
+    return writeWorktreeFile(thread.worktreePath, relativePath, content);
+  }
+  listSkills(threadRef) {
+    const thread = this.requireThread(threadRef);
+    return discoverSkills(thread.worktreePath);
+  }
+  async previewLand(threadRef) {
+    const thread = this.requireThread(threadRef);
+    this.assertNotGlobal(thread, "Land");
+    return previewLand(thread);
+  }
+  async confirmLand(threadRef, opts) {
+    const thread = this.requireThread(threadRef);
+    this.assertNotGlobal(thread, "Land");
+    const result = await confirmLand(thread, opts);
+    if (result.prUrl) {
+      const patch = { prUrl: result.prUrl };
+      try {
+        const details = await getPrDetails(thread.worktreePath, result.prUrl);
+        if (details?.title) patch.prTitle = details.title;
+      } catch {
+      }
+      updateThread(thread.id, patch);
+      await syncThreadBranchFromGit(thread.id);
+    }
+    return result;
+  }
+  async mergePr(threadRef) {
+    const { thread, selector, cwd } = await this.withPrSelector(threadRef);
+    this.assertNotGlobal(thread, "Merge PR");
+    if (!selector) throw new Error("No pull request linked to this thread");
+    const result = await mergePr(cwd, selector);
+    if (result.url && result.url !== thread.prUrl) {
+      updateThread(thread.id, { prUrl: result.url });
+    }
+    return result;
+  }
+  /** Resolve PR selector and optionally persist `prUrl` when found. */
+  async withPrSelector(threadRef) {
+    const thread = this.requireThread(threadRef);
+    const selector = resolvePrSelector(thread);
+    const cwd = thread.worktreePath;
+    if (!cwd?.trim()) {
+      throw new Error(`Thread ${threadRef} has no worktreePath`);
+    }
+    return { thread, selector, cwd };
+  }
+  async getPrChecks(threadRef) {
+    const { selector, cwd } = await this.withPrSelector(threadRef);
+    if (!selector) return null;
+    return getPrChecks(cwd, selector);
+  }
+  async getPrDetails(threadRef) {
+    const { thread, selector, cwd } = await this.withPrSelector(threadRef);
+    if (!selector) return null;
+    const details = await getPrDetails(cwd, selector);
+    if (details) {
+      const patch = {};
+      if (details.url && details.url !== thread.prUrl) patch.prUrl = details.url;
+      if (details.title && details.title !== thread.prTitle) patch.prTitle = details.title;
+      if (Object.keys(patch).length > 0) {
+        updateThread(thread.id, patch);
+        const latest = this.requireThread(thread.id);
+        if (!latest.userSetTitle && details.title && latest.title !== details.title) {
+          updateThread(thread.id, { title: details.title });
+        }
+      }
+    }
+    return details;
+  }
+  setAutonomy(threadRef, autonomy) {
+    return this.setThreadOptions(threadRef, { autonomy });
+  }
+  setThreadOptions(threadRef, patch) {
+    const thread = this.requireThread(threadRef);
+    const next = {};
+    if (patch.autonomy !== void 0) next.autonomy = patch.autonomy;
+    if (patch.fast !== void 0) next.fast = patch.fast;
+    if (patch.planMode !== void 0) next.planMode = patch.planMode;
+    if (patch.model !== void 0) next.model = patch.model;
+    if (patch.agent !== void 0) {
+      next.agent = patch.agent;
+      if (patch.agent !== "claude" && patch.model === void 0) next.model = null;
+      next.sessionId = null;
+    }
+    return updateThread(thread.id, next);
+  }
+  createChatTab(input) {
+    return createChatTab(input);
+  }
+  forkChatTab(input) {
+    return forkChatTab(input);
+  }
+  async forkThreadWorktree(input) {
+    const thread = await forkThreadWorktree(input, (line) => {
+      this.emit({
+        type: "turn_output",
+        threadId: "pending",
+        event: { type: "stdout", data: line }
+      });
+    });
+    this.emit({ type: "status_changed", threadId: thread.id, status: thread.status });
+    return thread;
+  }
+  renameThread(threadRef, title) {
+    const thread = this.requireThread(threadRef);
+    const next = title.trim();
+    if (!next) throw new Error("Title cannot be empty");
+    return updateThread(thread.id, { title: next, userSetTitle: true });
+  }
+  setAttachments(threadRef, attachments) {
+    return updateThread(this.requireThread(threadRef).id, { attachments });
+  }
+  listWorktreeChats(threadRef) {
+    const thread = this.requireThread(threadRef);
+    return threadsSharingWorktree(thread.worktreePath);
+  }
+  async archive(threadRef) {
+    const thread = this.requireThread(threadRef);
+    this.stop(thread.id);
+    if (isGlobalThread(thread)) {
+      return setStatus(thread.id, "archived");
+    }
+    const siblings = threadsSharingWorktree(thread.worktreePath).filter((t) => t.id !== thread.id);
+    if (siblings.length === 0) {
+      this.stopDev(thread.id);
+      try {
+        await runArchiveScript(thread.repoPath, thread.worktreePath, (line) => {
+          this.emit({
+            type: "turn_output",
+            threadId: thread.id,
+            event: { type: "stdout", data: `[archive] ${line}` }
+          });
+        });
+      } catch {
+      }
+      await removeWorktree(thread.repoPath, thread.worktreePath);
+    }
+    return setStatus(thread.id, "archived");
+  }
+  async purge(threadRef, opts) {
+    const thread = this.requireThread(threadRef);
+    this.stop(thread.id);
+    if (isGlobalThread(thread)) {
+      deleteThreadRecord(thread.id);
+      return;
+    }
+    const siblings = threadsSharingWorktree(thread.worktreePath).filter((t) => t.id !== thread.id);
+    if (siblings.length === 0) {
+      this.stopDev(thread.id);
+      try {
+        await runArchiveScript(thread.repoPath, thread.worktreePath);
+      } catch {
+      }
+      const { deleteBranchOnPurgeEnabled } = await import("./app-settings-BDMLWCWI.js");
+      const deleteBranch = opts?.deleteBranch ?? deleteBranchOnPurgeEnabled();
+      await removeWorktree(thread.repoPath, thread.worktreePath, {
+        deleteBranch: deleteBranch ? thread.branchName : void 0
+      });
+    }
+    deleteThreadRecord(thread.id);
+  }
+  async restore(threadRef) {
+    const thread = this.requireThread(threadRef);
+    if (thread.status !== "archived") {
+      throw new Error("Thread is not archived");
+    }
+    if (isGlobalThread(thread)) {
+      const { globalAgentCwd } = await import("./paths-VPH3ITBK.js");
+      updateThread(thread.id, { worktreePath: globalAgentCwd() });
+      return setStatus(thread.id, "idle");
+    }
+    if (!existsSync10(thread.worktreePath)) {
+      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-NGFDN3J4.js");
+      const { execa: execa6 } = await import("execa");
+      const slug = thread.worktreePath.split("/").pop();
+      const dest = thread.worktreePath;
+      await execa6("git", ["worktree", "add", dest, thread.branchName], {
+        cwd: thread.repoPath
+      });
+      void createThreadWorktree2;
+      void slug;
+    }
+    return setStatus(thread.id, "idle");
+  }
+  async attachCommand(threadRef) {
+    const thread = this.requireThread(threadRef);
+    const adapter = getAdapter(thread.agent);
+    return adapter.buildAttach(thread);
+  }
+  setMaxConcurrent(n) {
+    this.maxConcurrent = Math.max(1, Math.min(32, Math.floor(n)));
+  }
+  getRuntime() {
+    const threads = listThreads();
+    const count = (status) => threads.filter((t) => t.status === status).length;
+    return {
+      running: this.runningCount,
+      maxConcurrent: this.maxConcurrent,
+      queued: count("queued"),
+      idle: count("idle"),
+      error: count("error"),
+      stopped: count("stopped"),
+      broken: count("broken"),
+      totalActive: threads.length
+    };
+  }
+  requireThread(ref) {
+    const thread = this.getThread(ref);
+    if (!thread) throw new Error(`Thread not found: ${ref}`);
+    return thread;
+  }
+};
+var singleton = null;
+function getOrchestrator() {
+  if (!singleton) {
+    singleton = new Orchestrator();
+  }
+  return singleton;
+}
+async function startOrchestration(opts) {
+  const repoPath = opts.repoPath?.trim();
+  if (!repoPath || isGlobalRepoPath(repoPath)) {
+    return createGlobalChat({
+      sourceRef: opts.goal,
+      agent: opts.agent,
+      autonomy: opts.autonomy,
+      model: opts.model,
+      fast: opts.fast,
+      planMode: opts.planMode,
+      attachments: opts.attachments
+    });
+  }
+  const { titleFromPrompt } = await import("./title-4A2ATYNY.js");
+  const title = titleFromPrompt(opts.goal) || "Orchestration";
+  const createOpts = {
+    agent: opts.agent,
+    repoPath,
+    title,
+    autonomy: opts.autonomy,
+    model: opts.model,
+    fast: opts.fast,
+    planMode: opts.planMode,
+    attachments: opts.attachments
+  };
+  const thread = await createThread({
+    sourceType: "branch",
+    sourceRef: "default",
+    ...createOpts
+  }).catch(async () => {
+    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-NGFDN3J4.js");
+    const repo = await resolveRepoRoot2(repoPath);
+    const def = await resolveDefaultBranch2(repo);
+    return createThread({
+      sourceType: "branch",
+      sourceRef: def,
+      ...createOpts,
+      repoPath: repo
+    });
+  });
+  const { updateThread: upd } = await import("./thread-store-UNPZNIFW.js");
+  return upd(thread.id, {
+    sourceType: "orchestration",
+    sourceRef: opts.goal
+  });
+}
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { basename as basename3 } from "path";
+
+// src/mcp/archive-guard.ts
+function mcpArchiveBlockedReason(thread) {
+  if (isCloudCoordinatorThread(thread)) {
+    return "Refusing to archive the cloud coordinator via MCP. Archive it from the Sideboard UI if needed.";
+  }
+  return null;
+}
+
+// src/mcp/server.ts
+var MAX_ORCH_THREADS = 5;
+async function startMcpServer() {
+  const orch = getOrchestrator();
+  await orch.reconcile(void 0, { reclaimStaleTurns: false });
+  const server = new McpServer({
+    name: "sideboard",
+    version: "0.1.0"
+  });
+  server.tool(
+    "list_workspaces",
+    "List registered Sideboard workspaces (repos). Each line is name, path, and github:owner/repo when resolvable \u2014 use path as repoPath for list_branches/list_prs/list_issues/create_thread.",
+    {},
+    async () => {
+      const workspaces = orch.listWorkspaces();
+      const lines = await Promise.all(
+        workspaces.map(async (w) => {
+          const slug = await resolveGithubRepoSlug(w.path).catch(() => null);
+          return slug ? `${w.name}  ${w.path}  github:${slug}` : `${w.name}  ${w.path}`;
+        })
+      );
+      return {
+        content: [
+          { type: "text", text: lines.join("\n") || "(no workspaces)" }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "list_threads",
+    "List Sideboard threads across all workspaces (one summary line each \u2014 token-frugal). Each line ends with sideboard://thread/<id> \u2014 use that URL in markdown links so the UI can open the chat.",
+    {},
+    async () => {
+      const threads = orch.getThreads(true);
+      const lines = threads.map((t) => {
+        const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : basename3(t.repoPath) || t.repoPath;
+        return `${t.id.slice(0, 8)}  ${t.status.padEnd(9)}  ${t.agent.padEnd(8)}  ${repo}  ${t.sourceType}:${t.sourceRef}  ${t.title}  sideboard://thread/${t.id}${t.devPort ? `  http://localhost:${t.devPort}` : ""}`;
+      });
+      return {
+        content: [{ type: "text", text: lines.join("\n") || "(no threads)" }]
+      };
+    }
+  );
+  server.tool(
+    "get_thread",
+    "Get a compact thread summary by id/ref",
+    { ref: z.string() },
+    async ({ ref }) => {
+      const t = orch.getThread(ref);
+      if (!t) {
+        return { content: [{ type: "text", text: `Thread not found: ${ref}` }], isError: true };
+      }
+      const summary = {
+        id: t.id,
+        title: t.title,
+        status: t.status,
+        agent: t.agent,
+        sourceType: t.sourceType,
+        sourceRef: t.sourceRef,
+        branchName: t.branchName,
+        worktreePath: t.worktreePath,
+        sessionId: t.sessionId,
+        queueLength: t.queue.length,
+        messageCount: t.messages.length,
+        devPort: t.devPort,
+        prUrl: t.prUrl,
+        lastError: t.lastError ?? null
+      };
+      return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
+    }
+  );
+  server.tool(
+    "create_thread",
+    "Create a new worktree thread (chat) from branch, pr, or ticket. Pass repoPath from list_workspaces and parentThreadId when spawning from an orchestrator. Then use send_to_thread to chat.",
+    {
+      sourceType: z.enum(["branch", "pr", "ticket"]),
+      sourceRef: z.string(),
+      agent: z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]),
+      repoPath: z.string(),
+      title: z.string().optional(),
+      parentThreadId: z.string().optional()
+    },
+    async (args) => {
+      if (args.parentThreadId) {
+        const children = orch.getThreads(true).filter((t) => t.parentThreadId === args.parentThreadId);
+        if (children.length >= MAX_ORCH_THREADS) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Thread-creation cap (${MAX_ORCH_THREADS}) reached for this orchestration session`
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+      const thread = await orch.createThread({
+        sourceType: args.sourceType,
+        sourceRef: args.sourceRef,
+        agent: args.agent,
+        repoPath: args.repoPath,
+        title: args.title,
+        parentThreadId: args.parentThreadId ?? null
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              id: thread.id,
+              title: thread.title,
+              branchName: thread.branchName,
+              worktreePath: thread.worktreePath,
+              status: thread.status,
+              link: `sideboard://thread/${thread.id}`
+            })
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "send_to_thread",
+    "Queue a prompt on a worktree thread chat (runs under concurrency cap). Use after create_thread to start or continue a conversation. Set force_stop=true to interrupt an in-flight/queued turn (kill + clear queue) before queueing this prompt \u2014 use when the thread is mid-turn or has stale queued prompts you need to replace.",
+    {
+      ref: z.string(),
+      prompt: z.string(),
+      force_stop: z.boolean().optional()
+    },
+    async ({ ref, prompt, force_stop }) => {
+      if (force_stop) {
+        const existing = orch.getThread(ref);
+        if (existing) {
+          orch.stop(ref, { clearQueue: true });
+        }
+      }
+      const thread = await orch.send(ref, prompt);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              id: thread.id,
+              status: thread.status,
+              queueLength: thread.queue.length,
+              forceStopped: Boolean(force_stop)
+            })
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "wait_for_turn",
+    "Block until the thread finishes its current/queued turn (avoids polling). Use after send_to_thread to read the agent reply.",
+    {
+      ref: z.string(),
+      timeoutMs: z.number().optional()
+    },
+    async ({ ref, timeoutMs }) => {
+      const thread = await orch.waitForTurn(ref, timeoutMs ?? 6e5);
+      const result = orch.getTurnResult(thread.id);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              id: thread.id,
+              status: result.status,
+              text: result.text
+            })
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "get_turn_result",
+    "Final assistant message only (not full transcript)",
+    { ref: z.string() },
+    async ({ ref }) => {
+      const result = orch.getTurnResult(ref);
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+  );
+  server.tool(
+    "stop_thread",
+    "Force-stop a thread: kill any in-flight agent turn AND clear queued prompts so drainQueue cannot continue. Does not archive the worktree. Optional force defaults to true.",
+    {
+      ref: z.string(),
+      force: z.boolean().optional()
+    },
+    async ({ ref, force }) => {
+      const t = orch.getThread(ref);
+      if (!t) {
+        return {
+          content: [{ type: "text", text: `Thread not found: ${ref}` }],
+          isError: true
+        };
+      }
+      const clearQueue = force !== false;
+      const hadQueued = t.queue.length > 0;
+      const stopped = orch.stop(ref, { clearQueue });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              id: stopped.id,
+              status: stopped.status,
+              clearedQueue: clearQueue && hadQueued
+            })
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "archive_thread",
+    "Archive a thread (stops agent/dev, runs archive script, removes worktree when last chat tab). Cannot archive the cloud coordinator \u2014 use the Sideboard UI for that.",
+    { ref: z.string() },
+    async ({ ref }) => {
+      const t = orch.getThread(ref);
+      if (!t) {
+        return {
+          content: [{ type: "text", text: `Thread not found: ${ref}` }],
+          isError: true
+        };
+      }
+      const blocked = mcpArchiveBlockedReason(t);
+      if (blocked) {
+        return {
+          content: [{ type: "text", text: blocked }],
+          isError: true
+        };
+      }
+      const archived = await orch.archive(ref);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              id: archived.id,
+              status: archived.status
+            })
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "restore_thread",
+    "Restore an archived thread (recreates worktree from branch when needed)",
+    { ref: z.string() },
+    async ({ ref }) => {
+      try {
+        const restored = await orch.restore(ref);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                id: restored.id,
+                status: restored.status,
+                worktreePath: restored.worktreePath
+              })
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: message }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "get_diff",
+    "Compact diff summary (capped hunks, paginated)",
+    {
+      ref: z.string(),
+      maxFiles: z.number().optional()
+    },
+    async ({ ref, maxFiles }) => {
+      const summary = await orch.diffSummary(ref);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              ...summary,
+              files: summary.files.slice(0, maxFiles ?? 10)
+            })
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "run_dev_script",
+    "Start a .sideboard/.conductor run script for a thread (default script if name omitted); returns port",
+    {
+      ref: z.string(),
+      name: z.string().optional()
+    },
+    async ({ ref, name }) => {
+      const result = await orch.startDev(ref, name);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              port: result.port,
+              scriptName: result.scriptName,
+              ports: result.ports,
+              url: `http://localhost:${result.port}`
+            })
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "list_run_scripts",
+    "List named run scripts available for a thread",
+    { ref: z.string() },
+    async ({ ref }) => {
+      const scripts = orch.listThreadRunScripts(ref);
+      const active = orch.getActiveRuns(ref);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ scripts, active }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "stop_dev_script",
+    "Stop a running script for a thread (all scripts if name omitted)",
+    {
+      ref: z.string(),
+      name: z.string().optional()
+    },
+    async ({ ref, name }) => {
+      orch.stopDev(ref, name);
+      return { content: [{ type: "text", text: "ok" }] };
+    }
+  );
+  server.tool(
+    "run_setup",
+    "Re-run workspace setup (Sideboard/Conductor settings or .cursor/worktrees.json)",
+    { ref: z.string() },
+    async ({ ref }) => {
+      const result = await orch.runSetup(ref);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    }
+  );
+  server.tool(
+    "add_workspace",
+    "Register a git repo as a Sideboard workspace",
+    { repoPath: z.string() },
+    async ({ repoPath }) => {
+      const ws = await orch.addWorkspace(repoPath);
+      return { content: [{ type: "text", text: JSON.stringify(ws) }] };
+    }
+  );
+  server.tool(
+    "remove_workspace",
+    "Unregister a Sideboard workspace (does not archive threads)",
+    { repoPath: z.string() },
+    async ({ repoPath }) => {
+      orch.removeWorkspace(repoPath);
+      return { content: [{ type: "text", text: "ok" }] };
+    }
+  );
+  server.tool(
+    "fanout",
+    "Best-of-n: create one thread per agent with the same prompt (parallel attempts)",
+    {
+      prompt: z.string(),
+      agents: z.array(z.enum(["claude", "codex", "opencode", "brightsy", "cursor"])),
+      repoPath: z.string(),
+      sourceType: z.enum(["branch", "pr", "ticket"]).optional(),
+      sourceRef: z.string().optional(),
+      title: z.string().optional()
+    },
+    async (args) => {
+      const threads = await orch.bestOfN(args);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              threads.map((t) => ({
+                id: t.id,
+                agent: t.agent,
+                branchName: t.branchName,
+                worktreePath: t.worktreePath
+              })),
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "preview_land",
+    "Preview push+PR land (does NOT push). Use before create_draft_pr.",
+    { ref: z.string() },
+    async ({ ref }) => {
+      const preview = await orch.previewLand(ref);
+      return { content: [{ type: "text", text: JSON.stringify(preview, null, 2) }] };
+    }
+  );
+  server.tool(
+    "create_draft_pr",
+    "Commit dirty changes if needed, push the thread branch, and create/update a DRAFT GitHub PR. Ready-for-review / non-draft land stays human-only (CLI/app confirm_land). Prefer this when the orchestrator should open a PR itself; alternatively send_to_thread asking the worktree agent to run `gh pr create --draft`.",
+    { ref: z.string() },
+    async ({ ref }) => {
+      try {
+        const result = await orch.confirmLand(ref, { draft: true });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  prUrl: result.prUrl,
+                  pushed: result.pushed,
+                  committed: result.committed,
+                  draft: true
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: message }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "list_branches",
+    "List git branches in a registered workspace. Pass repoPath from list_workspaces (unmerged into the default branch by default \u2014 for create_thread sourceType=branch).",
+    {
+      repoPath: z.string(),
+      unmergedOnly: z.boolean().optional()
+    },
+    async ({ repoPath, unmergedOnly }) => {
+      const root = await resolveRepoRoot(repoPath);
+      const branches = await listBranches(root, {
+        unmergedOnly: unmergedOnly !== false
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: branches.map((b) => `${b.current ? "*" : " "} ${b.name}`).join("\n")
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "list_prs",
+    "List open GitHub PRs for a registered workspace. Pass repoPath from list_workspaces (uses gh against that repo remote). Then create_thread with sourceType=pr.",
+    { repoPath: z.string() },
+    async ({ repoPath }) => {
+      const root = await resolveRepoRoot(repoPath);
+      const prs = await listPrs(root);
+      return {
+        content: [
+          {
+            type: "text",
+            text: prs.map(
+              (p) => `#${p.number} ${p.title} (${p.headRefName})${p.isCrossRepository ? " [fork]" : ""}`
+            ).join("\n")
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "list_issues",
+    "List issues from Sideboard Account connections (Linear API or GitHub Issues; Linear\u2192GitHub fallback when Linear is not connected). Pass repoPath from list_workspaces \u2014 GitHub Issues are scoped to that repo. Then create_thread with sourceType=ticket.",
+    { repoPath: z.string() },
+    async ({ repoPath }) => {
+      const root = await resolveRepoRoot(repoPath);
+      const result = await listIssues(root);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server.tool(
+    "list_linear_issues",
+    "Deprecated: prefer list_issues. Lists assigned Linear issues via the chosen agent MCP connector",
+    {
+      agent: z.enum(["claude", "codex", "opencode"]),
+      repoPath: z.string()
+    },
+    async ({ agent, repoPath }) => {
+      const issues = await listLinearIssues(agent, repoPath);
+      return { content: [{ type: "text", text: JSON.stringify(issues, null, 2) }] };
+    }
+  );
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+export {
+  listLinearIssuesDirect,
+  validateLinearApiKey,
+  listGitHubIssues,
+  listIssues,
+  toolDetail,
+  toolDescription,
+  toolFilePath,
+  applyAgentEvent,
+  partsToAssistantText,
+  stripBrightsyNdjsonNoise,
+  isBrightsyNdjsonLine,
+  finalizeParts,
+  normalizeParseResult,
+  mergeUsage,
+  totalTokens,
+  spawnAgentTurn,
+  formatRenameBranchDirective,
+  formatWorktreeDirective,
+  loadAgentInstructions,
+  formatAgentInstructions,
+  withAgentInstructions,
+  detectAgents,
+  requireAgent,
+  readWorktreeInclude,
+  resolveFilesToCopy,
+  copyConfiguredFiles,
+  captureLoginEnv,
+  buildWorkspaceScriptEnv,
+  runSetupScript,
+  runArchiveScript,
+  listRunScripts,
+  getDefaultRunScript,
+  getRunScript,
+  getRunMode,
+  allocatePort,
+  allocatePortRange,
+  startDevServer,
+  runCursorWorktreeSetup,
+  hasCursorWorktreeSetup,
+  inspectGitWorktree,
+  initializeGitRepository,
+  captureTurnBaseline,
+  listBranchCommits,
+  getDiff,
+  listWorktreeFiles,
+  readWorktreeFile,
+  writeWorktreeFile,
+  getDiffSummary,
+  discoverSkills,
+  readSkillBody,
+  expandComposerPrompt,
+  summarizeConversation,
+  extractiveSummary,
+  CONTEXT_COMPACT_CHARS,
+  CONTEXT_KEEP_RECENT_CHARS,
+  CONTEXT_KEEP_RECENT_MESSAGES,
+  CONTEXT_MIN_MESSAGES,
+  estimateMessageChars,
+  estimateThreadChars,
+  shouldCompactContext,
+  splitForCompaction,
+  formatMessagesAsTranscript,
+  buildSessionSeed,
+  applyCompaction,
+  maybeCompactContext,
+  previewLand,
+  confirmLand,
+  createThread,
+  listLinearIssues,
+  sameWorktreePath,
+  takenTeamSlugsForChatTab,
+  threadsSharingWorktree,
+  formatTranscriptMarkdown,
+  forkMessageSlice,
+  buildForkTranscriptAttachment,
+  createChatTab,
+  forkChatTab,
+  forkThreadWorktree,
+  resolveConductorCursorAgentId,
+  adoptThread,
+  conductorDbPath,
+  listConductorWorkspaces,
+  importConductorWorkspace,
+  importConductorWorkspaceAsync,
+  findOrphanWorktrees,
+  cleanupOrphanWorktrees,
+  shouldRunWorktreeCleanup,
+  worktreeCleanupSettings,
+  applyThreadIntoMain,
+  cloneRepoIntoSideboard,
+  Orchestrator,
+  getOrchestrator,
+  startOrchestration,
+  startMcpServer
+};