@sideboard-ai/core 0.1.125 → 0.1.130

package/dist/mcp/run-stdio.js

@@ -2,11 +2,22 @@
 
 import {
   AGENT_GIT_ACTIONS,
+  BOARD_COLUMN_DEFS,
+  HOME_BOARD_AGENT_HINT,
+  HOME_BOARD_CACHE_TTL_MS,
+  assembleHomeBoard,
   createSchedule,
+  dedupeBoardIssues,
+  dedupeBoardPrs,
   deleteSchedule,
+  findBoardIssue,
+  findBoardPin,
+  findBoardPr,
+  findLiveThreadForCreate,
   fireSchedule,
   getOrchestrator,
   getSchedule,
+  issueNeedsWorkspacePick,
   listLinearIssues,
   listSchedules,
   listSlackOutboundWatches,
@@ -18,30 +29,32 @@ import {
   resolveScheduleThreadId,
   slackApi,
   slackTokenFor,
+  syncBoardPins,
   updateSchedule
-} from "../chunk-GKY2GR2J.js";
+} from "../chunk-FMBLOOAO.js";
 import {
   listModelsForAgent,
   sideboardMcpProfile
-} from "../chunk-JNAIKICO.js";
+} from "../chunk-ZMUOPTKZ.js";
 import "../chunk-YMRT2DU6.js";
-import "../chunk-RBVVWBVB.js";
+import "../chunk-SYLTXDRF.js";
 import "../chunk-N5PM7HGQ.js";
 import "../chunk-KLBOWJ74.js";
 import {
   GLOBAL_WORKSPACE_ID,
   isCloudCoordinatorThread
-} from "../chunk-O43IRQ2Y.js";
-import "../chunk-TRTWH6C2.js";
+} from "../chunk-MNL4FSKY.js";
+import "../chunk-RSFCB23A.js";
 import {
+  canonicalizeRepoPath,
   listBranches,
   listPrs,
   resolveGithubRepoSlug,
   resolveRepoRoot,
   warmGithubAgentAuth
-} from "../chunk-OHEFHIG3.js";
+} from "../chunk-HRSBZIXS.js";
 import "../chunk-B3SJXYIJ.js";
-import "../chunk-RG737OWT.js";
+import "../chunk-G6X6UFJO.js";
 import {
   gh
 } from "../chunk-KPIYENTF.js";
@@ -52,15 +65,18 @@ import {
   loadAppSettings,
   resolveEffectiveIssueSource,
   saveLinearOAuth
-} from "../chunk-BMIRX64H.js";
+} from "../chunk-ZND6XV6J.js";
 import "../chunk-NSTQ6QKD.js";
 import "../chunk-KGZBYWZ3.js";
-import "../chunk-BD2ICC4D.js";
+import {
+  appDataDir
+} from "../chunk-BD2ICC4D.js";
 
 // src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z as z4 } from "zod";
+import { randomUUID as randomUUID2 } from "crypto";
 import { basename } from "path";
 
 // src/http/fetch.ts
@@ -185,6 +201,16 @@ async function getLinearAuthToken(settings = loadAppSettings()) {
 
 // src/integrations/linear.ts
 var LINEAR_GRAPHQL = "https://api.linear.app/graphql";
+var LIST_ISSUE_FIELDS = `
+  id
+  identifier
+  title
+  url
+  assignee { id name }
+  team { id key }
+  labels(first: 10) { nodes { name } }
+  cycle { name number startsAt endsAt completedAt }
+`;
 var ISSUE_FIELDS = `
   id
   identifier
@@ -194,18 +220,21 @@ var ISSUE_FIELDS = `
   priority
   state { id name type }
   assignee { id name }
-  team { id key name states { nodes { id name type } } }
-  labels { nodes { name } }
+  team { id key name states(first: 50) { nodes { id name type } } }
+  labels(first: 50) { nodes { name } }
+  cycle { name number startsAt endsAt completedAt }
 `;
 var ASSIGNED_ISSUES_QUERY = `
 query SideboardAssignedIssues($first: Int!) {
   viewer {
+    id
+    name
     assignedIssues(
       first: $first
       orderBy: updatedAt
       filter: { state: { type: { nin: ["completed", "canceled"] } } }
     ) {
-      nodes { ${ISSUE_FIELDS} }
+      nodes { ${LIST_ISSUE_FIELDS} }
     }
   }
 }
@@ -218,7 +247,7 @@ query SideboardTeams {
       id
       key
       name
-      states { nodes { id name type } }
+      states(first: 50) { nodes { id name type } }
     }
   }
 }
@@ -302,6 +331,25 @@ function mapState(node) {
     type: String(node.type ?? "")
   };
 }
