@sideboard-ai/core 0.1.43 → 0.1.45

package/dist/mcp/run-stdio.cjs

@@ -133,11 +133,15 @@ function humanizeAgentFailDetail(detail) {
 }
 function formatTurnExitError(exitCode, stderrSummary) {
   const code = exitCode ?? 1;
-  const detail = humanizeAgentFailDetail(stderrSummary);
+  const raw = stderrSummary.trim();
+  if (/^exit\s*\d+$/i.test(raw)) {
+    return `exit ${code}: agent exited without details (credits, auth, rate limits, or a CLI error)`;
+  }
+  const detail = humanizeAgentFailDetail(raw);
   if (!detail) {
     return `exit ${code}: agent exited without details (credits, auth, rate limits, or a CLI error)`;
   }
-  if (looksLikeAgentFailureMessage(stderrSummary)) return detail;
+  if (looksLikeAgentFailureMessage(raw)) return detail;
   return `exit ${code}: ${detail}`;
 }
 var NODE_VERSION_FOOTER;
@@ -477,7 +481,9 @@ function normalizeThread(raw) {
     attachments: Array.isArray(raw.attachments) ? raw.attachments : [],
     prTitle: raw.prTitle ?? null,
     userSetTitle: Boolean(raw.userSetTitle),
-    activeRuns: Array.isArray(raw.activeRuns) ? raw.activeRuns : []
+    activeRuns: Array.isArray(raw.activeRuns) ? raw.activeRuns : [],
+    quotaResumeAt: raw.quotaResumeAt ?? null,
+    quotaContinuedFromId: raw.quotaContinuedFromId ?? null
   };
 }
 function createEmptyThread(partial) {
@@ -2631,6 +2637,8 @@ __export(app_settings_exports, {
   isLinearConnected: () => isLinearConnected,
   loadAppSettings: () => loadAppSettings,
   maxConcurrentAgents: () => maxConcurrentAgents,
+  orchestrationQuotaFallbackAgent: () => orchestrationQuotaFallbackAgent,
+  orchestrationQuotaOnLimit: () => orchestrationQuotaOnLimit,
   resolveClaudeExecutable: () => resolveClaudeExecutable,
   resolveEffectiveIssueSource: () => resolveEffectiveIssueSource,
   resolveThreadDefaults: () => resolveThreadDefaults,
@@ -2742,6 +2750,12 @@ function normalizeAdvanced(raw) {
   if (typeof source.autoCleanupOrphans === "boolean") {
     out.autoCleanupOrphans = source.autoCleanupOrphans;
   }
+  if (source.orchestrationQuotaOnLimit === "switch_agent" || source.orchestrationQuotaOnLimit === "wait_reset") {
+    out.orchestrationQuotaOnLimit = source.orchestrationQuotaOnLimit;
+  }
+  if (typeof source.orchestrationQuotaFallbackAgent === "string" && DEFAULT_AGENTS.has(source.orchestrationQuotaFallbackAgent)) {
+    out.orchestrationQuotaFallbackAgent = source.orchestrationQuotaFallbackAgent;
+  }
   return out;
 }
 function normalizeSettings(raw) {
@@ -2976,6 +2990,12 @@ function updateAdvancedSettings(patch) {
   if (typeof patch.autoCleanupOrphans === "boolean") {
     advanced.autoCleanupOrphans = patch.autoCleanupOrphans;
   }
+  if (patch.orchestrationQuotaOnLimit === "switch_agent" || patch.orchestrationQuotaOnLimit === "wait_reset") {
+    advanced.orchestrationQuotaOnLimit = patch.orchestrationQuotaOnLimit;
+  }
+  if (typeof patch.orchestrationQuotaFallbackAgent === "string" && DEFAULT_AGENTS.has(patch.orchestrationQuotaFallbackAgent)) {
+    advanced.orchestrationQuotaFallbackAgent = patch.orchestrationQuotaFallbackAgent;
+  }
   return saveAppSettings({ ...current, advanced });
 }
 function autoRenameBranchEnabled(settings = loadAppSettings()) {
@@ -2996,6 +3016,13 @@ function deleteBranchOnPurgeEnabled(settings = loadAppSettings()) {
 function autoCleanupOrphansEnabled(settings = loadAppSettings()) {
   return Boolean(settings.advanced.autoCleanupOrphans);
 }
+function orchestrationQuotaOnLimit(settings = loadAppSettings()) {
+  return settings.advanced.orchestrationQuotaOnLimit ?? "switch_agent";
+}
+function orchestrationQuotaFallbackAgent(settings = loadAppSettings()) {
+  const preferred = settings.advanced.orchestrationQuotaFallbackAgent;
+  return preferred && DEFAULT_AGENTS.has(preferred) ? preferred : "cursor";
+}
 function maxConcurrentAgents(settings = loadAppSettings()) {
   const n = settings.advanced.maxConcurrent;
   if (typeof n === "number" && Number.isFinite(n)) {
@@ -3223,11 +3250,14 @@ var init_coordinator_prompt = __esm({
       "Discover:",
       "- list_workspaces \u2014 registered repos (path + github slug when known)",
       "- list_branches / list_prs / list_issues \u2014 pass repoPath from list_workspaces (issues: Linear API or GitHub Issues)",
+      "- list_models \u2014 only when you need a specific model (rare); otherwise leave model unset = Auto",
       "- list_threads / get_thread \u2014 fleet status (what is going on)",
       "Workspaces:",
       "- add_workspace / remove_workspace \u2014 register or unregister a git repo",
       "Worktree threads (chats):",
       "- create_thread \u2014 create a worktree + chat from branch | pr | ticket; pass repoPath + parentThreadId",
+      "- fork_worktree \u2014 fork a worktree chat into a NEW git worktree + chat (transcript attached); optional agent; leave model unset (Auto) unless you have a reason. Not for orchestration chats.",
+      "- fork_chat \u2014 fork a worktree chat (same worktree tab) OR a Global orchestration chat (new orchestration tab); optional agent; leave model unset (Auto) unless you have a reason. Remote coordinators: use this to continue another orchestration chat on a different agent after session limits.",
       "- send_to_thread \u2014 queue a prompt (start/continue a chat turn); pass force_stop: true to interrupt mid-turn / clear stale queued prompts before replacing with a new request",
       "- wait_for_turn / get_turn_result \u2014 wait for and read the agent reply",
       "- stop_thread \u2014 force-stop: kill in-flight turn AND clear queued prompts (do not leave stale queue after an interrupt)",
@@ -3235,8 +3265,9 @@ var init_coordinator_prompt = __esm({
       "Setup / run:",
       "- run_setup \u2014 re-run worktree setup",
       "- list_run_scripts / run_dev_script / stop_dev_script \u2014 start/stop named run scripts",
-      "Inspect / PRs:",
+      "Inspect / review / PRs:",
       "- get_diff \u2014 compact diff summary",
+      "- request_review \u2014 open a Review chat tab on a worktree thread (merge-readiness recommendation); then wait_for_turn / get_turn_result on the returned id",
       "- Ask the worktree agent via send_to_thread to open a draft PR with `gh pr create --draft -R <origin-owner/name>` (workspace `github:` slug / that worktree's origin \u2014 never upstream). Do not open PRs from the orchestrator yourself.",
       "Human-only (do not attempt): merge, ready-for-review land, purge_thread.",
       "Thread links in replies: when mentioning a chat/thread for the user, include a markdown link `[Title](sideboard://thread/<id>)` using the full id (or the link field from create_thread / list_threads). Sideboard renders these as clickable opens.",
@@ -5321,6 +5352,199 @@ var init_opencode = __esm({
   }
 });
 
+// src/agents/list-models.ts
+async function listBrightsyModels() {
+  try {
+    const targets = await listBrightsyChatTargets();
+    const accountId = targets.activeAccountId;
+    const models = (targets.models ?? []).map((m) => ({
+      id: encodeBrightsyTarget("model", m.id, accountId),
+      displayName: m.name || m.id,
+      description: m.description ?? void 0
+    }));
+    const agents = (targets.agents ?? []).map((a) => ({
+      id: encodeBrightsyTarget("agent", a.id, accountId),
+      displayName: a.name || a.id,
+      description: a.description ?? "Brightsy agent target"
+    }));
+    return [...models, ...agents].slice(0, 80);
+  } catch {
+    return [];
+  }
+}
+async function listModelsForAgent(agent) {
+  const kinds = agent ? [agent] : ["claude", "codex", "opencode", "cursor", "brightsy"];
+  const out = [];
+  for (const kind of kinds) {
+    if (kind === "claude") {
+      out.push({
+        agent: kind,
+        auto: true,
+        models: CLAUDE_MODEL_CATALOG,
+        note: "Default Auto \u2014 only pass a model id when you have a reason."
+      });
+      continue;
+    }
+    if (kind === "codex") {
+      out.push({
+        agent: kind,
+        auto: true,
+        models: await listCodexModels(),
+        note: "Default Auto \u2014 only pass a model slug when you have a reason."
+      });
+      continue;
+    }
+    if (kind === "opencode") {
+      out.push({
+        agent: kind,
+        auto: true,
+        models: await listOpencodeModels(),
+        note: "Default Auto \u2014 only pass a provider/model id when you have a reason."
+      });
+      continue;
+    }
+    if (kind === "cursor") {
+      out.push({
+        agent: kind,
+        auto: true,
+        models: await listCursorModels(),
+        note: 'Default Auto \u2014 only pass a model id when you have a reason (or use "default").'
+      });
+      continue;
+    }
+    if (kind === "brightsy") {
+      const models = await listBrightsyModels();
+      out.push({
+        agent: kind,
+        auto: true,
+        models,
+        note: models.length ? "Default Auto / Default agent \u2014 only pass a model/agent id when you have a reason." : "Brightsy not logged in or no targets \u2014 leave model unset for Default."
+      });
+    }
+  }
+  return out;
+}
+var CLAUDE_MODEL_CATALOG;
+var init_list_models = __esm({
+  "src/agents/list-models.ts"() {
+    "use strict";
+    init_brightsy();
+    init_brightsy_targets();
+    init_codex();
+    init_cursor();
+    init_opencode();
+    CLAUDE_MODEL_CATALOG = [
+      { id: "fable", displayName: "Fable" },
+      { id: "opus", displayName: "Opus" },
+      { id: "sonnet", displayName: "Sonnet" },
+      { id: "haiku", displayName: "Haiku" }
+    ];
+  }
+});
+
+// src/agents/session-quota.ts
+function isSessionQuotaLimit(text) {
+  const lower = text.trim().toLowerCase();
+  if (!lower) return false;
+  if (/credit balance is too low|out of credits|insufficient.?quota|billing/.test(lower)) {
+    return false;
+  }
+  if (/prompt is too long|context.*(too long|exceed)|conversation too long/.test(lower)) {
+    return false;
+  }
+  return /you've hit your/.test(lower) || /hit your (session|weekly|opus) limit/.test(lower) || /usage limit/.test(lower) || /rate.?limit|too many requests|\b429\b/.test(lower) && /reset/i.test(text);
+}
+function parseSessionQuotaResetAt(text, now = /* @__PURE__ */ new Date()) {
+  const absolute = text.match(
+    /resets\s+(?:at\s+)?(\d{1,2}):(\d{2})\s*(am|pm)(?:\s*\(([^)]+)\))?/i
+  );
+  if (absolute) {
+    const hour12 = Number(absolute[1]);
+    const minute = Number(absolute[2]);
+    const ampm = absolute[3].toLowerCase();
+    const timeZone = absolute[4]?.trim() || Intl.DateTimeFormat().resolvedOptions().timeZone;
+    let hour = hour12 % 12;
+    if (ampm === "pm") hour += 12;
+    const at = zonedWallTimeToUtc(now, hour, minute, timeZone);
+    if (!at) return null;
+    if (at.getTime() <= now.getTime() + 3e4) {
+      const tomorrow = new Date(now.getTime() + 24 * 60 * 60 * 1e3);
+      return zonedWallTimeToUtc(tomorrow, hour, minute, timeZone);
+    }
+    return at;
+  }
+  const relative = text.match(
+    /resets\s+in\s+(\d+)\s*(minutes?|hours?|days?)/i
+  );
+  if (relative) {
+    const n = Number(relative[1]);
+    const unit = relative[2].toLowerCase();
+    const ms = unit.startsWith("day") ? n * 24 * 60 * 60 * 1e3 : unit.startsWith("hour") ? n * 60 * 60 * 1e3 : n * 60 * 1e3;
+    return new Date(now.getTime() + ms);
+  }
+  return null;
+}
+function zonedWallTimeToUtc(day, hour, minute, timeZone) {
+  try {
+    const cal = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit"
+    });
+    const parts = Object.fromEntries(
+      cal.formatToParts(day).filter((p) => p.type !== "literal").map((p) => [p.type, p.value])
+    );
+    const year = Number(parts.year);
+    const month = Number(parts.month);
+    const date = Number(parts.day);
+    if (![year, month, date].every((n) => Number.isFinite(n))) return null;
+    const utcGuess = Date.UTC(year, month - 1, date, hour, minute, 0);
+    const dtf = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hourCycle: "h23"
+    });
+    const asParts = Object.fromEntries(
+      dtf.formatToParts(new Date(utcGuess)).filter((p) => p.type !== "literal").map((p) => [p.type, p.value])
+    );
+    const asUtc = Date.UTC(
+      Number(asParts.year),
+      Number(asParts.month) - 1,
+      Number(asParts.day),
+      Number(asParts.hour),
+      Number(asParts.minute),
+      Number(asParts.second || "0")
+    );
+    const offset = asUtc - utcGuess;
+    return new Date(utcGuess - offset);
+  } catch {
+    return null;
+  }
+}
+function resolveQuotaFallbackAgent(current, preferred) {
+  const ordered = preferred ? [preferred, ...FALLBACK_ORDER.filter((a) => a !== preferred)] : FALLBACK_ORDER;
+  return ordered.find((a) => a !== current) ?? (current === "cursor" ? "codex" : "cursor");
+}
+var FALLBACK_ORDER;
+var init_session_quota = __esm({
+  "src/agents/session-quota.ts"() {
+    "use strict";
+    FALLBACK_ORDER = [
+      "cursor",
+      "codex",
+      "opencode",
+      "brightsy",
+      "claude"
+    ];
+  }
+});
+
 // src/agents/install.ts
 function getAgentSetupInfo(agent) {
   return SETUP[agent];
@@ -5501,6 +5725,7 @@ var init_install = __esm({
 // src/agents/index.ts
 var agents_exports = {};
 __export(agents_exports, {
+  CLAUDE_MODEL_CATALOG: () => CLAUDE_MODEL_CATALOG,
   PLAN_MODE_INSTRUCTION: () => PLAN_MODE_INSTRUCTION,
   allAdapters: () => allAdapters,
   brightsyAdapter: () => brightsyAdapter,
@@ -5515,17 +5740,21 @@ __export(agents_exports, {
   getAgentSetupInfo: () => getAgentSetupInfo,
   installAgent: () => installAgent,
   isCursorAutoModel: () => isCursorAutoModel,
+  isSessionQuotaLimit: () => isSessionQuotaLimit,
   listAgentSetupInfo: () => listAgentSetupInfo,
   listBrightsyChatTargets: () => listBrightsyChatTargets,
   listCodexModels: () => listCodexModels,
   listCursorModels: () => listCursorModels,
+  listModelsForAgent: () => listModelsForAgent,
   listOpencodeModels: () => listOpencodeModels,
   loginAgent: () => loginAgent,
   openInSystemTerminal: () => openInSystemTerminal,
   opencodeAdapter: () => opencodeAdapter,
   parseCursorRunnerLine: () => parseCursorRunnerLine,
+  parseSessionQuotaResetAt: () => parseSessionQuotaResetAt,
   permissionMode: () => permissionMode,
-  resolveCursorModelId: () => resolveCursorModelId
+  resolveCursorModelId: () => resolveCursorModelId,
+  resolveQuotaFallbackAgent: () => resolveQuotaFallbackAgent
 });
 function getAdapter(kind) {
   return adapters[kind];
@@ -5551,6 +5780,8 @@ var init_agents = __esm({
     init_cursor_events();
     init_cursor();
     init_opencode();
+    init_list_models();
+    init_session_quota();
     init_path();
     init_install();
     adapters = {
@@ -5690,10 +5921,10 @@ __export(cursor_recover_exports, {
 function recoverFinishedCursorRun(opts) {
   const agentId = opts.agentId.trim();
   if (!agentId) return null;
-  const runsPath = (0, import_node_path23.join)(appDataDir(), "cursor-sdk-store", "runs.ndjson");
-  if (!(0, import_node_fs24.existsSync)(runsPath)) return null;
+  const runsPath = (0, import_node_path24.join)(appDataDir(), "cursor-sdk-store", "runs.ndjson");
+  if (!(0, import_node_fs25.existsSync)(runsPath)) return null;
   try {
-    const lines = (0, import_node_fs24.readFileSync)(runsPath, "utf8").split("\n");
+    const lines = (0, import_node_fs25.readFileSync)(runsPath, "utf8").split("\n");
     let best = null;
     for (const line of lines) {
       const trimmed = line.trim();
@@ -5719,12 +5950,12 @@ function recoverFinishedCursorRun(opts) {
     return null;
   }
 }
-var import_node_fs24, import_node_path23;
+var import_node_fs25, import_node_path24;
 var init_cursor_recover = __esm({
   "src/agents/cursor-recover.ts"() {
     "use strict";
-    import_node_fs24 = require("fs");
-    import_node_path23 = require("path");
+    import_node_fs25 = require("fs");
+    import_node_path24 = require("path");
     init_paths();
   }
 });
@@ -5733,11 +5964,11 @@ var init_cursor_recover = __esm({
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_zod = require("zod");
-var import_node_path24 = require("path");
+var import_node_path25 = require("path");
 
 // src/orchestrator/orchestrator.ts
 var import_node_events = require("events");
-var import_node_fs25 = require("fs");
+var import_node_fs26 = require("fs");
 init_error_detail();
 
 // src/agents/spawn.ts
@@ -7174,16 +7405,76 @@ function forkChatTab(input) {
   const from = requireThread(input.threadId);
   const slice = forkMessageSlice(from, input.throughIndex);
   const attachment = buildForkTranscriptAttachment(from.title || "Chat", slice);
-  return createChatTab({
+  const tab = createChatTab({
     fromThreadId: input.threadId,
     agent: input.agent ?? from.agent,
+    model: input.model,
     title: input.title?.trim() || void 0,
     attachments: [attachment]
   });
+  if (isOrchestratorThread(from) && tab.parentThreadId !== from.id) {
+    const next = { ...tab, parentThreadId: from.id };
+    writeThread(next);
+    return next;
+  }
+  return tab;
+}
+
+// src/review/request-review.ts
+var import_node_crypto3 = require("crypto");
+var import_node_fs19 = require("fs");
+var import_node_path18 = require("path");
+init_global_workspace();
+init_thread_store();
+var REVIEW_REQUEST_PATH = ".sideboard/attachments/Review request.md";
+var REVIEW_REQUEST_NAME = "Review request.md";
+var REVIEW_REQUEST_PREFILL = `Please review the changes in this workspace and recommend whether they are ready to merge.
+
+Start with a **Recommendation**: Approve, Approve with nits, Request changes, or Needs more information \u2014 and say why in 1\u20133 sentences. Then list blocking findings vs nits (findings may be empty).`;
+function buildReviewRequestAttachment(content) {
+  return {
+    id: (0, import_node_crypto3.randomUUID)(),
+    name: REVIEW_REQUEST_NAME,
+    kind: "file",
+    path: REVIEW_REQUEST_PATH,
+    content
+  };
+}
+function readExistingReviewRequestFile(worktreePath) {
+  const abs = (0, import_node_path18.join)(worktreePath, REVIEW_REQUEST_PATH);
+  if (!(0, import_node_fs19.existsSync)(abs)) return null;
+  try {
+    const content = (0, import_node_fs19.readFileSync)(abs, "utf8");
+    return content.trim() ? content : null;
+  } catch {
+    return null;
+  }
+}
+async function requestReview(threadRef, send) {
+  const from = findThreadByRef(threadRef);
+  if (!from) throw new Error(`Thread not found: ${threadRef}`);
+  if (isOrchestratorThread(from)) {
+    throw new Error(
+      "request_review targets a worktree agent thread (not the orchestrator). Pass a child/worktree thread ref."
+    );
+  }
+  if (from.status === "archived") {
+    throw new Error(`Thread is archived: ${from.id}`);
+  }
+  const existing = readExistingReviewRequestFile(from.worktreePath);
+  const attachments = existing ? [buildReviewRequestAttachment(existing)] : [];
+  const tab = createChatTab({
+    fromThreadId: from.id,
+    title: "Review",
+    attachments
+  });
+  const started = await send(tab.id, REVIEW_REQUEST_PREFILL);
+  return { tab: started, from };
 }
 
 // src/threads/fork-worktree.ts
 init_thread_store();
+init_global_workspace();
 function requireThread2(idOrRef) {
   const thread = findThreadByRef(idOrRef) ?? null;
   if (!thread) throw new Error(`Thread not found: ${idOrRef}`);
@@ -7191,16 +7482,28 @@ function requireThread2(idOrRef) {
 }
 async function forkThreadWorktree(input, onSetupLine) {
   const from = requireThread2(input.threadId);
+  if (isOrchestratorThread(from)) {
+    throw new Error(
+      "fork_worktree targets a worktree agent thread (not the orchestrator). Pass a child/worktree thread ref."
+    );
+  }
+  if (!from.branchName?.trim() || !from.repoPath?.trim()) {
+    throw new Error(
+      `Cannot fork worktree: thread ${from.id} has no branch/repo (need a real worktree chat).`
+    );
+  }
   const slice = forkMessageSlice(from, input.throughIndex);
   const attachment = buildForkTranscriptAttachment(from.title || "Chat", slice);
+  const nextAgent = input.agent ?? from.agent;
+  const nextModel = input.model !== void 0 ? input.model : input.agent && input.agent !== from.agent ? null : from.model;
   const thread = await createThread(
     {
       sourceType: "branch",
       sourceRef: from.branchName,
       repoPath: from.repoPath,
-      agent: input.agent ?? from.agent,
+      agent: nextAgent,
       autonomy: from.autonomy,
-      model: from.model,
+      model: nextModel,
       effort: from.effort,
       fast: from.fast,
       planMode: from.planMode,
@@ -7213,22 +7516,131 @@ async function forkThreadWorktree(input, onSetupLine) {
   return thread;
 }
 
+// src/orchestrator/quota-failover.ts
+var import_node_crypto4 = require("crypto");
+init_session_quota();
+init_app_settings();
+init_global_workspace();
+init_thread_store();
+function planOrchestrationQuotaFailover(thread, limitText, opts) {
+  if (!isOrchestratorThread(thread)) return null;
+  if (!isSessionQuotaLimit(limitText)) return null;
+  const onLimit = opts?.onLimit ?? orchestrationQuotaOnLimit();
+  const resumeAt = parseSessionQuotaResetAt(limitText, opts?.now);
+  if (thread.quotaContinuedFromId) {
+    if (resumeAt) {
+      return {
+        action: "wait_reset",
+        reason: "Already continued once; waiting for quota reset instead.",
+        limitText,
+        resumeAt
+      };
+    }
+    return {
+      action: "none",
+      reason: "Already continued once; no parseable reset time.",
+      limitText
+    };
+  }
+  if (onLimit === "wait_reset") {
+    if (!resumeAt) {
+      return {
+        action: "none",
+        reason: "wait_reset configured but reset time could not be parsed.",
+        limitText
+      };
+    }
+    return {
+      action: "wait_reset",
+      reason: "Settings: wait for quota reset.",
+      limitText,
+      resumeAt
+    };
+  }
+  const preferred = opts?.fallbackAgent ?? orchestrationQuotaFallbackAgent();
+  const fallbackAgent = resolveQuotaFallbackAgent(thread.agent, preferred);
+  return {
+    action: "switch_agent",
+    reason: `Continue on ${fallbackAgent} (Auto) after ${thread.agent} session limit.`,
+    limitText,
+    fallbackAgent
+  };
+}
+function buildQuotaHandoffAttachment(from, limitText, fallbackAgent) {
+  const children = listThreads({ includeArchived: false }).filter((t) => t.parentThreadId === from.id && t.status !== "archived").slice(0, 40).map(
+    (t) => `- ${t.title} \xB7 ${t.status} \xB7 ${t.agent} \xB7 sideboard://thread/${t.id}`
+  );
+  const recent = from.messages.slice(-8).map((m) => {
+    const role = m.role === "user" ? "User" : m.role === "agent" ? "Agent" : "Summary";
+    const text = m.text.trim().replace(/\s+/g, " ").slice(0, 280);
+    return text ? `- ${role}: ${text}` : null;
+  }).filter(Boolean);
+  const body = [
+    `# Orchestration handoff`,
+    "",
+    `Previous chat: ${from.title} (\`${from.id}\`) on **${from.agent}** hit a session/usage limit.`,
+    `Limit: ${limitText.trim()}`,
+    `Continuing on **${fallbackAgent}** with Auto model.`,
+    "",
+    `## Goal`,
+    from.sourceRef?.trim() || "(none)",
+    "",
+    `## Child threads`,
+    children.length ? children.join("\n") : "(none listed \u2014 call list_threads)",
+    "",
+    `## Recent turns (truncated)`,
+    recent.length ? recent.join("\n") : "(none)",
+    "",
+    `## Instructions`,
+    `- Continue fleet orchestration from this handoff.`,
+    `- Prefer Sideboard MCP (list_threads, get_thread, send_to_thread, \u2026) for live status.`,
+    `- Leave model Auto unless there is a specific reason to pin one.`,
+    `- Do not wait on the limited ${from.agent} account; keep going on ${fallbackAgent}.`
+  ].join("\n");
+  return {
+    id: (0, import_node_crypto4.randomUUID)(),
+    name: "Orchestration quota handoff.md",
+    kind: "transcript",
+    content: body
+  };
+}
+var QUOTA_CONTINUE_PROMPT = (fromAgent, fallback) => [
+  `${fromAgent} hit a session/usage limit. Continue this orchestration on ${fallback} using the attached handoff.`,
+  "Call list_threads for live fleet status, then proceed with the goal. Leave model Auto unless needed."
+].join(" ");
+var QUOTA_RESUME_PROMPT = "Session/usage limit window should have reset. Continue the orchestration from where you left off. Use list_threads for fleet status.";
+function createQuotaFailoverChat(from, fallbackAgent, limitText) {
+  const handoff = buildQuotaHandoffAttachment(from, limitText, fallbackAgent);
+  const tab = createChatTab({
+    fromThreadId: from.id,
+    agent: fallbackAgent,
+    model: null,
+    attachments: [handoff]
+  });
+  return updateThread(tab.id, {
+    parentThreadId: from.id,
+    quotaContinuedFromId: from.id,
+    sourceRef: from.sourceRef,
+    sourceType: "orchestration"
+  });
+}
+
 // src/threads/adopt.ts
 var import_node_child_process = require("child_process");
-var import_node_fs19 = require("fs");
+var import_node_fs20 = require("fs");
 var import_node_os8 = require("os");
-var import_node_path18 = require("path");
+var import_node_path19 = require("path");
 var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
 init_worktree();
 init_thread_store();
-var CONDUCTOR_APP_SUPPORT = (0, import_node_path18.join)(
+var CONDUCTOR_APP_SUPPORT = (0, import_node_path19.join)(
   process.env.HOME ?? "",
   "Library",
   "Application Support",
   "com.conductor.app"
 );
-var CONDUCTOR_DB = (0, import_node_path18.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
-var CURSOR_SDK_STORE = (0, import_node_path18.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
+var CONDUCTOR_DB = (0, import_node_path19.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
+var CURSOR_SDK_STORE = (0, import_node_path19.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
 function mapAgentType(raw) {
   if (!raw) return null;
   const v = raw.toLowerCase();
@@ -7240,21 +7652,21 @@ function mapAgentType(raw) {
   return null;
 }
 function resolveConductorCursorAgentId(workspacePath) {
-  if (!workspacePath || !(0, import_node_fs19.existsSync)(CURSOR_SDK_STORE)) return null;
+  if (!workspacePath || !(0, import_node_fs20.existsSync)(CURSOR_SDK_STORE)) return null;
   const normalized = workspacePath.replace(/\/$/, "");
   let best = null;
   let hashes;
   try {
-    hashes = (0, import_node_fs19.readdirSync)(CURSOR_SDK_STORE);
+    hashes = (0, import_node_fs20.readdirSync)(CURSOR_SDK_STORE);
   } catch {
     return null;
   }
   for (const hash of hashes) {
-    const agentsFile = (0, import_node_path18.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!(0, import_node_fs19.existsSync)(agentsFile)) continue;
+    const agentsFile = (0, import_node_path19.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
+    if (!(0, import_node_fs20.existsSync)(agentsFile)) continue;
     let text;
     try {
-      text = (0, import_node_fs19.readFileSync)(agentsFile, "utf8");
+      text = (0, import_node_fs20.readFileSync)(agentsFile, "utf8");
     } catch {
       continue;
     }
@@ -7278,7 +7690,7 @@ function resolveConductorCursorAgentId(workspacePath) {
   return best?.agentId ?? null;
 }
 async function adoptThread(input) {
-  if (!(0, import_node_fs19.existsSync)(input.worktreePath)) {
+  if (!(0, import_node_fs20.existsSync)(input.worktreePath)) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
@@ -7302,18 +7714,18 @@ async function adoptThread(input) {
   return thread;
 }
 function listConductorWorkspaces() {
-  if (!(0, import_node_fs19.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs20.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs19.mkdtempSync)((0, import_node_path18.join)((0, import_node_os8.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path18.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs20.mkdtempSync)((0, import_node_path19.join)((0, import_node_os8.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path19.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs19.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs20.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs19.existsSync)(src)) {
+      if ((0, import_node_fs20.existsSync)(src)) {
         try {
-          (0, import_node_fs19.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs20.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -7389,22 +7801,22 @@ function listConductorWorkspaces() {
       db.close();
     }
   } finally {
-    (0, import_node_fs19.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs20.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 function importConductorWorkspace(workspaceId) {
-  if (!(0, import_node_fs19.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs20.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs19.mkdtempSync)((0, import_node_path18.join)((0, import_node_os8.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path18.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs20.mkdtempSync)((0, import_node_path19.join)((0, import_node_os8.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path19.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs19.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs20.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs19.existsSync)(src)) {
+      if ((0, import_node_fs20.existsSync)(src)) {
         try {
-          (0, import_node_fs19.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs20.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -7422,7 +7834,7 @@ function importConductorWorkspace(workspaceId) {
       ).get(workspaceId);
       if (!row) throw new Error(`Conductor workspace not found: ${workspaceId}`);
       const worktreePath = String(row.workspacePath);
-      if (!(0, import_node_fs19.existsSync)(worktreePath)) {
+      if (!(0, import_node_fs20.existsSync)(worktreePath)) {
         throw new Error(`Conductor worktree missing on disk: ${worktreePath}`);
       }
       let sessionId = null;
@@ -7485,7 +7897,7 @@ function importConductorWorkspace(workspaceId) {
       db.close();
     }
   } finally {
-    (0, import_node_fs19.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs20.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 async function importConductorWorkspaceAsync(workspaceId) {
@@ -7496,12 +7908,12 @@ async function importConductorWorkspaceAsync(workspaceId) {
 init_worktree();
 
 // src/diff/diff.ts
-var import_node_fs20 = require("fs");
-var import_node_path19 = require("path");
+var import_node_fs21 = require("fs");
+var import_node_path20 = require("path");
 init_run();
 init_worktree();
 async function inspectGitWorktree(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs20.existsSync)(worktreePath)) return "missing_worktree";
+  if (!worktreePath || !(0, import_node_fs21.existsSync)(worktreePath)) return "missing_worktree";
   const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
     reject: false
   });
@@ -7509,7 +7921,7 @@ async function inspectGitWorktree(worktreePath) {
   return "ok";
 }
 async function initializeGitRepository(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs20.existsSync)(worktreePath)) {
+  if (!worktreePath || !(0, import_node_fs21.existsSync)(worktreePath)) {
     throw new Error("Worktree not found");
   }
   const status = await inspectGitWorktree(worktreePath);
@@ -7941,8 +8353,8 @@ var DEFAULT_UPLOAD_MAX_BYTES = 5e7;
 function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES;
-  const abs = (0, import_node_path19.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs20.statSync)(abs);
+  const abs = (0, import_node_path20.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs21.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
@@ -7951,7 +8363,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
       `File too large to upload (${st.size} bytes; max ${maxBytes})`
     );
   }
-  const buf = (0, import_node_fs20.readFileSync)(abs);
+  const buf = (0, import_node_fs21.readFileSync)(abs);
   return {
     path: relativePath,
     contentBase64: buf.toString("base64"),
@@ -7961,12 +8373,12 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
 function readWorktreeFile(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? 2e5;
-  const abs = (0, import_node_path19.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs20.statSync)(abs);
+  const abs = (0, import_node_path20.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs21.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
-  const buf = (0, import_node_fs20.readFileSync)(abs);
+  const buf = (0, import_node_fs21.readFileSync)(abs);
   if (isImageRelativePath(relativePath)) {
     const maxImageBytes = Math.max(maxBytes, 15e6);
     const truncated2 = buf.length > maxImageBytes;
@@ -8009,9 +8421,9 @@ function assertSafeRelativePath(relativePath) {
 }
 function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
-  const abs = (0, import_node_path19.join)(worktreePath, relativePath);
-  (0, import_node_fs20.mkdirSync)((0, import_node_path19.dirname)(abs), { recursive: true });
-  (0, import_node_fs20.writeFileSync)(abs, content, "utf8");
+  const abs = (0, import_node_path20.join)(worktreePath, relativePath);
+  (0, import_node_fs21.mkdirSync)((0, import_node_path20.dirname)(abs), { recursive: true });
+  (0, import_node_fs21.writeFileSync)(abs, content, "utf8");
   return { path: relativePath };
 }
 async function getDiffSummary(worktreePath, repoPath, opts) {
@@ -8190,9 +8602,9 @@ async function confirmLand(thread, opts) {
 }
 
 // src/skills/discover.ts
-var import_node_fs21 = require("fs");
+var import_node_fs22 = require("fs");
 var import_node_os9 = require("os");
-var import_node_path20 = require("path");
+var import_node_path21 = require("path");
 function toCommand(name) {
   return name.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
@@ -8224,7 +8636,7 @@ function parseFrontmatter(content) {
 }
 function readSkill(skillMd, source) {
   try {
-    const content = (0, import_node_fs21.readFileSync)(skillMd, "utf8");
+    const content = (0, import_node_fs22.readFileSync)(skillMd, "utf8");
     const { name: fmName, description } = parseFrontmatter(content);
     const dirName = skillMd.split("/").slice(-2, -1)[0] || "skill";
     const name = fmName || dirName;
@@ -8243,19 +8655,19 @@ function readSkill(skillMd, source) {
   }
 }
 function scanSkillsDir(dir, source, out) {
-  if (!(0, import_node_fs21.existsSync)(dir)) return;
+  if (!(0, import_node_fs22.existsSync)(dir)) return;
   let entries;
   try {
-    entries = (0, import_node_fs21.readdirSync)(dir);
+    entries = (0, import_node_fs22.readdirSync)(dir);
   } catch {
     return;
   }
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
-    const skillMd = (0, import_node_path20.join)(dir, entry, "SKILL.md");
-    if (!(0, import_node_fs21.existsSync)(skillMd)) continue;
+    const skillMd = (0, import_node_path21.join)(dir, entry, "SKILL.md");
+    if (!(0, import_node_fs22.existsSync)(skillMd)) continue;
     try {
-      if (!(0, import_node_fs21.statSync)(skillMd).isFile()) continue;
+      if (!(0, import_node_fs22.statSync)(skillMd).isFile()) continue;
     } catch {
       continue;
     }
@@ -8264,24 +8676,24 @@ function scanSkillsDir(dir, source, out) {
   }
 }
 function scanClaudePluginSkills(pluginsRoot, out) {
-  if (!(0, import_node_fs21.existsSync)(pluginsRoot)) return;
+  if (!(0, import_node_fs22.existsSync)(pluginsRoot)) return;
   const walk = (dir, depth, lookingForSkillsDir) => {
     if (depth > 7) return;
     let entries;
     try {
-      entries = (0, import_node_fs21.readdirSync)(dir);
+      entries = (0, import_node_fs22.readdirSync)(dir);
     } catch {
       return;
     }
     if (lookingForSkillsDir && entries.includes("SKILL.md")) {
-      const skill = readSkill((0, import_node_path20.join)(dir, "SKILL.md"), "cli");
+      const skill = readSkill((0, import_node_path21.join)(dir, "SKILL.md"), "cli");
       if (skill) out.push(skill);
     }
     for (const entry of entries) {
       if (entry === "node_modules" || entry === ".git") continue;
-      const full = (0, import_node_path20.join)(dir, entry);
+      const full = (0, import_node_path21.join)(dir, entry);
       try {
-        if (!(0, import_node_fs21.statSync)(full).isDirectory()) continue;
+        if (!(0, import_node_fs22.statSync)(full).isDirectory()) continue;
       } catch {
         continue;
       }
@@ -8299,17 +8711,17 @@ function discoverSkills(worktreePath) {
   const home = (0, import_node_os9.homedir)();
   const collected = [];
   for (const rel of [".claude/skills", ".cursor/skills", ".sideboard/skills", ".brightsy/skills", "skills"]) {
-    scanSkillsDir((0, import_node_path20.join)(worktreePath, rel), "workspace", collected);
+    scanSkillsDir((0, import_node_path21.join)(worktreePath, rel), "workspace", collected);
   }
   for (const abs of [
-    (0, import_node_path20.join)(home, ".claude/skills"),
-    (0, import_node_path20.join)(home, ".cursor/skills"),
-    (0, import_node_path20.join)(home, ".sideboard/skills"),
-    (0, import_node_path20.join)(home, ".brightsy/skills")
+    (0, import_node_path21.join)(home, ".claude/skills"),
+    (0, import_node_path21.join)(home, ".cursor/skills"),
+    (0, import_node_path21.join)(home, ".sideboard/skills"),
+    (0, import_node_path21.join)(home, ".brightsy/skills")
   ]) {
     scanSkillsDir(abs, "user", collected);
   }
-  scanClaudePluginSkills((0, import_node_path20.join)(home, ".claude/plugins"), collected);
+  scanClaudePluginSkills((0, import_node_path21.join)(home, ".claude/plugins"), collected);
   const rank = { workspace: 0, user: 1, cli: 2 };
   const byCommand = /* @__PURE__ */ new Map();
   for (const skill of collected) {
@@ -8321,7 +8733,7 @@ function discoverSkills(worktreePath) {
   return [...byCommand.values()].sort((a, b) => a.command.localeCompare(b.command));
 }
 function readSkillBody(skillPath, maxChars = 12e3) {
-  const raw = (0, import_node_fs21.readFileSync)(skillPath, "utf8");
+  const raw = (0, import_node_fs22.readFileSync)(skillPath, "utf8");
   if (raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 3);
     if (end >= 0) {
@@ -8414,9 +8826,9 @@ function expandComposerPrompt(worktreePath, prompt, opts) {
 }
 
 // src/composer/stage-files.ts
-var import_node_fs22 = require("fs");
-var import_node_path21 = require("path");
-var import_node_crypto3 = require("crypto");
+var import_node_fs23 = require("fs");
+var import_node_path22 = require("path");
+var import_node_crypto5 = require("crypto");
 var IMAGE_EXTENSIONS2 = /* @__PURE__ */ new Set([
   "png",
   "jpg",
@@ -8445,7 +8857,7 @@ var ATTACHMENTS_GITIGNORE = `# Sideboard review / composer attachments (local on
 var MAX_INLINE_BYTES = 4e5;
 var MAX_PREVIEW_BYTES = 5e6;
 function fileExtension(filePath) {
-  const base = (0, import_node_path21.basename)(filePath).toLowerCase();
+  const base = (0, import_node_path22.basename)(filePath).toLowerCase();
   return base.includes(".") ? base.split(".").pop() || "" : "";
 }
 function isImageFilePath(filePath) {
@@ -8455,24 +8867,24 @@ function imageMimeType(filePath) {
   return IMAGE_MIME_BY_EXT[fileExtension(filePath)] || "image/png";
 }
 function ensureAttachmentsDir(worktreePath) {
-  const dir = (0, import_node_path21.join)(worktreePath, ATTACHMENTS_DIR);
-  (0, import_node_fs22.mkdirSync)(dir, { recursive: true });
-  const gi = (0, import_node_path21.join)(dir, ".gitignore");
-  if (!(0, import_node_fs22.existsSync)(gi)) {
-    (0, import_node_fs22.writeFileSync)(gi, ATTACHMENTS_GITIGNORE, "utf8");
+  const dir = (0, import_node_path22.join)(worktreePath, ATTACHMENTS_DIR);
+  (0, import_node_fs23.mkdirSync)(dir, { recursive: true });
+  const gi = (0, import_node_path22.join)(dir, ".gitignore");
+  if (!(0, import_node_fs23.existsSync)(gi)) {
+    (0, import_node_fs23.writeFileSync)(gi, ATTACHMENTS_GITIGNORE, "utf8");
   }
   return dir;
 }
 function uniqueAttachmentName(dir, originalName) {
   const safe = originalName.replace(/[/\\]/g, "_") || "file";
-  if (!(0, import_node_fs22.existsSync)((0, import_node_path21.join)(dir, safe))) return safe;
-  const ext = (0, import_node_path21.extname)(safe);
+  if (!(0, import_node_fs23.existsSync)((0, import_node_path22.join)(dir, safe))) return safe;
+  const ext = (0, import_node_path22.extname)(safe);
   const stem = ext ? safe.slice(0, -ext.length) : safe;
   for (let i = 1; i < 1e4; i++) {
     const candidate = `${stem}-${i}${ext}`;
-    if (!(0, import_node_fs22.existsSync)((0, import_node_path21.join)(dir, candidate))) return candidate;
+    if (!(0, import_node_fs23.existsSync)((0, import_node_path22.join)(dir, candidate))) return candidate;
   }
-  return `${stem}-${(0, import_node_crypto3.randomUUID)()}${ext}`;
+  return `${stem}-${(0, import_node_crypto5.randomUUID)()}${ext}`;
 }
 function previewDataUrlFromBuf(filePath, buf) {
   if (!isImageFilePath(filePath)) return void 0;
@@ -8484,7 +8896,7 @@ function attachmentFromBuffer(name, buf, opts) {
   if (isImageFilePath(name)) {
     const pathHint = opts.path ? `\`${opts.path}\`` : opts.sourceLabel || name;
     return {
-      id: (0, import_node_crypto3.randomUUID)(),
+      id: (0, import_node_crypto5.randomUUID)(),
       name,
       kind: "file",
       path: opts.path,
@@ -8497,7 +8909,7 @@ function attachmentFromBuffer(name, buf, opts) {
   }
   if (buf.length > MAX_INLINE_BYTES) {
     return {
-      id: (0, import_node_crypto3.randomUUID)(),
+      id: (0, import_node_crypto5.randomUUID)(),
       name,
       kind: "file",
       path: opts.path,
@@ -8506,7 +8918,7 @@ function attachmentFromBuffer(name, buf, opts) {
   }
   if (buf.includes(0)) {
     return {
-      id: (0, import_node_crypto3.randomUUID)(),
+      id: (0, import_node_crypto5.randomUUID)(),
       name,
       kind: "file",
       path: opts.path,
@@ -8514,7 +8926,7 @@ function attachmentFromBuffer(name, buf, opts) {
     };
   }
   return {
-    id: (0, import_node_crypto3.randomUUID)(),
+    id: (0, import_node_crypto5.randomUUID)(),
     name,
     kind: "file",
     path: opts.path,
@@ -8526,19 +8938,19 @@ function stageAbsolutePathsAsAttachments(worktreePath, absolutePaths) {
   const dir = ensureAttachmentsDir(worktreePath);
   const out = [];
   for (const abs of absolutePaths) {
-    const originalName = (0, import_node_path21.basename)(abs);
+    const originalName = (0, import_node_path22.basename)(abs);
     try {
-      const st = (0, import_node_fs22.statSync)(abs);
+      const st = (0, import_node_fs23.statSync)(abs);
       if (!st.isFile()) continue;
       const name = uniqueAttachmentName(dir, originalName);
-      const destAbs = (0, import_node_path21.join)(dir, name);
-      (0, import_node_fs22.copyFileSync)(abs, destAbs);
+      const destAbs = (0, import_node_path22.join)(dir, name);
+      (0, import_node_fs23.copyFileSync)(abs, destAbs);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
-      const buf = (0, import_node_fs22.readFileSync)(destAbs);
+      const buf = (0, import_node_fs23.readFileSync)(destAbs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
-        id: (0, import_node_crypto3.randomUUID)(),
+        id: (0, import_node_crypto5.randomUUID)(),
         name: originalName,
         kind: "file",
         content: `(could not attach ${abs}: ${err instanceof Error ? err.message : String(err)})`
@@ -8556,13 +8968,13 @@ function stageBuffersAsAttachments(worktreePath, buffers) {
     try {
       const buf = Buffer.from(item.dataBase64, "base64");
       const name = uniqueAttachmentName(dir, originalName);
-      const destAbs = (0, import_node_path21.join)(dir, name);
-      (0, import_node_fs22.writeFileSync)(destAbs, buf);
+      const destAbs = (0, import_node_path22.join)(dir, name);
+      (0, import_node_fs23.writeFileSync)(destAbs, buf);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
       out.push(attachmentFromBuffer(name, buf, { path: rel }));
     } catch (err) {
       out.push({
-        id: (0, import_node_crypto3.randomUUID)(),
+        id: (0, import_node_crypto5.randomUUID)(),
         name: originalName,
         kind: "file",
         content: `(could not attach ${originalName}: ${err instanceof Error ? err.message : String(err)})`
@@ -8576,23 +8988,23 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
   for (const rel of relativePaths) {
     if (!rel || rel.includes("..") || rel.startsWith("/")) {
       out.push({
-        id: (0, import_node_crypto3.randomUUID)(),
-        name: (0, import_node_path21.basename)(rel) || "file",
+        id: (0, import_node_crypto5.randomUUID)(),
+        name: (0, import_node_path22.basename)(rel) || "file",
         kind: "file",
         content: `(invalid path: ${rel})`
       });
       continue;
     }
-    const name = (0, import_node_path21.basename)(rel);
+    const name = (0, import_node_path22.basename)(rel);
     try {
-      const abs = (0, import_node_path21.join)(worktreePath, rel);
-      const st = (0, import_node_fs22.statSync)(abs);
+      const abs = (0, import_node_path22.join)(worktreePath, rel);
+      const st = (0, import_node_fs23.statSync)(abs);
       if (!st.isFile()) continue;
-      const buf = (0, import_node_fs22.readFileSync)(abs);
+      const buf = (0, import_node_fs23.readFileSync)(abs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
-        id: (0, import_node_crypto3.randomUUID)(),
+        id: (0, import_node_crypto5.randomUUID)(),
         name,
         kind: "file",
         content: `(could not read ${rel}: ${err instanceof Error ? err.message : String(err)})`
@@ -8603,8 +9015,8 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
 }
 
 // src/agents/instructions.ts
-var import_node_fs23 = require("fs");
-var import_node_path22 = require("path");
+var import_node_fs24 = require("fs");
+var import_node_path23 = require("path");
 init_worktree_labels();
 function normPath2(p) {
   return p.replace(/\/+$/, "");
@@ -8743,11 +9155,11 @@ function loadAgentInstructions(worktreePath, agent) {
   const out = [];
   for (const rel of candidates) {
     if (seen.has(rel)) continue;
-    const abs = (0, import_node_path22.join)(worktreePath, rel);
-    if (!(0, import_node_fs23.existsSync)(abs)) continue;
+    const abs = (0, import_node_path23.join)(worktreePath, rel);
+    if (!(0, import_node_fs24.existsSync)(abs)) continue;
     try {
-      if (!(0, import_node_fs23.statSync)(abs).isFile()) continue;
-      let content = (0, import_node_fs23.readFileSync)(abs, "utf8");
+      if (!(0, import_node_fs24.statSync)(abs).isFile()) continue;
+      let content = (0, import_node_fs24.readFileSync)(abs, "utf8");
       if (!content.trim()) continue;
       if (content.length > MAX_CHARS_PER_FILE) {
         content = `${content.slice(0, MAX_CHARS_PER_FILE)}
@@ -8848,6 +9260,8 @@ var Orchestrator = class {
   haltDrain = /* @__PURE__ */ new Set();
   /** WIP snapshot SHA at the start of the latest agent turn (per thread). */
   turnBaselines = /* @__PURE__ */ new Map();
+  /** Timers for orchestration session-quota auto-resume. */
+  quotaResumeTimers = /* @__PURE__ */ new Map();
   maxConcurrent;
   runningCount = 0;
   constructor(opts) {
@@ -8897,7 +9311,7 @@ var Orchestrator = class {
         }
         continue;
       }
-      if (!(0, import_node_fs25.existsSync)(thread.worktreePath)) {
+      if (!(0, import_node_fs26.existsSync)(thread.worktreePath)) {
         setStatus(thread.id, "broken", "Worktree missing on disk");
         this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
         continue;
@@ -8927,6 +9341,113 @@ var Orchestrator = class {
         void this.drainQueue(thread.id);
       }
     }
+    this.schedulePendingQuotaResumes();
+  }
+  clearQuotaResumeTimer(threadId) {
+    const timer = this.quotaResumeTimers.get(threadId);
+    if (timer) clearTimeout(timer);
+    this.quotaResumeTimers.delete(threadId);
+  }
+  /** Schedule (or fire) auto-retry after a provider session/usage limit reset. */
+  scheduleQuotaResume(threadId, resumeAt) {
+    this.clearQuotaResumeTimer(threadId);
+    updateThread(threadId, { quotaResumeAt: resumeAt.toISOString() });
+    const delay = Math.max(5e3, resumeAt.getTime() - Date.now());
+    const capped = Math.min(delay, 2147483647);
+    const timer = setTimeout(() => {
+      this.quotaResumeTimers.delete(threadId);
+      void this.resumeAfterQuotaWait(threadId);
+    }, capped);
+    this.quotaResumeTimers.set(threadId, timer);
+  }
+  schedulePendingQuotaResumes() {
+    for (const thread of listThreads({ includeArchived: false })) {
+      if (!thread.quotaResumeAt) continue;
+      const at = new Date(thread.quotaResumeAt);
+      if (Number.isNaN(at.getTime())) continue;
+      if (at.getTime() <= Date.now()) {
+        void this.resumeAfterQuotaWait(thread.id);
+      } else if (!this.quotaResumeTimers.has(thread.id)) {
+        this.scheduleQuotaResume(thread.id, at);
+      }
+    }
+  }
+  async resumeAfterQuotaWait(threadId) {
+    const thread = findThreadByRef(threadId);
+    if (!thread || thread.status === "archived") return;
+    this.clearQuotaResumeTimer(threadId);
+    try {
+      updateThread(threadId, { quotaResumeAt: null });
+    } catch {
+      return;
+    }
+    if (thread.status === "running" || this.activeTurns.has(threadId) || this.startingTurns.has(threadId)) {
+      return;
+    }
+    await this.send(threadId, QUOTA_RESUME_PROMPT);
+  }
+  /**
+   * Host-side continue when an orchestration chat hits a provider session/usage
+   * limit (not context size): switch agent (Auto) or wait until reset.
+   */
+  async maybeHandleOrchestrationQuotaFailover(threadId, limitText) {
+    const thread = findThreadByRef(threadId);
+    if (!thread) return;
+    const plan = planOrchestrationQuotaFailover(thread, limitText);
+    if (!plan || plan.action === "none") return;
+    if (plan.action === "wait_reset" && plan.resumeAt) {
+      this.haltDrain.add(threadId);
+      this.scheduleQuotaResume(threadId, plan.resumeAt);
+      setStatus(threadId, "idle", null);
+      appendMessage(threadId, {
+        role: "agent",
+        text: `Sideboard will auto-retry this orchestration around ${plan.resumeAt.toLocaleString()} when the session limit resets.`,
+        ts: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      this.emit({
+        type: "quota_failover",
+        threadId,
+        action: "wait_reset",
+        message: plan.reason,
+        resumeAt: plan.resumeAt.toISOString()
+      });
+      this.emit({ type: "status_changed", threadId, status: "idle" });
+      return;
+    }
+    if (plan.action === "switch_agent" && plan.fallbackAgent) {
+      this.haltDrain.add(threadId);
+      const next = createQuotaFailoverChat(
+        thread,
+        plan.fallbackAgent,
+        plan.limitText
+      );
+      this.clearQuotaResumeTimer(threadId);
+      try {
+        updateThread(threadId, { quotaResumeAt: null });
+      } catch {
+      }
+      appendMessage(threadId, {
+        role: "agent",
+        text: `Session limit on ${thread.agent}. Sideboard continued on ${plan.fallbackAgent} (Auto) in [${next.title}](sideboard://thread/${next.id}).`,
+        ts: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      this.emit({
+        type: "quota_failover",
+        threadId,
+        action: "switch_agent",
+        toThreadId: next.id,
+        message: plan.reason
+      });
+      this.emit({
+        type: "status_changed",
+        threadId: next.id,
+        status: next.status
+      });
+      await this.send(
+        next.id,
+        QUOTA_CONTINUE_PROMPT(thread.agent, plan.fallbackAgent)
+      );
+    }
   }
   getThreads(includeArchived = false) {
     return listThreads({ includeArchived });
@@ -9285,11 +9806,16 @@ var Orchestrator = class {
           }
         }
       }
-      const failureOnlyMessage = exitCode !== 0 && looksLikeAgentFailureMessage(assistantText) && !parts.some((p) => p.type === "tool" || p.type === "thinking");
-      if (!failureOnlyMessage && (assistantText || parts.length > 0)) {
+      const lastStderr = summarizeTurnStderr(stderrTail);
+      const detail = lastStderr || (exitCode !== 0 ? fallbackTurnFailDetail(assistantText) : "");
+      let chatText = assistantText;
+      if (exitCode !== 0 && !chatText && looksLikeAgentFailureMessage(detail)) {
+        chatText = humanizeAgentFailDetail(detail);
+      }
+      if (chatText || parts.length > 0) {
         appendMessage(threadId, {
           role: "agent",
-          text: assistantText,
+          text: chatText,
           parts: parts.length > 0 ? parts : void 0,
           durationMs: Math.max(0, Date.now() - turnStartedAt),
           usage,
@@ -9308,13 +9834,12 @@ var Orchestrator = class {
         this.emit({ type: "status_changed", threadId, status: "stopped" });
         this.emit({ type: "turn_finished", threadId, exitCode });
       } else {
-        const lastStderr = summarizeTurnStderr(stderrTail);
-        const detail = lastStderr || (exitCode !== 0 ? fallbackTurnFailDetail(assistantText) : "");
         const failDetail = formatTurnExitError(exitCode, detail);
+        const explainedInChat = exitCode !== 0 && Boolean(chatText) && (looksLikeAgentFailureMessage(chatText) || failDetail && chatText.includes(failDetail.replace(/^exit\s*\d+:\s*/i, "").trim()));
         setStatus(
           threadId,
           exitCode === 0 ? "idle" : "error",
-          exitCode === 0 ? null : failDetail
+          exitCode === 0 || explainedInChat ? null : failDetail
         );
         this.emit({
           type: "status_changed",
@@ -9322,6 +9847,10 @@ var Orchestrator = class {
           status: exitCode === 0 ? "idle" : "error"
         });
         this.emit({ type: "turn_finished", threadId, exitCode });
+        if (exitCode !== 0) {
+          const blob = [chatText, detail].filter(Boolean).join("\n");
+          void this.maybeHandleOrchestrationQuotaFailover(threadId, blob);
+        }
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -9335,6 +9864,7 @@ var Orchestrator = class {
         this.emit({ type: "error", threadId, message });
         this.emit({ type: "status_changed", threadId, status: "error" });
         this.emit({ type: "turn_finished", threadId, exitCode: 1 });
+        void this.maybeHandleOrchestrationQuotaFailover(threadId, message);
       }
     } finally {
       this.startingTurns.delete(threadId);
@@ -9795,6 +10325,15 @@ var Orchestrator = class {
   setAutonomy(threadRef, autonomy) {
     return this.setThreadOptions(threadRef, { autonomy });
   }
+  /**
+   * Open a Review chat tab on a worktree thread (same as the desktop Review button)
+   * and send the merge-readiness prefill.
+   */
+  async requestReview(threadRef) {
+    const { tab } = await requestReview(threadRef, (ref, prompt) => this.send(ref, prompt));
+    this.emit({ type: "status_changed", threadId: tab.id, status: tab.status });
+    return tab;
+  }
   setThreadOptions(threadRef, patch) {
     const thread = this.requireThread(threadRef);
     const next = {};
@@ -9919,7 +10458,7 @@ var Orchestrator = class {
       updateThread(thread.id, { worktreePath: globalAgentCwd2() });
       return setStatus(thread.id, "idle");
     }
-    if (!(0, import_node_fs25.existsSync)(thread.worktreePath)) {
+    if (!(0, import_node_fs26.existsSync)(thread.worktreePath)) {
       const { createThreadWorktree: createThreadWorktree2 } = await Promise.resolve().then(() => (init_worktree(), worktree_exports));
       const { execa: execa7 } = await import("execa");
       const slug = thread.worktreePath.split("/").pop();
@@ -10092,6 +10631,7 @@ async function listIssues(repoPath) {
 
 // src/mcp/server.ts
 init_global_workspace();
+init_list_models();
 
 // src/mcp/archive-guard.ts
 init_global_workspace();
@@ -10137,7 +10677,7 @@ async function startMcpServer() {
     async () => {
       const threads = orch.getThreads(true);
       const lines = threads.map((t) => {
-        const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : (0, import_node_path24.basename)(t.repoPath) || t.repoPath;
+        const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : (0, import_node_path25.basename)(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 {
@@ -10480,6 +11020,148 @@ async function startMcpServer() {
       };
     }
   );
+  server.tool(
+    "request_review",
+    "Start a merge-readiness Review on a worktree agent thread (same as the desktop Review button). Opens a new Review chat tab, optionally attaches .sideboard/attachments/Review request.md when present, and asks for Approve / Approve with nits / Request changes / Needs more information. Pass a worktree thread ref \u2014 not the orchestrator. Then wait_for_turn / get_turn_result on the returned review tab id.",
+    { ref: import_zod.z.string().describe("Worktree thread id/ref to review") },
+    async ({ ref }) => {
+      try {
+        const tab = await orch.requestReview(ref);
+        const from = orch.getThread(ref);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                id: tab.id,
+                title: tab.title,
+                status: tab.status,
+                fromThreadId: from?.id ?? ref,
+                link: `sideboard://thread/${tab.id}`
+              })
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: message }], isError: true };
+      }
+    }
+  );
+  const agentEnum = import_zod.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]);
+  server.tool(
+    "list_models",
+    "List models for an agent. Prefer Auto: do not call this unless you have a reason to pin a specific model (user request, cost/latency, capability). Omit agent to list all.",
+    {
+      agent: agentEnum.optional().describe("Limit to one agent; omit for all")
+    },
+    async ({ agent }) => {
+      try {
+        const catalogs = await listModelsForAgent(agent);
+        return {
+          content: [{ type: "text", text: JSON.stringify(catalogs, null, 2) }]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: message }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "fork_worktree",
+    "Fork a worktree agent chat into a NEW git worktree + chat (desktop \u201CFork to new workspace\u201D). Seeds a transcript (through through_index, default all). Optional agent override. Leave model unset for Auto (default) \u2014 only pass model when you have a reason. Not for the orchestrator. Then send_to_thread / wait_for_turn on the returned id.",
+    {
+      ref: import_zod.z.string().describe("Worktree thread id/ref to fork"),
+      through_index: import_zod.z.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
+      agent: agentEnum.optional().describe("Agent for the forked chat (default: same as source)"),
+      model: import_zod.z.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
+      title: import_zod.z.string().optional()
+    },
+    async ({ ref, through_index, agent, model, title }) => {
+      try {
+        const source = orch.getThread(ref);
+        if (source) await orch.reconcile(source.repoPath);
+        const thread = await orch.forkThreadWorktree({
+          threadId: ref,
+          throughIndex: through_index,
+          agent,
+          model,
+          title
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                id: thread.id,
+                title: thread.title,
+                status: thread.status,
+                agent: thread.agent,
+                model: thread.model,
+                branchName: thread.branchName,
+                worktreePath: thread.worktreePath,
+                fromThreadId: source?.id ?? ref,
+                link: `sideboard://thread/${thread.id}`
+              })
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: message }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "fork_chat",
+    "Fork a chat into a NEW tab on the SAME workspace: worktree agent \u2192 same worktree tab; Global orchestration chat \u2192 new orchestration chat (same synthetic home). Seeds a transcript; optional agent override. Leave model unset for Auto unless you have a reason. Remote coordinators use this to continue an orchestration chat on another agent after session limits. Then send_to_thread / wait_for_turn on the returned id. Use fork_worktree only for worktree agents that need a new git worktree.",
+    {
+      ref: import_zod.z.string().describe("Thread id/ref to fork (worktree agent or orchestration chat)"),
+      through_index: import_zod.z.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
+      agent: agentEnum.optional().describe("Agent for the forked chat (default: same as source)"),
+      model: import_zod.z.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
+      title: import_zod.z.string().optional()
+    },
+    async ({ ref, through_index, agent, model, title }) => {
+      try {
+        const source = orch.getThread(ref);
+        if (!source) {
+          return {
+            content: [{ type: "text", text: `Thread not found: ${ref}` }],
+            isError: true
+          };
+        }
+        const tab = orch.forkChatTab({
+          threadId: source.id,
+          throughIndex: through_index,
+          agent,
+          model,
+          title
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                id: tab.id,
+                title: tab.title,
+                status: tab.status,
+                agent: tab.agent,
+                model: tab.model,
+                sourceType: tab.sourceType,
+                worktreePath: tab.worktreePath,
+                fromThreadId: source.id,
+                link: `sideboard://thread/${tab.id}`
+              })
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: message }], isError: true };
+      }
+    }
+  );
   server.tool(
     "run_dev_script",
     "Start a .sideboard/.conductor run script for a thread (default script if name omitted); returns port",