@sideboard-ai/core 0.1.52 → 0.1.56

package/dist/mcp/run-stdio.cjs

@@ -92,6 +92,11 @@ function summarizeTurnStderr(tail, maxChars = 500) {
   if (joined.length <= maxChars) return joined;
   return joined.slice(joined.length - maxChars);
 }
+function looksLikeInvalidAgentSession(text) {
+  const lower = text.trim().toLowerCase();
+  if (!lower) return false;
+  return /session not found/.test(lower) || /no conversation found/.test(lower) || /conversation .+ not found/.test(lower) || /thread .+ not found/.test(lower) || /unknown session/.test(lower) || /invalid session/.test(lower) || /session .+ (missing|expired|deleted|gone)/.test(lower) || /cannot resume/.test(lower) || /failed to (load|resume|open) session/.test(lower);
+}
 function looksLikeAgentFailureMessage(text) {
   const lower = text.trim().toLowerCase();
   if (!lower) return false;
@@ -2969,6 +2974,7 @@ __export(app_settings_exports, {
   orchestrationQuotaOnLimit: () => orchestrationQuotaOnLimit,
   resolveClaudeExecutable: () => resolveClaudeExecutable,
   resolveEffectiveIssueSource: () => resolveEffectiveIssueSource,
+  resolveNewThreadOptions: () => resolveNewThreadOptions,
   resolveThreadDefaults: () => resolveThreadDefaults,
   saveAppSettings: () => saveAppSettings,
   updateAdvancedSettings: () => updateAdvancedSettings,
@@ -3261,6 +3267,16 @@ function resolveThreadDefaults(settings = loadAppSettings()) {
     fast: getDefaultFast(settings)
   };
 }
+function resolveNewThreadOptions(overrides = {}, settings = loadAppSettings()) {
+  const defaults = resolveThreadDefaults(settings);
+  const effort = overrides.effort === void 0 || overrides.effort === null ? defaults.effort : normalizeThinkingEffort(overrides.effort) ?? defaults.effort;
+  return {
+    agent: overrides.agent ?? defaults.agent,
+    model: overrides.model === void 0 ? defaults.model : overrides.model?.trim() || null,
+    effort,
+    fast: overrides.fast === void 0 || overrides.fast === null ? defaults.fast : Boolean(overrides.fast)
+  };
+}
 function isLinearConnected(settings = loadAppSettings()) {
   return Boolean(settings.integrations.linearApiKey?.trim());
 }
@@ -3280,7 +3296,12 @@ function brightsyCloudConnectEnabled(settings = loadAppSettings()) {
   return Boolean(settings.brightsy.cloudConnectEnabled);
 }
 function brightsyCloudConnectAgent(settings = loadAppSettings()) {
-  return settings.brightsy.cloudConnectAgent ?? "claude";
+  const fallback = settings.brightsy.cloudConnectAgent && CLOUD_CONNECT_AGENTS.has(settings.brightsy.cloudConnectAgent) ? settings.brightsy.cloudConnectAgent : "claude";
+  const preferred = getDefaultAgent(settings);
+  if (CLOUD_CONNECT_AGENTS.has(preferred)) {
+    return preferred;
+  }
+  return fallback;
 }
 function updateAdvancedSettings(patch) {
   const current = loadAppSettings();
@@ -3528,6 +3549,11 @@ function coordinatorGreenfieldPlaybook(reposDir) {
     "- Do coding work in the child worktree thread, not by editing files in this home cwd."
   ].join("\n");
 }
+function accountDefaultsPlaybookLine() {
+  const d = resolveThreadDefaults();
+  const model = d.model?.trim() || "Auto";
+  return `- Account defaults for create_thread (omit agent/model to use these): agent=${d.agent}, model=${model}, effort=${d.effort}`;
+}
 function coordinatorTurnReminder(opts) {
   const goal = opts.goal?.trim();
   return [
@@ -3537,6 +3563,7 @@ function coordinatorTurnReminder(opts) {
     "- Registered workspaces / child threads are the fleet you manage via Sideboard MCP.",
     `- Parent thread id (pass as parentThreadId when creating children): ${opts.parentId}`,
     goal ? `- Goal / title: ${goal}` : null,
+    accountDefaultsPlaybookLine(),
     `- For "what's going on": call list_threads (and list_workspaces if needed). Summarize fleet status \u2014 do not ls/git-status this synthetic home.`,
     "- Existing repo: create_thread on a repoPath \u2192 send_to_thread \u2192 wait_for_turn.",
     "- New repo: Bash (clone or gh repo create under ~/sideboard/repos/<name>) \u2192 add_workspace \u2192 create_thread \u2192 send_to_thread \u2192 wait_for_turn \u2192 draft PR.",
@@ -3559,9 +3586,12 @@ function ensureGlobalCoordinatorCwd() {
     "",
     COORDINATOR_TOOL_PLAYBOOK,
     "",
+    accountDefaultsPlaybookLine(),
+    "",
     coordinatorGreenfieldPlaybook(reposDir),
     "",
     "When creating threads, pass `repoPath` from `list_workspaces` (or the path you just registered) and `parentThreadId` for children.",
+    "Omit `agent` / `model` on `create_thread` unless you have a reason to override Account defaults.",
     "Typical flow (existing): list_workspaces \u2192 list_branches|list_prs|list_issues \u2192 create_thread \u2192 send_to_thread \u2192 wait_for_turn.",
     "Typical flow (new app): Bash create/clone under repos dir \u2192 add_workspace \u2192 create_thread \u2192 send_to_thread (implement) \u2192 wait_for_turn \u2192 draft PR via worktree agent.",
     "Always ask worktree agents to open draft PRs (`send_to_thread` + `gh pr create --draft -R <origin>`); never open PRs from the orchestrator."
@@ -3587,8 +3617,10 @@ function coordinatorSystemPrompt(opts) {
     "You operate across ALL registered workspaces below.",
     "You have no project git home \u2014 this process cwd is synthetic and empty on purpose.",
     COORDINATOR_TOOL_PLAYBOOK,
+    accountDefaultsPlaybookLine(),
     coordinatorGreenfieldPlaybook(reposDir),
     "When creating threads, pass the correct repoPath for the target workspace and parentThreadId for children.",
+    "Omit agent/model on create_thread unless you need to override Account defaults.",
     "Typical flow (existing): list_workspaces \u2192 list_branches|list_prs|list_issues \u2192 create_thread \u2192 send_to_thread (implement) \u2192 wait_for_turn \u2192 send_to_thread (ask for `gh pr create --draft -R <origin-owner/name>` using the workspace github slug) \u2192 wait_for_turn. Never target upstream. Never open PRs from the orchestrator.",
     "Typical flow (new app): Bash under repos dir (clone or gh repo create) \u2192 add_workspace \u2192 create_thread \u2192 send_to_thread \u2192 wait_for_turn \u2192 draft PR via worktree agent.",
     `Goal: ${opts.goal}`,
@@ -3604,6 +3636,7 @@ var init_coordinator_prompt = __esm({
     import_node_fs6 = require("fs");
     import_node_path7 = require("path");
     init_worktree();
+    init_app_settings();
     init_paths();
     COORDINATOR_TOOL_PLAYBOOK = [
       "Role: you oversee Sideboard worktree agents across registered repos. You do not live inside one of those worktrees.",
@@ -3612,12 +3645,12 @@ var init_coordinator_prompt = __esm({
       "- 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)",
       "- get_pr_stack / open_pr_stack_layers / add_stack_layer / create_pr_stack \u2014 GitHub stacked PRs (`gh stack`); one worktree per layer",
-      "- list_models \u2014 only when you need a specific model (rare); otherwise leave model unset = Auto",
+      "- list_models \u2014 only when you need a specific model (rare); otherwise omit model so Account defaults apply",
       "- 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",
+      "- create_thread \u2014 create a worktree + chat from branch | pr | ticket; pass repoPath + parentThreadId; omit agent and model to use Sideboard Account defaults (Settings \u2192 Default agent, model & effort)",
       "- 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",
@@ -3717,7 +3750,13 @@ function createGlobalChat(opts) {
   const explicit = opts.title?.trim();
   const title = explicit && explicit !== CLOUD_ORCHESTRATOR_GOAL ? explicit : allocateTeamName(takenTeamSlugsForOrchestration()).name;
   const sourceRef = opts.sourceRef?.trim() || (isCloud ? CLOUD_ORCHESTRATOR_GOAL : title);
-  const agent = assertOrchestratorCapableAgent(opts.agent);
+  const resolved = resolveNewThreadOptions({
+    agent: opts.agent,
+    model: opts.model,
+    effort: opts.effort,
+    fast: opts.fast
+  });
+  const agent = assertOrchestratorCapableAgent(resolved.agent);
   const thread = createEmptyThread({
     title,
     // Stick nicknames the same way chat tabs do (avoid later sync overwrites).
@@ -3729,9 +3768,9 @@ function createGlobalChat(opts) {
     repoPath: GLOBAL_WORKSPACE_ID,
     agent,
     autonomy: opts.autonomy ?? "default",
-    model: opts.model ?? null,
-    effort: opts.effort ?? "high",
-    fast: Boolean(opts.fast),
+    model: resolved.model,
+    effort: resolved.effort,
+    fast: resolved.fast,
     planMode: Boolean(opts.planMode),
     attachments: opts.attachments ?? [],
     parentThreadId: opts.parentThreadId ?? null,
@@ -3764,20 +3803,35 @@ function findCloudCoordinator() {
   );
 }
 function ensureCloudCoordinator(agent) {
+  const defaults = resolveThreadDefaults();
+  const desired = assertOrchestratorCapableAgent(agent);
   const existing = findCloudCoordinator();
   if (existing) {
+    const patch = {};
     if (existing.repoPath !== GLOBAL_WORKSPACE_ID) {
-      return updateThread(existing.id, {
-        repoPath: GLOBAL_WORKSPACE_ID,
-        worktreePath: globalAgentCwd(),
-        branchName: "global"
-      });
+      patch.repoPath = GLOBAL_WORKSPACE_ID;
+      patch.worktreePath = globalAgentCwd();
+      patch.branchName = "global";
+    }
+    const hasAgentTurns = existing.messages.some((m) => m.role === "agent");
+    const canRetarget = !existing.sessionId && !hasAgentTurns && existing.status !== "running" && existing.status !== "queued";
+    if (canRetarget) {
+      if (existing.agent !== desired) patch.agent = desired;
+      if (existing.model !== defaults.model) patch.model = defaults.model;
+      if (existing.effort !== defaults.effort) patch.effort = defaults.effort;
+      if (existing.fast !== defaults.fast) patch.fast = defaults.fast;
+    }
+    if (Object.keys(patch).length > 0) {
+      return updateThread(existing.id, patch);
     }
     return existing;
   }
   const created = createGlobalChat({
     sourceRef: CLOUD_ORCHESTRATOR_GOAL,
-    agent
+    agent: desired,
+    model: defaults.model,
+    effort: defaults.effort,
+    fast: defaults.fast
   });
   const all = listThreads({ includeArchived: true }).filter(
     (t) => t.status !== "archived" && isCloudCoordinatorThread(t)
@@ -3792,6 +3846,7 @@ var init_global_workspace = __esm({
     init_orchestrator_capable();
     init_teams();
     init_coordinator_prompt();
+    init_app_settings();
     init_paths();
     init_thread_store();
     GLOBAL_WORKSPACE_ID = "__global__";
@@ -4546,6 +4601,7 @@ function toCodexMcpConfigArgs(servers) {
         args.push("-c", `${prefix}.env.${key}=${JSON.stringify(value)}`);
       }
     }
+    args.push("-c", `${prefix}.default_tools_approval_mode=${JSON.stringify("approve")}`);
   }
   return args;
 }
@@ -5054,6 +5110,32 @@ function codexConfigHasNetworkAccess() {
   }
   return false;
 }
+function unwrapCodexMcpResult(result) {
+  if (result == null) return void 0;
+  if (typeof result === "string") return result;
+  if (typeof result !== "object") return String(result);
+  const rec = result;
+  if (Array.isArray(rec.content)) {
+    const texts = [];
+    for (const item of rec.content) {
+      if (!item || typeof item !== "object") continue;
+      const text = item.text;
+      if (typeof text === "string") texts.push(text);
+    }
+    if (texts.length) return texts.join("\n");
+  }
+  try {
+    return JSON.stringify(result);
+  } catch {
+    return String(result);
+  }
+}
+function asRecord(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return void 0;
+}
 var import_node_fs11, import_node_os7, import_node_path11, CODEX_PROMPT_ARG_MAX, FALLBACK_CODEX_MODELS, cachedCodexModels, CODEX_MODEL_CACHE_MS, codexAdapter;
 var init_codex = __esm({
   "src/agents/codex.ts"() {
@@ -5166,15 +5248,49 @@ var init_codex = __esm({
           }
           if (typeof obj.item === "object" && obj.item !== null) {
             const item = obj.item;
-            if (item.type === "error") {
+            const itemType = item.type ?? item.item_type;
+            if (itemType === "error") {
               const detail = item.message?.trim() || extractJsonErrorMessage(obj) || "Codex item error";
               return { type: "stderr", data: detail };
             }
-            if (item.type === "agent_message" && item.text) {
+            if (itemType === "agent_message" && item.text) {
               return { type: "stdout", data: item.text };
             }
+            if (itemType === "mcp_tool_call" && item.id && item.server && item.tool) {
+              const name = `mcp__${item.server}__${item.tool}`;
+              const input = asRecord(item.arguments);
+              const events = [
+                { type: "tool_use", id: item.id, name, input }
+              ];
+              const finished = type === "item.completed" || item.status === "completed" || item.status === "failed";
+              if (finished) {
+                const errMsg = item.error && typeof item.error.message === "string" ? item.error.message : void 0;
+                events.push({
+                  type: "tool_result",
+                  id: item.id,
+                  content: unwrapCodexMcpResult(item.result) ?? errMsg,
+                  isError: item.status === "failed" || Boolean(errMsg)
+                });
+              }
+              return events.length === 1 ? events[0] : events;
+            }
+            if (itemType === "command_execution" && item.id) {
+              const input = item.command ? { command: item.command } : void 0;
+              const events = [
+                { type: "tool_use", id: item.id, name: "Bash", input }
+              ];
+              if (type === "item.completed" || item.status === "completed" || item.status === "failed") {
+                events.push({
+                  type: "tool_result",
+                  id: item.id,
+                  content: item.aggregated_output,
+                  isError: item.status === "failed"
+                });
+              }
+              return events.length === 1 ? events[0] : events;
+            }
             if (item.status === "failed") {
-              const detail = item.message?.trim() || extractJsonErrorMessage(item) || `Codex ${item.type ?? "item"} failed`;
+              const detail = item.message?.trim() || extractJsonErrorMessage(item) || `Codex ${itemType ?? "item"} failed`;
               return { type: "stderr", data: detail };
             }
           }
@@ -5260,6 +5376,75 @@ function usageFromCursor(usage) {
     cacheWriteTokens: usage.cacheWriteTokens ? Number(usage.cacheWriteTokens) : void 0
   };
 }
+function asRecord2(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return void 0;
+}
+function normalizeCursorToolCall(name, args) {
+  const raw = asRecord2(args);
+  const toolName = typeof raw?.toolName === "string" && raw.toolName.trim() ? raw.toolName.trim() : null;
+  const looksLikeMcp = name === "mcp" || toolName != null && (typeof raw?.providerIdentifier === "string" || asRecord2(raw?.args) != null);
+  if (looksLikeMcp && toolName) {
+    const providerRaw = typeof raw.providerIdentifier === "string" && raw.providerIdentifier.trim() ? raw.providerIdentifier.trim() : "sideboard";
+    const provider = providerRaw.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const nested = asRecord2(raw.args);
+    return {
+      name: `mcp__${provider}__${toolName}`,
+      input: nested ?? { toolName }
+    };
+  }
+  return { name, input: raw };
+}
+function unwrapCursorToolResult(result) {
+  if (result == null) return void 0;
+  if (typeof result === "string") return result;
+  const rec = asRecord2(result);
+  if (!rec) {
+    try {
+      return JSON.stringify(result);
+    } catch {
+      return String(result);
+    }
+  }
+  const collectTexts = (items) => {
+    const texts = [];
+    for (const item of items) {
+      const row = asRecord2(item);
+      if (!row) continue;
+      if (typeof row.text === "string") {
+        texts.push(row.text);
+        continue;
+      }
+      const nested = asRecord2(row.text);
+      if (typeof nested?.text === "string") texts.push(nested.text);
+    }
+    return texts;
+  };
+  const value = asRecord2(rec.value);
+  if (value && Array.isArray(value.content)) {
+    const texts = collectTexts(value.content);
+    if (texts.length) return texts.join("\n");
+  }
+  if (Array.isArray(rec.content)) {
+    const texts = collectTexts(rec.content);
+    if (texts.length) return texts.join("\n");
+  }
+  try {
+    return JSON.stringify(result);
+  } catch {
+    return String(result);
+  }
+}
+function cursorToolResultIsError(status, result) {
+  if (status === "error") return true;
+  const rec = asRecord2(result);
+  if (!rec) return false;
+  if (rec.status === "error") return true;
+  const value = asRecord2(rec.value);
+  return value?.isError === true;
+}
 function cursorSdkMessageToEvents(msg) {
   if (!msg?.type) return [];
   if (msg.type === "system" && msg.agent_id) {
@@ -5274,35 +5459,42 @@ function cursorSdkMessageToEvents(msg) {
       if (block?.type === "text" && block.text) {
         out.push({ type: "stdout", data: block.text });
       } else if (block?.type === "tool_use" && block.id && block.name) {
+        const normalized = normalizeCursorToolCall(block.name, block.input);
         out.push({
           type: "tool_use",
           id: block.id,
-          name: block.name,
-          input: block.input && typeof block.input === "object" ? block.input : void 0
+          name: normalized.name,
+          input: normalized.input
         });
       }
     }
     return out;
   }
   if (msg.type === "tool_call" && msg.call_id && msg.name) {
+    const normalized = normalizeCursorToolCall(msg.name, msg.args);
     if (msg.status === "running") {
       return [
         {
           type: "tool_use",
           id: msg.call_id,
-          name: msg.name,
-          input: msg.args && typeof msg.args === "object" ? msg.args : void 0
+          name: normalized.name,
+          input: normalized.input
         }
       ];
     }
     if (msg.status === "completed" || msg.status === "error") {
-      const content = typeof msg.result === "string" ? msg.result : msg.result != null ? JSON.stringify(msg.result) : void 0;
       return [
+        {
+          type: "tool_use",
+          id: msg.call_id,
+          name: normalized.name,
+          input: normalized.input
+        },
         {
           type: "tool_result",
           id: msg.call_id,
-          content,
-          isError: msg.status === "error"
+          content: unwrapCursorToolResult(msg.result),
+          isError: cursorToolResultIsError(msg.status, msg.result)
         }
       ];
     }
@@ -5672,17 +5864,31 @@ var init_opencode = __esm({
             return { type: "stderr", data: detail };
           }
           const sid = typeof obj.sessionID === "string" && obj.sessionID || typeof obj.sessionId === "string" && obj.sessionId || typeof obj.session_id === "string" && obj.session_id;
-          if (sid) return { type: "session_id", data: sid };
+          if (sid && (!obj.type || obj.type === "step_start" || obj.type === "session")) {
+            return { type: "session_id", data: sid };
+          }
           if (obj.type === "text") {
             const text = obj.part?.text ?? obj.text;
             if (text) return { type: "stdout", data: text };
           }
           if (obj.type === "tool_use") {
             const part = obj.part;
-            const id = part?.id ?? obj.id ?? `tool-${Date.now()}`;
-            const name = part?.name ?? part?.tool ?? obj.name ?? obj.tool ?? "tool";
-            const input = part?.input ?? obj.input;
-            return { type: "tool_use", id, name, input };
+            const id = part?.callID ?? part?.id ?? obj.id ?? `tool-${Date.now()}`;
+            const name = part?.tool ?? part?.name ?? obj.tool ?? obj.name ?? "tool";
+            const state = part?.state;
+            const input = (state?.input && typeof state.input === "object" ? state.input : void 0) ?? part?.input ?? obj.input;
+            const events = [{ type: "tool_use", id, name, input }];
+            const output = state?.output;
+            if (output != null || state?.status === "completed" || state?.status === "error") {
+              const content = typeof output === "string" ? output : output != null ? JSON.stringify(output) : formatUnknownDetail(state?.error) || void 0;
+              events.push({
+                type: "tool_result",
+                id,
+                content,
+                isError: state?.status === "error" || state?.status === "failed"
+              });
+            }
+            return events.length === 1 ? events[0] : events;
           }
           if (obj.type === "tool_result") {
             const part = obj.part;
@@ -5710,6 +5916,7 @@ var init_opencode = __esm({
         }
       },
       async resolveSessionId(worktreePath, cached) {
+        const cachedId = cached?.trim() || null;
         const listed = await run(
           "opencode",
           ["session", "list", "--format", "json"],
@@ -5721,15 +5928,21 @@ var init_opencode = __esm({
             if (Array.isArray(sessions) && sessions.length > 0) {
               const norm = (p) => p.replace(/\/+$/, "");
               const wt = norm(worktreePath);
-              const match = sessions.find(
+              const forWorktree = sessions.filter(
                 (s) => s.directory && norm(s.directory) === wt || s.path && norm(s.path) === wt
               );
-              if (match?.id) return match.id;
+              if (cachedId && forWorktree.some((s) => s.id === cachedId)) {
+                return cachedId;
+              }
+              if (cachedId && sessions.some((s) => s.id === cachedId)) {
+                return cachedId;
+              }
+              return null;
             }
           } catch {
           }
         }
-        return cached;
+        return cachedId;
       },
       async buildAttach(thread) {
         const sessionId = await this.resolveSessionId(thread.worktreePath, thread.sessionId);
@@ -6347,7 +6560,7 @@ var init_workspaces = __esm({
 });
 
 // src/plan/plan-present.ts
-function asRecord2(v) {
+function asRecord4(v) {
   return v != null && typeof v === "object" && !Array.isArray(v) ? v : null;
 }
 function isPresentPlanToolName(name) {
@@ -6359,7 +6572,7 @@ function extractPresentedPlan(parts) {
   for (let i = parts.length - 1; i >= 0; i--) {
     const p = parts[i];
     if (p.type !== "tool" || !isPresentPlanToolName(p.name)) continue;
-    const input = asRecord2(p.input) ?? {};
+    const input = asRecord4(p.input) ?? {};
     const content = typeof input.content === "string" ? input.content : typeof input.plan === "string" ? input.plan : typeof input.markdown === "string" ? input.markdown : "";
     if (!content.trim()) continue;
     const title = typeof input.title === "string" && input.title.trim() ? input.title.trim() : "Plan";
@@ -6525,7 +6738,7 @@ init_agents();
 init_orchestrator_capable();
 
 // src/agents/message-parts.ts
-function asRecord(input) {
+function asRecord3(input) {
   if (input && typeof input === "object" && !Array.isArray(input)) {
     return input;
   }
@@ -6660,7 +6873,7 @@ function applyAgentEvent(parts, event) {
     return next;
   }
   if (event.type === "tool_use") {
-    const input = asRecord(event.input);
+    const input = asRecord3(event.input);
     const diff = diffFromInput(input);
     const existing = parts.findIndex((p) => p.type === "tool" && p.id === event.id);
     if (existing >= 0) {
@@ -6694,9 +6907,25 @@ function applyAgentEvent(parts, event) {
     ];
   }
   if (event.type === "tool_result") {
-    const next = parts.map((p) => {
-      if (p.type !== "tool" || p.id !== event.id) return p;
-      const fromResult = parseDiffStat(event.content);
+    const existing = parts.findIndex((p) => p.type === "tool" && p.id === event.id);
+    const fromResult = parseDiffStat(event.content);
+    if (existing < 0) {
+      return [
+        ...parts,
+        {
+          type: "tool",
+          id: event.id,
+          name: "tool",
+          description: "tool",
+          status: event.isError ? "error" : "done",
+          result: event.content,
+          ...fromResult.additions != null ? { additions: fromResult.additions } : {},
+          ...fromResult.deletions != null ? { deletions: fromResult.deletions } : {}
+        }
+      ];
+    }
+    return parts.map((p, i) => {
+      if (i !== existing || p.type !== "tool") return p;
       return {
         ...p,
         status: event.isError ? "error" : "done",
@@ -6705,7 +6934,6 @@ function applyAgentEvent(parts, event) {
         ...fromResult.deletions != null ? { deletions: fromResult.deletions } : {}
       };
     });
-    return next;
   }
   return parts;
 }
@@ -7501,10 +7729,17 @@ async function requireAgent(agent, opts) {
 
 // src/threads/create.ts
 init_worktree();
+init_app_settings();
 init_thread_store();
 init_workspaces();
 async function createThread(input, _onSetupLine) {
-  await requireAgent(input.agent);
+  const resolved = resolveNewThreadOptions({
+    agent: input.agent,
+    model: input.model,
+    effort: input.effort,
+    fast: input.fast
+  });
+  await requireAgent(resolved.agent);
   const repoPath = await resolveRepoRoot(input.repoPath);
   if (!(0, import_node_fs18.existsSync)(repoPath)) {
     throw new Error(`Repo not found: ${repoPath}`);
@@ -7547,11 +7782,11 @@ async function createThread(input, _onSetupLine) {
     branchName,
     worktreePath,
     repoPath,
-    agent: input.agent,
+    agent: resolved.agent,
     autonomy: input.autonomy ?? "default",
-    model: input.model ?? null,
-    effort: input.effort ?? "high",
-    fast: Boolean(input.fast),
+    model: resolved.model,
+    effort: resolved.effort,
+    fast: resolved.fast,
     planMode: Boolean(input.planMode),
     attachments: input.attachments ?? [],
     sourceIsFork,
@@ -10479,21 +10714,30 @@ var Orchestrator = class {
     return findThreadByRef(idOrRef) ?? readThread(idOrRef);
   }
   async createThread(input) {
-    let thread = await createThread(input);
+    const thread = await createThread(input);
     this.emit({ type: "status_changed", threadId: thread.id, status: thread.status });
-    await this.runSetupAfterCreate(thread.id);
+    void this.finishCreateThread(thread.id, input.prompt?.trim() || void 0);
+    return thread;
+  }
+  async finishCreateThread(threadId, prompt) {
+    await this.runSetupAfterCreate(threadId);
     const { autoRunAfterSetupEnabled: autoRunAfterSetupEnabled2 } = await Promise.resolve().then(() => (init_app_settings(), app_settings_exports));
     if (autoRunAfterSetupEnabled2()) {
       try {
-        await this.startDev(thread.id);
+        await this.startDev(threadId);
       } catch {
       }
     }
-    const prompt = input.prompt?.trim();
     if (prompt) {
-      thread = await this.send(thread.id, prompt);
+      try {
+        await this.send(threadId, prompt);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        updateThread(threadId, {
+          lastError: `First prompt failed: ${message}`
+        });
+      }
     }
-    return thread;
   }
   /** Run workspace setup after a new worktree is created (no-op if none configured). */
   async runSetupAfterCreate(threadId) {
@@ -10509,7 +10753,7 @@ var Orchestrator = class {
     }
   }
   listWorkspaces() {
-    const fromThreads = listThreads({ includeArchived: false }).map((t) => t.repoPath);
+    const fromThreads = listThreads({ includeArchived: true }).map((t) => t.repoPath);
     return syncWorkspacesFromThreads(fromThreads);
   }
   async addWorkspace(repoPath) {
@@ -10839,8 +11083,73 @@ var Orchestrator = class {
           }
         }
       }
-      const lastStderr = summarizeTurnStderr(stderrTail);
-      const detail = lastStderr || (exitCode !== 0 ? fallbackTurnFailDetail(assistantText) : "");
+      let lastStderr = summarizeTurnStderr(stderrTail);
+      let detail = lastStderr || (exitCode !== 0 ? fallbackTurnFailDetail(assistantText) : "");
+      if (exitCode !== 0 && !assistantText && parts.length === 0 && !this.stoppedTurns.has(threadId) && looksLikeInvalidAgentSession(detail) && this.requireThread(threadId).sessionId && this.requireThread(threadId).agent !== "cursor" && this.requireThread(threadId).agent !== "brightsy") {
+        updateThread(threadId, { sessionId: null });
+        pushTurnStderr(
+          stderrTail,
+          "Agent session missing \u2014 starting a fresh session"
+        );
+        this.emit({
+          type: "turn_output",
+          threadId,
+          event: {
+            type: "stderr",
+            data: "Agent session missing \u2014 starting a fresh session"
+          }
+        });
+        const retryThread = this.requireThread(threadId);
+        const prior = retryThread.messages.slice(0, -1);
+        const retrySeed = buildSessionSeed(prior);
+        const retryInstructions = retryThread.agent === "claude" ? null : formatAgentInstructions(
+          loadAgentInstructions(retryThread.worktreePath, retryThread.agent)
+        );
+        const retryPrefix = [
+          coordinatorDirective,
+          worktreeDirective,
+          artifactDirective,
+          renameBranchDirective,
+          retryInstructions,
+          retrySeed
+        ].filter(Boolean).join("\n\n---\n\n");
+        const retryHandle = await spawnAgentTurn(
+          retryThread,
+          { cachedPrefix: retryPrefix, prompt: agentPrompt },
+          (event) => {
+            this.emit({ type: "turn_output", threadId, event });
+            if (event.type === "session_id") {
+              updateThread(threadId, { sessionId: event.data });
+            }
+            if (event.type === "stderr" && typeof event.data === "string") {
+              pushTurnStderr(stderrTail, event.data);
+            }
+          }
+        );
+        this.activeTurns.set(threadId, retryHandle);
+        if (typeof retryHandle.pid === "number" && retryHandle.pid > 0) {
+          updateThread(threadId, { agentPid: retryHandle.pid });
+        }
+        this.processes.set(`${threadId}:agent`, {
+          kind: "agent",
+          pid: retryHandle.pid,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          kill: retryHandle.kill
+        });
+        if (this.stoppedTurns.has(threadId)) {
+          retryHandle.kill();
+        }
+        const retryResult = await retryHandle.done;
+        if (retryResult.sessionId) {
+          updateThread(threadId, { sessionId: retryResult.sessionId });
+        }
+        assistantText = retryResult.assistantText.trim();
+        parts = retryResult.parts;
+        usage = retryResult.usage ?? void 0;
+        exitCode = retryResult.exitCode;
+        lastStderr = summarizeTurnStderr(stderrTail);
+        detail = lastStderr || (exitCode !== 0 ? fallbackTurnFailDetail(assistantText) : "");
+      }
       let chatText = assistantText;
       if (exitCode !== 0 && !chatText && looksLikeAgentFailureMessage(detail)) {
         chatText = humanizeAgentFailDetail(detail);
@@ -11544,7 +11853,15 @@ var Orchestrator = class {
       }
       await removeWorktree(thread.repoPath, thread.worktreePath);
     }
-    return setStatus(thread.id, "archived");
+    const archived = setStatus(thread.id, "archived");
+    if (thread.repoPath && !isGlobalRepoPath(thread.repoPath)) {
+      try {
+        const { ensureWorkspace: ensureWorkspace2 } = await Promise.resolve().then(() => (init_workspaces(), workspaces_exports));
+        await ensureWorkspace2(thread.repoPath);
+      } catch {
+      }
+    }
+    return archived;
   }
   async purge(threadRef, opts) {
     const thread = this.requireThread(threadRef);
@@ -11966,13 +12283,19 @@ async function startMcpServer() {
       return { content: [{ type: "text", text: JSON.stringify(payload) }] };
     }
   );
+  const { resolveNewThreadOptions: resolveNewThreadOptions2, resolveThreadDefaults: resolveThreadDefaults2 } = await Promise.resolve().then(() => (init_app_settings(), app_settings_exports));
+  const accountDefaults = resolveThreadDefaults2();
+  const accountDefaultsHint = `Account defaults: agent=${accountDefaults.agent}, model=${accountDefaults.model?.trim() || "Auto"}, effort=${accountDefaults.effort}`;
   server.tool(
     "create_thread",
-    "Create a new worktree thread (chat) from branch, pr, or ticket. Pass repoPath from list_workspaces and parentThreadId when spawning from an orchestrator. Then use send_to_thread to chat.",
+    `Create a new worktree thread (chat) from branch, pr, or ticket. Pass repoPath from list_workspaces and parentThreadId when spawning from an orchestrator. Prefer omitting agent/model so Sideboard applies ${accountDefaultsHint}. Then use send_to_thread to chat.`,
     {
       sourceType: import_zod.z.enum(["branch", "pr", "ticket"]),
       sourceRef: import_zod.z.string(),
-      agent: import_zod.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]),
+      agent: import_zod.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]).optional().describe(`Omit to use Account default agent (${accountDefaults.agent})`),
+      model: import_zod.z.string().nullable().optional().describe(
+        `Usually omit to use Account default model (${accountDefaults.model?.trim() || "Auto"}). Pass null only to force Auto / agent-default.`
+      ),
       repoPath: import_zod.z.string(),
       title: import_zod.z.string().optional(),
       parentThreadId: import_zod.z.string().optional()
@@ -11992,10 +12315,17 @@ async function startMcpServer() {
           };
         }
       }
+      const opts = resolveNewThreadOptions2({
+        agent: args.agent,
+        model: args.model
+      });
       const thread = await orch.createThread({
         sourceType: args.sourceType,
         sourceRef: args.sourceRef,
-        agent: args.agent,
+        agent: opts.agent,
+        model: opts.model,
+        effort: opts.effort,
+        fast: opts.fast,
         repoPath: args.repoPath,
         title: args.title,
         parentThreadId: args.parentThreadId ?? null
@@ -12009,6 +12339,8 @@ async function startMcpServer() {
               title: thread.title,
               branchName: thread.branchName,
               worktreePath: thread.worktreePath,
+              agent: thread.agent,
+              model: thread.model,
               status: thread.status,
               link: `sideboard://thread/${thread.id}`
             })