+function linearCycleIsActive(cycle, now = Date.now()) {
+  if (!cycle) return false;
+  if (cycle.completedAt) return false;
+  const start = cycle.startsAt ? Date.parse(cycle.startsAt) : Number.NaN;
+  const end = cycle.endsAt ? Date.parse(cycle.endsAt) : Number.NaN;
+  if (Number.isFinite(start) && now < start) return false;
+  if (Number.isFinite(end) && now > end) return false;
+  return true;
+}
+function mapCycle(node) {
+  if (!node?.name && node?.number == null) return null;
+  const name = String(node.name ?? (node.number != null ? `Cycle ${node.number}` : "")).trim();
+  if (!name) return null;
+  return {
+    name,
+    number: typeof node.number === "number" ? node.number : void 0,
+    isActive: linearCycleIsActive(node)
+  };
+}
 function mapIssue(node) {
   const team = node.team;
   return {
@@ -319,7 +367,8 @@ function mapIssue(node) {
       name: String(team.name ?? ""),
       states: (team.states?.nodes ?? []).map((s) => mapState(s)).filter((s) => Boolean(s))
     } : void 0,
-    labels: (node.labels?.nodes ?? []).map((l) => l.name).filter((n) => Boolean(n))
+    labels: (node.labels?.nodes ?? []).map((l) => l.name).filter((n) => Boolean(n)),
+    cycle: mapCycle(node.cycle)
   };
 }
 function toIssueInfo(issue) {
@@ -329,7 +378,11 @@ function toIssueInfo(issue) {
     title: issue.title,
     url: issue.url,
     labels: issue.labels,
-    provider: "linear"
+    provider: "linear",
+    assignee: issue.assignee?.name,
+    assignees: issue.assignee?.name ? [issue.assignee.name] : void 0,
+    cycle: issue.cycle ?? null,
+    teamKey: issue.team?.key || void 0
   };
 }
 function mapTeam(node) {
@@ -371,10 +424,18 @@ function normalizePriority(priority) {
   }
   return priority;
 }
