@sideboard-ai/core 0.1.44 → 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)",
@@ -5322,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];
@@ -5502,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,
@@ -5516,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];
@@ -5552,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 = {
@@ -7175,12 +7405,19 @@ 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
@@ -7237,6 +7474,7 @@ async function requestReview(threadRef, send) {
 
 // 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}`);
@@ -7244,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,
@@ -7266,6 +7516,115 @@ 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_fs20 = require("fs");
@@ -8469,7 +8828,7 @@ function expandComposerPrompt(worktreePath, prompt, opts) {
 // src/composer/stage-files.ts
 var import_node_fs23 = require("fs");
 var import_node_path22 = require("path");
-var import_node_crypto4 = require("crypto");
+var import_node_crypto5 = require("crypto");
 var IMAGE_EXTENSIONS2 = /* @__PURE__ */ new Set([
   "png",
   "jpg",
@@ -8525,7 +8884,7 @@ function uniqueAttachmentName(dir, originalName) {
     const candidate = `${stem}-${i}${ext}`;
     if (!(0, import_node_fs23.existsSync)((0, import_node_path22.join)(dir, candidate))) return candidate;
   }
-  return `${stem}-${(0, import_node_crypto4.randomUUID)()}${ext}`;
+  return `${stem}-${(0, import_node_crypto5.randomUUID)()}${ext}`;
 }
 function previewDataUrlFromBuf(filePath, buf) {
   if (!isImageFilePath(filePath)) return void 0;
@@ -8537,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_crypto4.randomUUID)(),
+      id: (0, import_node_crypto5.randomUUID)(),
       name,
       kind: "file",
       path: opts.path,
@@ -8550,7 +8909,7 @@ function attachmentFromBuffer(name, buf, opts) {
   }
   if (buf.length > MAX_INLINE_BYTES) {
     return {
-      id: (0, import_node_crypto4.randomUUID)(),
+      id: (0, import_node_crypto5.randomUUID)(),
       name,
       kind: "file",
       path: opts.path,
@@ -8559,7 +8918,7 @@ function attachmentFromBuffer(name, buf, opts) {
   }
   if (buf.includes(0)) {
     return {
-      id: (0, import_node_crypto4.randomUUID)(),
+      id: (0, import_node_crypto5.randomUUID)(),
       name,
       kind: "file",
       path: opts.path,
@@ -8567,7 +8926,7 @@ function attachmentFromBuffer(name, buf, opts) {
     };
   }
   return {
-    id: (0, import_node_crypto4.randomUUID)(),
+    id: (0, import_node_crypto5.randomUUID)(),
     name,
     kind: "file",
     path: opts.path,
@@ -8591,7 +8950,7 @@ function stageAbsolutePathsAsAttachments(worktreePath, absolutePaths) {
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
-        id: (0, import_node_crypto4.randomUUID)(),
+        id: (0, import_node_crypto5.randomUUID)(),
         name: originalName,
         kind: "file",
         content: `(could not attach ${abs}: ${err instanceof Error ? err.message : String(err)})`
@@ -8615,7 +8974,7 @@ function stageBuffersAsAttachments(worktreePath, buffers) {
       out.push(attachmentFromBuffer(name, buf, { path: rel }));
     } catch (err) {
       out.push({
-        id: (0, import_node_crypto4.randomUUID)(),
+        id: (0, import_node_crypto5.randomUUID)(),
         name: originalName,
         kind: "file",
         content: `(could not attach ${originalName}: ${err instanceof Error ? err.message : String(err)})`
@@ -8629,7 +8988,7 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
   for (const rel of relativePaths) {
     if (!rel || rel.includes("..") || rel.startsWith("/")) {
       out.push({
-        id: (0, import_node_crypto4.randomUUID)(),
+        id: (0, import_node_crypto5.randomUUID)(),
         name: (0, import_node_path22.basename)(rel) || "file",
         kind: "file",
         content: `(invalid path: ${rel})`
@@ -8645,7 +9004,7 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
-        id: (0, import_node_crypto4.randomUUID)(),
+        id: (0, import_node_crypto5.randomUUID)(),
         name,
         kind: "file",
         content: `(could not read ${rel}: ${err instanceof Error ? err.message : String(err)})`
@@ -8901,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) {
@@ -8980,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 });
@@ -9338,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,
@@ -9361,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",
@@ -9375,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);
@@ -9388,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);
@@ -10154,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();
@@ -10570,6 +11048,120 @@ async function startMcpServer() {
       }
     }
   );
+  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",