-async function listLinearIssuesDirect(opts) {
-  const first = Math.max(1, Math.min(100, opts?.limit ?? 50));
+async function listLinearAssignedIssues(opts) {
+  const first = Math.max(1, Math.min(250, opts?.limit ?? 200));
   const json = await linearGraphql(ASSIGNED_ISSUES_QUERY, { first }, opts);
-  return (json.viewer?.assignedIssues?.nodes ?? []).map((node) => toIssueInfo(mapIssue(node)));
+  return {
+    viewer: {
+      id: String(json.viewer?.id ?? ""),
+      name: String(json.viewer?.name ?? "")
+    },
+    issues: (json.viewer?.assignedIssues?.nodes ?? []).map(
+      (node) => toIssueInfo(mapIssue(node))
+    )
+  };
 }
 async function listLinearTeams(opts) {
   const json = await linearGraphql(TEAMS_QUERY, void 0, opts);
@@ -483,13 +544,13 @@ async function commentLinearIssue(input, opts) {
 
 // src/integrations/issues.ts
 async function listGitHubIssues(repoPath, opts) {
-  const limit = Math.max(1, Math.min(100, opts?.limit ?? 50));
+  const limit = Math.max(1, Math.min(1e3, opts?.limit ?? 200));
   const slug = await resolveGithubRepoSlug(repoPath);
   const args = [
     "issue",
     "list",
     "--json",
-    "number,title,url,labels",
+    "number,title,url,labels,assignees",
     "--limit",
     String(limit),
     "--state",
@@ -512,27 +573,55 @@ async function listGitHubIssues(repoPath, opts) {
     const labels = (item.labels ?? []).map(
       (l) => typeof l === "string" ? l : String(l?.name ?? "")
     ).filter(Boolean);
+    const assignees = (item.assignees ?? []).map((a) => typeof a === "string" ? a : String(a?.login ?? "")).map((login) => login.trim()).filter(Boolean);
     return {
       id: Number.isFinite(number) ? `gh-${number}` : identifier,
       identifier,
       title: String(item.title ?? ""),
       url: String(item.url ?? ""),
       labels,
-      provider: "github"
+      provider: "github",
+      assignee: assignees[0],
+      assignees
     };
   });
 }
+async function githubViewerLogin(repoPath) {
+  const { stdout, exitCode } = await gh(["api", "user", "--jq", ".login"], repoPath, {
+    reject: false
+  });
+  if (exitCode !== 0) return "";
+  return stdout.trim();
+}
 async function listIssues(repoPath) {
   const settings = loadAppSettings();
   const preferredSource = settings.integrations.issueSource ?? "github";
   const linearConnected = isLinearConnected(settings);
   const source = resolveEffectiveIssueSource(settings);
   if (source === "linear") {
-    const issues2 = await listLinearIssuesDirect();
-    return { source, preferredSource, linearConnected, issues: issues2 };
+    const listed = await listLinearAssignedIssues();
+    return {
+      source,
+      preferredSource,
+      linearConnected,
+      issues: listed.issues,
+      viewer: {
+        login: listed.viewer.name,
+        name: listed.viewer.name
+      }
+    };
   }
-  const issues = await listGitHubIssues(repoPath);
-  return { source, preferredSource, linearConnected, issues };
+  const [issues, login] = await Promise.all([
+    listGitHubIssues(repoPath),
+    githubViewerLogin(repoPath)
+  ]);
+  return {
+    source,
+    preferredSource,
+    linearConnected,
+    issues,
+    viewer: login ? { login } : void 0
+  };
 }
 
 // src/mcp/archive-guard.ts
@@ -1315,6 +1404,221 @@ function registerScheduleTools(server) {
   );
 }
 
+// src/board/load-home-board.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/board/board-pins.ts
+import { randomUUID } from "crypto";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { join } from "path";
+var FILE = "home-board-pins.json";
+var VERSION = 1;
+function pinsFile() {
+  return join(appDataDir(), FILE);
+}
+function readDisk() {
+  const path = pinsFile();
+  if (!existsSync(path)) return [];
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf8"));
+    if (raw?.version !== VERSION || !Array.isArray(raw.items)) return [];
+    return raw.items.filter((item) => item?.id && item.kind && item.ref);
+  } catch {
+    return [];
+  }
+}
+function writeDisk(items) {
+  mkdirSync(appDataDir(), { recursive: true });
+  writeFileSync(pinsFile(), JSON.stringify({ version: VERSION, items }, null, 2), "utf8");
+}
+function listBoardPins() {
+  return readDisk();
+}
+function replaceBoardPins(items) {
+  writeDisk(items);
+}
+
+// src/board/load-home-board.ts
+var CACHE_VERSION = 1;
+var memory = null;
+var inflight = null;
+function errText(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function homeBoardWorkspaceKey(workspaces) {
+  return workspaces.map((w) => w.path).filter(Boolean).sort().join("\n");
+}
+function cacheFile() {
+  return join2(appDataDir(), "home-board-cache.json");
+}
+function emptyInputs() {
+  return {
+    issues: [],
+    prs: [],
+    issueSource: "github",
+    viewerLogin: void 0,
+    issueErrors: [],
+    prErrors: []
+  };
+}
+function asLoaded(entry, fromCache) {
+  const pins = syncBoardPins(listBoardPins(), entry.inputs.issues, entry.inputs.prs);
+  return { ...entry.inputs, fetchedAt: entry.fetchedAt, fromCache, pins };
+}
+function cacheStillFresh(entry, key, now) {
+  return entry.workspaceKey === key && now - entry.fetchedAt < HOME_BOARD_CACHE_TTL_MS;
+}
+function shouldCacheHomeBoardInputs(inputs) {
+  const issuesFailed = inputs.issues.length === 0 && inputs.issueErrors.length > 0;
+  const prsFailed = inputs.prs.length === 0 && inputs.prErrors.length > 0;
+  return !(issuesFailed && prsFailed);
+}
+function readDiskCache() {
+  const path = cacheFile();
+  if (!existsSync2(path)) return null;
+  try {
+    const raw = JSON.parse(readFileSync2(path, "utf8"));
+    if (raw?.version !== CACHE_VERSION || typeof raw.fetchedAt !== "number") {
+      return null;
+    }
+    if (!raw.inputs || !Array.isArray(raw.inputs.issues) || !Array.isArray(raw.inputs.prs)) {
+      return null;
+    }
+    return raw;
+  } catch {
+    return null;
+  }
+}
+function writeDiskCache(entry) {
+  try {
+    mkdirSync2(appDataDir(), { recursive: true });
+    writeFileSync2(cacheFile(), JSON.stringify(entry), "utf8");
+  } catch {
+  }
+}
+async function loadHomeBoardInputs(workspaces) {
+  const paths = workspaces.map((w) => w.path).filter(Boolean);
+  if (paths.length === 0) return emptyInputs();
+  const issueErrors = [];
+  const prErrors = [];
+  let issueSource = "github";
+  let viewerLogin;
+  let issues = [];
+  try {
+    const first = await listIssues(paths[0]);
+    issueSource = first.source;
+    viewerLogin = first.viewer?.login || first.viewer?.name || void 0;
+    if (first.source === "linear") {
+      const repoPath = paths[0] ?? "";
+      issues = first.issues.map((issue) => ({
+        ...issue,
+        repoPath,
+        needsWorkspacePick: issueNeedsWorkspacePick(
+          issue.provider ?? first.source,
+          paths.length
+        )
+      }));
+    } else {
+      const settled = await Promise.allSettled(
+        paths.map(async (path) => {
+          const result = path === paths[0] ? first : await listIssues(path);
+          return result.issues.map((issue) => ({
+            ...issue,
+            repoPath: path,
+            needsWorkspacePick: issueNeedsWorkspacePick(
+              issue.provider ?? result.source,
+              1
+            )
+          }));
+        })
+      );
+      const collected = [];
+      for (const item of settled) {
+        if (item.status === "fulfilled") collected.push(...item.value);
+        else issueErrors.push(errText(item.reason));
+      }
+      issues = collected;
+      if (collected.length === 0 && issueErrors[0]) {
+        throw new Error(issueErrors[0]);
+      }
+    }
+    issues = dedupeBoardIssues(issues);
+  } catch (err) {
+    issueErrors.push(errText(err));
+    issues = [];
+  }
+  let prs = [];
+  try {
+    const settled = await Promise.allSettled(
+      paths.map(async (path) => {
+        const list = await listPrs(path);
+        return list.map((pr) => ({ ...pr, repoPath: path }));
+      })
+    );
+    const collected = [];
+    for (const item of settled) {
+      if (item.status === "fulfilled") collected.push(...item.value);
+      else prErrors.push(errText(item.reason));
+    }
+    if (collected.length === 0 && prErrors[0]) {
+      throw new Error(prErrors[0]);
+    }
+    prs = dedupeBoardPrs(collected);
+  } catch (err) {
+    prErrors.push(errText(err));
+    prs = [];
+  }
+  return { issues, prs, issueSource, viewerLogin, issueErrors, prErrors };
+}
+async function getHomeBoardInputs(workspaces, opts) {
+  const key = homeBoardWorkspaceKey(workspaces);
+  const now = opts?.now ?? Date.now();
+  if (!key) {
+    return {
+      ...emptyInputs(),
+      fetchedAt: now,
+      fromCache: false,
+      pins: listBoardPins()
+    };
+  }
+  if (!opts?.refresh) {
+    const disk = readDiskCache();
+    const best = memory && disk ? disk.fetchedAt >= memory.fetchedAt ? disk : memory : memory ?? disk;
+    if (best && cacheStillFresh(best, key, now)) {
+      memory = best;
+      return asLoaded(best, true);
+    }
+  }
+  if (inflight && inflight.key === key) {
+    return inflight.promise;
+  }
+  const promise = (async () => {
+    const inputs = await loadHomeBoardInputs(workspaces);
+    const fetchedAt = opts?.now ?? Date.now();
+    const pins = syncBoardPins(listBoardPins(), inputs.issues, inputs.prs);
+    replaceBoardPins(pins);
+    const loaded = { ...inputs, fetchedAt, fromCache: false, pins };
+    if (shouldCacheHomeBoardInputs(inputs)) {
+      const entry = {
+        version: CACHE_VERSION,
+        workspaceKey: key,
+        fetchedAt,
+        inputs
+      };
+      memory = entry;
+      writeDiskCache(entry);
+    }
+    return loaded;
+  })();
+  inflight = { key, promise };
+  try {
+    return await promise;
+  } finally {
+    if (inflight?.promise === promise) inflight = null;
+  }
+}
+
 // src/mcp/server.ts
 var MAX_ORCH_THREADS = 5;
 var CREATE_THREAD_TIMEOUT_MS = 9e4;
@@ -1335,6 +1639,93 @@ function withTimeout(promise, ms, label) {
     );
   });
 }
+async function createOrchChildThread(orch, args, resolveNewThreadOptions) {
+  const envParentId = process.env.SIDEBOARD_ORCHESTRATOR_THREAD_ID?.trim() || "";
+  let parentId = args.parentThreadId?.trim() || "";
+  let parent = parentId ? orch.getThread(parentId) : null;
+  let parentCorrectedFrom;
+  if (envParentId) {
+    const envParent = orch.getThread(envParentId);
+    if (envParent) {
+      if (parentId && parentId !== envParentId) parentCorrectedFrom = parentId;
+      else if (!parentId) parentCorrectedFrom = void 0;
+      parentId = envParentId;
+      parent = envParent;
+    }
+  }
+  if (parentId && !parent) {
+    parentCorrectedFrom = parentId;
+    parentId = "";
+    parent = null;
+  }
+  if (parentId) {
+    const children = orch.getThreads(false).filter((t) => t.parentThreadId === parentId);
+    if (children.length >= MAX_ORCH_THREADS) {
+      return {
+        ok: false,
+        text: `Thread-creation cap (${MAX_ORCH_THREADS}) reached for this orchestration session`
+      };
+    }
+  }
+  let agentArg = args.agent;
+  let agentCoercedFrom;
+  const resolvedProbe = resolveNewThreadOptions({ agent: agentArg }).agent;
+  if (resolvedProbe === "codex") {
+    agentCoercedFrom = agentArg ?? "codex";
+    const accountAgent = resolveNewThreadOptions({}).agent;
+    agentArg = accountAgent !== "codex" ? accountAgent : "cursor";
+  }
+  const opts = resolveNewThreadOptions({
+    agent: agentArg,
+    model: args.model
+  });
+  try {
+    const priorIds = new Set(orch.getThreads(false).map((t) => t.id));
+    const thread = await withTimeout(
+      orch.createThread({
+        sourceType: args.sourceType,
+        sourceRef: args.sourceRef,
+        agent: opts.agent,
+        model: opts.model,
+        effort: opts.effort,
+        fast: opts.fast,
+        repoPath: args.repoPath,
+        title: args.title,
+        parentThreadId: parentId || null,
+        cowboy: args.cowboy || void 0,
+        attachments: args.attachments
+      }),
+      CREATE_THREAD_TIMEOUT_MS,
+      "create_thread"
+    );
+    const alreadyStarted = priorIds.has(thread.id);
+    const parentNote = parentCorrectedFrom ? parentId ? `Ignored unknown/stale parentThreadId ${parentCorrectedFrom}; nested under ${parentId}` : `Ignored unknown/stale parentThreadId ${parentCorrectedFrom}; created without parent` : void 0;
+    return {
+      ok: true,
+      text: JSON.stringify({
+        id: thread.id,
+        title: thread.title,
+        branchName: thread.branchName,
+        worktreePath: thread.worktreePath,
+        agent: thread.agent,
+        model: thread.model,
+        status: thread.status,
+        cowboy: Boolean(thread.cowboy),
+        link: `sideboard://thread/${thread.id}`,
+        parentThreadId: thread.parentThreadId,
+        ...alreadyStarted ? { alreadyStarted: true } : {},
+        ...agentCoercedFrom ? {
+          agentCoercedFrom,
+          note: `Avoid nested Codex under a Codex orchestrator \u2014 used Account default agent=${thread.agent}`
+        } : {},
+        ...parentCorrectedFrom ? { parentCorrectedFrom, parentNote } : {}
+      })
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, text: `create_thread failed: ${message}` };
+  }
+}
 async function startMcpServer() {
   const orch = getOrchestrator();
   try {
@@ -1346,7 +1737,7 @@ async function startMcpServer() {
     );
   }
   try {
-    const { maxConcurrentAgents } = await import("../app-settings-IKFWZDUK.js");
+    const { maxConcurrentAgents } = await import("../app-settings-E7NEQY7D.js");
     orch.setMaxConcurrent(maxConcurrentAgents());
   } catch {
   }
@@ -1366,7 +1757,7 @@ async function startMcpServer() {
   if (!worktreeProfile) {
     server.tool(
       "list_workspaces",
-      "List registered Sideboard workspaces (repos). Each line is name, path, and github:owner/repo when resolvable \u2014 use path as repoPath for list_branches/list_prs/list_issues/create_thread.",
+      "List registered Sideboard workspaces (repos). Each line is name, path, and github:owner/repo when resolvable \u2014 use path as repoPath for list_board/list_branches/list_prs/list_issues/create_thread.",
       {},
       async () => {
         const workspaces = orch.listWorkspaces();
@@ -1400,6 +1791,51 @@ async function startMcpServer() {
         };
       }
     );
+    server.tool(
+      "list_board",
+      "Home Kanban of worktrees (New, Draft, Review, Merged) \u2014 one card per checkout; sibling chat tabs nest as inner cards. Same cards as desktop Home. Path to merge: no PR \u2192 draft PR \u2192 open PR \u2192 merged. Archive removes the card to Settings \u2192 History. Queued/running are activity on the card, not columns. Orchestration chats are not on the board. Filters: query, repoPath, kind (ticket/PR/branch source), column, limit (default 40). create_thread adds a worktree (and a Home card), or returns the live one if that ticket/PR/named branch is already checked out.",
+      {
+        query: z4.string().optional().describe("Case-insensitive token search across title, id, labels, repo"),
+        repoPath: z4.string().optional().describe("Limit to one workspace path from list_workspaces"),
+        kind: z4.enum(["all", "tickets", "prs", "branches", "threads"]).optional().describe("Filter by worktree source (default all)"),
+        column: z4.enum(["new", "draft", "review", "done", "needs_you"]).optional().describe(
+          "Return cards for this column only (totals still include the rest). needs_you is a legacy alias for new."
+        ),
+        limit: z4.number().int().positive().optional().describe("Max cards per column (default 40). hidden counts the remainder.")
+      },
+      async ({ query, repoPath, kind, column, limit }) => {
+        const workspaces = orch.listWorkspaces();
+        const all = orch.getThreads(true);
+        const names = new Map(workspaces.map((w) => [w.path, w.name]));
+        const snap = assembleHomeBoard({
+          threads: all.filter((t) => t.status !== "archived"),
+          query,
+          repoPath,
+          kind: kind ?? "all",
+          column: column === "needs_you" ? "new" : column,
+          limit,
+          workspaceName: (path) => names.get(path) ?? ""
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  columns: snap.columns,
+                  hidden: snap.hidden,
+                  totals: snap.totals,
+                  columnDefs: BOARD_COLUMN_DEFS,
+                  hint: HOME_BOARD_AGENT_HINT
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    );
     server.tool(
       "get_thread",
       "Get a compact thread summary by id/ref. While running, includes progress (last tool/thinking) and lastActivityAt. Includes usage (thread billed token + costUsd totals when providers reported cost) and lastTurnUsage.",
@@ -1438,25 +1874,31 @@ async function startMcpServer() {
   }
   server.tool(
     "present_artifact",
-    "Show an HTML, SVG, markdown, or React document in Sideboard\u2019s Claude-style side column (desktop). Use instead of claude.ai\u2019s artifact tool \u2014 pass the full document content. Do not also emit the same document as a chat html/markdown fence. Prefer type=html for interactive pages. For type=react, pass a single component module that `export default`s a component (JSX/TSX ok) \u2014 Sideboard bootstraps React/ReactDOM/Babel and renders it; only `react`/`react-dom` imports are available, no other npm packages.",
+    "Show a document or live log in Sideboard\u2019s side column. For html/svg/markdown/react, pass the FULL document and do not also fence that same body in chat. For type=log, pass only NEW lines (same artifact_id appends). Prefer type=log for long-running job output \u2014 do not resend HTML. type=react is a single default-export component (JSX/TSX); only react/react-dom imports.",
     {
       title: z4.string().describe("Short title shown in the artifact pane header"),
-      type: z4.enum(["html", "svg", "markdown", "react"]).describe(
-        "Artifact kind \u2014 html opens an iframe preview; react transpiles and renders a default-exported component in a sandboxed iframe"
+      type: z4.enum(["html", "svg", "markdown", "react", "log"]).describe(
+        "html/svg/markdown/react replace the pane. log appends content to the same artifact_id (new lines only)."
       ),
       content: z4.string().describe(
-        "Full document body (complete HTML page, SVG markup, markdown, or a React component module with a default export)"
+        "html/svg/markdown/react: full document. log: only the new lines since the last call (empty is ok for a status-only update)."
       ),
-      artifact_id: z4.string().optional().describe("Stable id when updating the same artifact across turns")
+      artifact_id: z4.string().optional().describe("Stable id. Required for type=log so later calls append to the same pane."),
+      status: z4.enum(["running", "ok", "failed", "idle"]).optional().describe("Log header pill: running (working), ok (done), failed, idle"),
+      phase: z4.string().optional().describe("Log subtitle (Signing, Notarizing, \u2026)"),
+      mode: z4.enum(["append", "replace"]).optional().describe("log only: append (default) or replace the buffer")
     },
-    async ({ title, type, artifact_id }) => {
+    async ({ title, type, artifact_id, status, phase, mode }) => {
       const id = artifact_id?.trim() || `artifact_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
       const payload = {
         ok: true,
         artifact_id: id,
         title,
         type,
-        message: "Artifact accepted. Sideboard desktop opens it in the side column beside chat."
+        status,
+        phase,
+        mode: type === "log" ? mode ?? "append" : void 0,
+        message: type === "log" ? "Log accepted. Same artifact_id appends; send only new lines next time." : "Artifact accepted. Sideboard desktop opens it in the side column beside chat."
       };
       return { content: [{ type: "text", text: JSON.stringify(payload) }] };
     }
@@ -1569,7 +2011,7 @@ async function startMcpServer() {
     registerLinearTools(server);
     registerScheduleTools(server);
     const { getCaffeinateHold, setCaffeinateHold } = await import("../caffeinate-hold-NBRUWYXO.js");
-    const { resolveNewThreadOptions, resolveThreadDefaults } = await import("../app-settings-IKFWZDUK.js");
+    const { resolveNewThreadOptions, resolveThreadDefaults } = await import("../app-settings-E7NEQY7D.js");
     const accountDefaults = resolveThreadDefaults();
     const accountDefaultsHint = `Account defaults: agent=${accountDefaults.agent}, model=${accountDefaults.model?.trim() || "Auto"}, effort=${accountDefaults.effort}`;
     server.tool(
@@ -1612,7 +2054,7 @@ async function startMcpServer() {
     );
     server.tool(
       "create_thread",
-      `Create a new worktree thread (chat) from branch, pr, or ticket. Pass repoPath from list_workspaces. cowboy=true uses the project folder on the default branch (no isolated worktree; land is commit+push). From an orchestration chat, omit parentThreadId (Sideboard binds the child to this chat) or pass the exact id from the turn reminder \u2014 never invent a uuid. Prefer omitting agent/model so Sideboard applies ${accountDefaultsHint}. Setup (settings.toml, .cursor/worktrees.json, or script/setup) runs in the background in parallel with the first turn (skipped for cowboy). Then use send_to_thread to chat.`,
+      `Create a worktree thread (chat) from branch, pr, or ticket. If a live worktree already matches that ticket, PR, or named branch, returns it (alreadyStarted=true) instead of a second checkout. Creating from the default branch still opens a new isolated worktree. Pass repoPath from list_workspaces. cowboy=true uses the project folder on the default branch (no isolated worktree; land is commit+push). From an orchestration chat, omit parentThreadId (Sideboard binds the child to this chat) or pass the exact id from the turn reminder \u2014 never invent a uuid. Prefer omitting agent/model so Sideboard applies ${accountDefaultsHint}. Setup (settings.toml, .cursor/worktrees.json, or script/setup) runs in the background in parallel with the first turn (skipped for cowboy). Then use send_to_thread to chat.`,
       {
         sourceType: z4.enum(["branch", "pr", "ticket"]),
         sourceRef: z4.string(),
@@ -1630,104 +2072,118 @@ async function startMcpServer() {
         )
       },
       async (args) => {
-        const envParentId = process.env.SIDEBOARD_ORCHESTRATOR_THREAD_ID?.trim() || "";
-        let parentId = args.parentThreadId?.trim() || "";
-        let parent = parentId ? orch.getThread(parentId) : null;
-        let parentCorrectedFrom;
-        if (envParentId) {
-          const envParent = orch.getThread(envParentId);
-          if (envParent) {
-            if (parentId && parentId !== envParentId) parentCorrectedFrom = parentId;
-            else if (!parentId) parentCorrectedFrom = void 0;
-            parentId = envParentId;
-            parent = envParent;
-          }
-        }
-        if (parentId && !parent) {
-          parentCorrectedFrom = parentId;
-          parentId = "";
-          parent = null;
-        }
-        if (parentId) {
-          const children = orch.getThreads(false).filter((t) => t.parentThreadId === parentId);
-          if (children.length >= MAX_ORCH_THREADS) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Thread-creation cap (${MAX_ORCH_THREADS}) reached for this orchestration session`
-                }
-              ],
-              isError: true
-            };
-          }
-        }
-        let agentArg = args.agent;
-        let agentCoercedFrom;
-        const resolvedProbe = resolveNewThreadOptions({ agent: agentArg }).agent;
-        if (resolvedProbe === "codex") {
-          agentCoercedFrom = agentArg ?? "codex";
-          const accountAgent = resolveNewThreadOptions({}).agent;
-          agentArg = accountAgent !== "codex" ? accountAgent : "cursor";
-        }
-        const opts = resolveNewThreadOptions({
-          agent: agentArg,
-          model: args.model
-        });
-        try {
-          const thread = await withTimeout(
-            orch.createThread({
-              sourceType: args.sourceType,
-              sourceRef: args.sourceRef,
-              agent: opts.agent,
-              model: opts.model,
-              effort: opts.effort,
-              fast: opts.fast,
-              repoPath: args.repoPath,
-              title: args.title,
-              parentThreadId: parentId || null,
-              cowboy: args.cowboy || void 0
-            }),
-            CREATE_THREAD_TIMEOUT_MS,
-            "create_thread"
-          );
-          const parentNote = parentCorrectedFrom ? parentId ? `Ignored unknown/stale parentThreadId ${parentCorrectedFrom}; nested under ${parentId}` : `Ignored unknown/stale parentThreadId ${parentCorrectedFrom}; created without parent` : void 0;
+        const result = await createOrchChildThread(orch, args, resolveNewThreadOptions);
+        return {
+          content: [{ type: "text", text: result.text }],
+          ...result.ok ? {} : { isError: true }
+        };
+      }
+    );
+    server.tool(
+      "start_board_card",
+      "Same as create_thread for a ticket, PR, or named branch (attaches issue text when Sideboard can resolve it). Reuses the live worktree if one already matches. Then send_to_thread.",
+      {
+        kind: z4.enum(["ticket", "pr", "branch"]),
+        ref: z4.string().describe("Ticket identifier (ENG-12), PR number (44), or branch name from list_board"),
+        repoPath: z4.string().describe("Workspace path from list_workspaces / list_board"),
+        title: z4.string().optional()
+      },
+      async ({ kind, ref, repoPath, title }) => {
+        const root = await resolveRepoRoot(repoPath);
+        const existing = findLiveThreadForCreate(
+          {
+            sourceType: kind,
+            sourceRef: ref.trim(),
+            repoPath: canonicalizeRepoPath(root),
+            title: title?.trim()
+          },
+          orch.getThreads(false).map((t) => ({
+            ...t,
+            repoPath: canonicalizeRepoPath(t.repoPath)
+          }))
+        );
+        if (existing) {
           return {
             content: [
               {
                 type: "text",
                 text: JSON.stringify({
-                  id: thread.id,
-                  title: thread.title,
-                  branchName: thread.branchName,
-                  worktreePath: thread.worktreePath,
-                  agent: thread.agent,
-                  model: thread.model,
-                  status: thread.status,
-                  cowboy: Boolean(thread.cowboy),
-                  link: `sideboard://thread/${thread.id}`,
-                  parentThreadId: thread.parentThreadId,
-                  ...agentCoercedFrom ? {
-                    agentCoercedFrom,
-                    note: `Avoid nested Codex under a Codex orchestrator \u2014 used Account default agent=${thread.agent}`
-                  } : {},
-                  ...parentCorrectedFrom ? { parentCorrectedFrom, parentNote } : {}
+                  alreadyStarted: true,
+                  id: existing.id,
+                  title: existing.title,
+                  status: existing.status,
+                  link: `sideboard://thread/${existing.id}`
                 })
               }
             ]
           };
-        } catch (err) {
-          const message = err instanceof Error ? err.message : String(err);
+        }
+        const workspaces = orch.listWorkspaces();
+        const loaded = await getHomeBoardInputs(workspaces);
+        const pin = findBoardPin(loaded.pins, kind, ref, root);
+        if (kind === "branch") {
+          const sourceRef = pin?.ref === "default" ? "default" : pin?.ref ?? ref.trim();
+          const result2 = await createOrchChildThread(
+            orch,
+            {
+              sourceType: "branch",
+              sourceRef,
+              repoPath: root,
+              title: title?.trim() || pin?.title || (sourceRef === "default" ? void 0 : sourceRef)
+            },
+            resolveNewThreadOptions
+          );
           return {
-            content: [
-              {
-                type: "text",
-                text: `create_thread failed: ${message}`
-              }
-            ],
-            isError: true
+            content: [{ type: "text", text: result2.text }],
+            ...result2.ok ? {} : { isError: true }
+          };
+        }
+        if (kind === "ticket") {
+          const issue = findBoardIssue(loaded.issues, ref, root);
+          const ident = issue?.identifier ?? ref.trim();
+          const attachments = issue ? [
+            {
+              id: randomUUID2(),
+              name: issue.identifier,
+              kind: "issue",
+              content: [
+                `Linked issue: ${issue.identifier} \u2014 ${issue.title}`,
+                issue.url ? `URL: ${issue.url}` : null
+              ].filter(Boolean).join("\n")
+            }
+          ] : void 0;
+          const result2 = await createOrchChildThread(
+            orch,
+            {
+              sourceType: "ticket",
+              sourceRef: ident,
+              repoPath: root,
+              title: title?.trim() || issue?.title,
+              attachments
+            },
+            resolveNewThreadOptions
+          );
+          return {
+            content: [{ type: "text", text: result2.text }],
+            ...result2.ok ? {} : { isError: true }
           };
         }
+        const pr = findBoardPr(loaded.prs, ref, root);
+        const number = pr ? String(pr.number) : ref.trim().replace(/^#/, "");
+        const result = await createOrchChildThread(
+          orch,
+          {
+            sourceType: "pr",
+            sourceRef: number,
+            repoPath: root,
+            title: title?.trim() || pr?.title
+          },
+          resolveNewThreadOptions
+        );
+        return {
+          content: [{ type: "text", text: result.text }],
+          ...result.ok ? {} : { isError: true }
+        };
       }
     );
     server.tool(
@@ -2374,7 +2830,7 @@ async function startMcpServer() {
     );
     server.tool(
       "list_issues",
-      "List issues from Sideboard Account connections (Linear API or GitHub Issues; Linear\u2192GitHub fallback when Linear is not connected). Pass repoPath from list_workspaces \u2014 GitHub Issues are scoped to that repo. Then create_thread with sourceType=ticket.",
+      "List issues from Sideboard Account connections (Linear API or GitHub Issues; Linear\u2192GitHub fallback when Linear is not connected). Linear returns issues assigned to you (includes cycle). Pass repoPath from list_workspaces \u2014 GitHub Issues are scoped to that repo. Prefer list_board for Home columns + current-cycle filter. Then create_thread with sourceType=ticket.",
       { repoPath: z4.string() },
       async ({ repoPath }) => {
         const root = await resolveRepoRoot(repoPath);