@sideboard-ai/core 0.1.193 → 0.1.195

package/dist/mcp/run-stdio.cjs

@@ -2986,18 +2986,6 @@ var init_teams = __esm({
 });
 
 // src/git/worktree-labels.ts
-var worktree_labels_exports = {};
-__export(worktree_labels_exports, {
-  branchDisplayLabel: () => branchDisplayLabel,
-  isPlaceholderBranch: () => isPlaceholderBranch,
-  normalizeWorktreePath: () => normalizeWorktreePath,
-  threadDisplayLabel: () => threadDisplayLabel,
-  ticketSlugForBranch: () => ticketSlugForBranch,
-  worktreeDisplayLabel: () => worktreeDisplayLabel,
-  worktreeDisplayLabelForGroup: () => worktreeDisplayLabelForGroup,
-  worktreeNameFromPath: () => worktreeNameFromPath,
-  worktreeSlugForTicket: () => worktreeSlugForTicket
-});
 function normalizeWorktreePath(worktreePath) {
   const trimmed = (worktreePath ?? "").replace(/\/+$/, "") || "/";
   const absolute = trimmed.startsWith("/");
@@ -3465,7 +3453,7 @@ function sanitizeGitBranchPrefix(raw) {
   return slug || null;
 }
 function resolveGitBranchPrefix(opts) {
-  return sanitizeGitBranchPrefix(opts.setting) ?? sanitizeGitBranchPrefix(opts.githubLogin);
+  return sanitizeGitBranchPrefix(opts.setting);
 }
 function examplePrefixedBranch(prefix, ticket) {
   const head = sanitizeGitBranchPrefix(prefix);
@@ -13034,6 +13022,59 @@ var init_context_compact = __esm({
   }
 });
 
+// src/threads/worktree-runtime.ts
+function worktreeProcessPrefix(worktreePath) {
+  return `wt:${normalizeWorktreePath(worktreePath)}`;
+}
+function worktreeSetupProcessKey(worktreePath) {
+  return `${worktreeProcessPrefix(worktreePath)}:setup`;
+}
+function worktreeRunProcessKey(worktreePath, scriptName) {
+  return `${worktreeProcessPrefix(worktreePath)}:run:${scriptName}`;
+}
+function worktreeDevProcessKey(worktreePath) {
+  return `${worktreeProcessPrefix(worktreePath)}:dev`;
+}
+function isWorktreeRunProcessKey(key, worktreePath) {
+  const prefix = worktreeProcessPrefix(worktreePath);
+  return key.startsWith(`${prefix}:run:`) || key === `${prefix}:dev`;
+}
+function pickRichestSetupLog(snaps) {
+  let best;
+  for (const snap of snaps) {
+    if (!snap.output && !snap.running && snap.exitCode == null) continue;
+    if (!best) {
+      best = snap;
+      continue;
+    }
+    if (snap.running && !best.running) {
+      best = snap;
+      continue;
+    }
+    if (snap.running === best.running && snap.output.length > best.output.length) {
+      best = snap;
+    }
+  }
+  return best;
+}
+function mergeWorktreeActiveRuns(threads) {
+  const byName = /* @__PURE__ */ new Map();
+  let devPort = null;
+  for (const thread of threads) {
+    if (thread.devPort != null && devPort == null) devPort = thread.devPort;
+    for (const run2 of thread.activeRuns ?? []) {
+      if (!byName.has(run2.scriptName)) byName.set(run2.scriptName, run2);
+    }
+  }
+  return { activeRuns: [...byName.values()], devPort };
+}
+var init_worktree_runtime = __esm({
+  "src/threads/worktree-runtime.ts"() {
+    "use strict";
+    init_worktree_labels();
+  }
+});
+
 // src/threads/chat-tabs.ts
 function sameWorktreePath(a, b) {
   return normalizeWorktreePath(a) === normalizeWorktreePath(b);
@@ -13130,7 +13171,8 @@ function createChatTab(input) {
     planMode: from.planMode,
     autonomy: input.autonomy ?? from.autonomy,
     attachments: input.attachments ?? [],
-    status: "idle"
+    status: "idle",
+    ...mergeWorktreeActiveRuns(threadsSharingWorktree(binding.worktreePath))
   });
   writeThread(thread);
   return thread;
@@ -13164,6 +13206,7 @@ var init_chat_tabs = __esm({
     init_global_workspace();
     init_orchestrator_capable();
     init_thread_store();
+    init_worktree_runtime();
     init_worktree_labels();
   }
 });
@@ -13832,6 +13875,10 @@ var init_conductor = __esm({
 function setupLogPath(threadId) {
   return (0, import_node_path36.join)(threadsDir(), `${threadId}.setup.log.json`);
 }
+function setupLogKeyForWorktree(worktreePath) {
+  const norm = normalizeWorktreePath(worktreePath);
+  return `wt-${(0, import_node_crypto8.createHash)("sha1").update(norm).digest("hex").slice(0, 16)}`;
+}
 function emptySetupLog() {
   return { ...EMPTY };
 }
@@ -13922,12 +13969,14 @@ function finishSetupLog(threadId, exitCode, source) {
   persistNow(threadId);
   return clone(snap);
 }
-var import_node_fs36, import_node_path36, EMPTY, memory, persistTimers;
+var import_node_crypto8, import_node_fs36, import_node_path36, EMPTY, memory, persistTimers;
 var init_setup_log = __esm({
   "src/store/setup-log.ts"() {
     "use strict";
+    import_node_crypto8 = require("crypto");
     import_node_fs36 = require("fs");
     import_node_path36 = require("path");
+    init_worktree_labels();
     init_paths();
     EMPTY = {
       output: "",
@@ -16396,7 +16445,7 @@ function buildQuotaHandoffAttachment(from, limitText, fallbackAgent) {
     `- Do not wait on the limited ${from.agent} account; keep going on ${fallbackAgent}.`
   ].join("\n");
   return {
-    id: (0, import_node_crypto8.randomUUID)(),
+    id: (0, import_node_crypto9.randomUUID)(),
     name: "Orchestration quota handoff.md",
     kind: "transcript",
     content: body
@@ -16417,11 +16466,11 @@ function createQuotaFailoverChat(from, fallbackAgent, limitText) {
     sourceType: "orchestration"
   });
 }
-var import_node_crypto8, QUOTA_CONTINUE_PROMPT, QUOTA_RESUME_PROMPT;
+var import_node_crypto9, QUOTA_CONTINUE_PROMPT, QUOTA_RESUME_PROMPT;
 var init_quota_failover = __esm({
   "src/orchestrator/quota-failover.ts"() {
     "use strict";
-    import_node_crypto8 = require("crypto");
+    import_node_crypto9 = require("crypto");
     init_session_quota();
     init_app_settings();
     init_global_workspace();
@@ -19179,7 +19228,7 @@ function buildTask(input, now) {
   const ts = nowIso2(now);
   const agent = input.agent ? coerceOrchestratorAgent(input.agent) : null;
   return {
-    id: (0, import_node_crypto9.randomUUID)(),
+    id: (0, import_node_crypto10.randomUUID)(),
     name: input.name?.trim() || defaultScheduleName(prompt),
     prompt,
     enabled: input.enabled !== false,
@@ -19266,11 +19315,11 @@ function recordScheduleRun(id, result) {
   writeAll2(rows);
   return next;
 }
-var import_node_crypto9, import_node_fs51, import_node_path48, import_croner, DURATION_RE, UNIT_MS;
+var import_node_crypto10, import_node_fs51, import_node_path48, import_croner, DURATION_RE, UNIT_MS;
 var init_schedules = __esm({
   "src/store/schedules.ts"() {
     "use strict";
-    import_node_crypto9 = require("crypto");
+    import_node_crypto10 = require("crypto");
     import_node_fs51 = require("fs");
     import_node_path48 = require("path");
     import_croner = require("croner");
@@ -19412,64 +19461,6 @@ var init_schedule_runner = __esm({
   }
 });
 
-// src/integrations/github.ts
-var github_exports = {};
-__export(github_exports, {
-  getGitHubStatus: () => getGitHubStatus,
-  refreshGitHubAuth: () => refreshGitHubAuth
-});
-async function getGitHubStatus() {
-  const which = await run("which", ["gh"], { reject: false });
-  if (which.exitCode !== 0 || !which.stdout.trim()) {
-    return {
-      connected: false,
-      login: null,
-      hosts: [],
-      reason: "gh CLI not found on PATH"
-    };
-  }
-  const loginResult = await run(
-    "gh",
-    ["api", "user", "--jq", ".login"],
-    { reject: false }
-  );
-  if (loginResult.exitCode === 0 && loginResult.stdout.trim()) {
-    return {
-      connected: true,
-      login: loginResult.stdout.trim(),
-      hosts: ["github.com"],
-      reason: null
-    };
-  }
-  const status = await run("gh", ["auth", "status"], { reject: false });
-  const text7 = `${status.stdout}
-${status.stderr}`;
-  const loginMatch = text7.match(/Logged in to ([^\s]+) account (\S+)/i) ?? text7.match(/Logged in to ([^\s]+) as (\S+)/i);
-  if (loginMatch) {
-    return {
-      connected: true,
-      login: loginMatch[2].replace(/['"]/g, ""),
-      hosts: [loginMatch[1]],
-      reason: null
-    };
-  }
-  return {
-    connected: false,
-    login: null,
-    hosts: [],
-    reason: status.stderr.trim() || status.stdout.trim() || "Not logged in to GitHub (run: gh auth login)"
-  };
-}
-async function refreshGitHubAuth() {
-  return getGitHubStatus();
-}
-var init_github = __esm({
-  "src/integrations/github.ts"() {
-    "use strict";
-    init_run();
-  }
-});
-
 // src/agents/cursor-store.ts
 function cursorSdkStoreDir(threadId) {
   const root = (0, import_node_path49.join)(appDataDir(), CURSOR_SDK_STORE_DIR);
@@ -19736,6 +19727,7 @@ var init_orchestrator = __esm({
     init_setup_last_error();
     init_request_review();
     init_fork_worktree();
+    init_worktree_runtime();
     init_quota_failover();
     init_adopt();
     init_stack_layers();
@@ -20534,21 +20526,11 @@ var init_orchestrator = __esm({
         const settings = loadWorkspaceSettings(fresh.worktreePath, fresh.repoPath);
         let renameBranchDirective = null;
         if (!isBrightsy && !isOrchestration && autoRenameBranchEnabled2()) {
-          const { isPlaceholderBranch: isPlaceholderBranch2 } = await Promise.resolve().then(() => (init_worktree_labels(), worktree_labels_exports));
-          let githubLogin = null;
-          if (isPlaceholderBranch2(fresh.branchName, fresh.worktreePath) && !gitBranchPrefixSetting2()) {
-            try {
-              const { getGitHubStatus: getGitHubStatus2 } = await Promise.resolve().then(() => (init_github(), github_exports));
-              githubLogin = (await getGitHubStatus2()).login;
-            } catch {
-            }
-          }
           const { resolveGitBranchPrefix: resolveGitBranchPrefix2 } = await Promise.resolve().then(() => (init_branch_prefix(), branch_prefix_exports));
           renameBranchDirective = formatRenameBranchDirective(fresh, {
             customPrompt: settings?.prompts?.renameBranch,
             branchPrefix: resolveGitBranchPrefix2({
-              setting: gitBranchPrefixSetting2(),
-              githubLogin
+              setting: gitBranchPrefixSetting2()
             })
           });
         }
@@ -20911,22 +20893,25 @@ var init_orchestrator = __esm({
             "No run script found for this worktree. Add [scripts.run.*] in the worktree\u2019s .sideboard/settings.toml or .conductor/settings.toml (or settings.local.toml on the main repo)."
           );
         }
-        const runKey = `${thread.id}:run:${resolvedName}`;
-        const existing = this.processes.get(runKey);
-        const active = (thread.activeRuns ?? []).find((r) => r.scriptName === resolvedName);
+        const siblings = threadsSharingWorktree(thread.worktreePath);
+        const shared = mergeWorktreeActiveRuns(siblings);
+        const runKey = worktreeRunProcessKey(thread.worktreePath, resolvedName);
+        const existing = this.processes.get(runKey) ?? siblings.map((t) => this.processes.get(`${t.id}:run:${resolvedName}`)).find(Boolean);
+        const active = shared.activeRuns.find((r) => r.scriptName === resolvedName);
         if (existing && active) {
           return { port: active.port, scriptName: resolvedName, ports: active.ports };
         }
         if (!scriptName) {
-          const legacy = this.processes.get(`${thread.id}:dev`);
-          if (legacy && thread.devPort) {
-            return { port: thread.devPort, scriptName: resolvedName, ports: [thread.devPort] };
+          const legacy = this.processes.get(worktreeDevProcessKey(thread.worktreePath)) ?? siblings.map((t) => this.processes.get(`${t.id}:dev`)).find(Boolean);
+          if (legacy && shared.devPort) {
+            return { port: shared.devPort, scriptName: resolvedName, ports: [shared.devPort] };
           }
         }
         const mode = getRunMode(thread.worktreePath, thread.repoPath);
         if (mode === "nonconcurrent") {
+          const here = normalizeWorktreePath(thread.worktreePath);
           for (const t of listThreads()) {
-            if (t.id === thread.id) continue;
+            if (normalizeWorktreePath(t.worktreePath) === here) continue;
             const runs = t.activeRuns ?? [];
             if (runs.length > 0 || t.devPort) {
               throw new Error(
@@ -20961,7 +20946,7 @@ var init_orchestrator = __esm({
         });
         const isDefault = scripts.find((s) => s.default)?.name === resolvedName || !scripts.some((s) => s.default) && (resolvedName === "dev" || resolvedName === scripts[0]?.name);
         if (isDefault) {
-          this.processes.set(`${thread.id}:dev`, {
+          this.processes.set(worktreeDevProcessKey(thread.worktreePath), {
             kind: "dev",
             pid: handle.pid,
             startedAt,
@@ -20976,13 +20961,14 @@ var init_orchestrator = __esm({
           startedAt
         };
         const nextRuns = [
-          ...(thread.activeRuns ?? []).filter((r) => r.scriptName !== resolvedName),
+          ...shared.activeRuns.filter((r) => r.scriptName !== resolvedName),
           run2
         ];
-        updateThread(thread.id, {
-          activeRuns: nextRuns,
-          devPort: isDefault ? handle.port : thread.devPort
-        });
+        this.syncWorktreeRuns(
+          thread.worktreePath,
+          nextRuns,
+          isDefault ? handle.port : shared.devPort
+        );
         this.emit({
           type: "dev_server_started",
           threadId: thread.id,
@@ -20991,15 +20977,14 @@ var init_orchestrator = __esm({
         });
         void handle.done.then(() => {
           this.processes.delete(runKey);
-          if (isDefault) this.processes.delete(`${thread.id}:dev`);
-          const latest = readThread(thread.id);
-          const remaining = (latest?.activeRuns ?? []).filter(
-            (r) => r.scriptName !== resolvedName
+          if (isDefault) this.processes.delete(worktreeDevProcessKey(thread.worktreePath));
+          const latest = mergeWorktreeActiveRuns(threadsSharingWorktree(thread.worktreePath));
+          const remaining = latest.activeRuns.filter((r) => r.scriptName !== resolvedName);
+          this.syncWorktreeRuns(
+            thread.worktreePath,
+            remaining,
+            isDefault ? null : latest.devPort
           );
-          updateThread(thread.id, {
-            activeRuns: remaining,
-            devPort: isDefault ? null : latest?.devPort ?? null
-          });
           this.emit({
             type: "dev_server_stopped",
             threadId: thread.id,
@@ -21010,51 +20995,82 @@ var init_orchestrator = __esm({
       }
       stopDev(threadRef, scriptName) {
         const thread = this.requireThread(threadRef);
+        const siblings = threadsSharingWorktree(thread.worktreePath);
+        const shared = mergeWorktreeActiveRuns(siblings);
         if (scriptName) {
-          const runKey = `${thread.id}:run:${scriptName}`;
-          const proc = this.processes.get(runKey);
-          if (proc) proc.kill();
-          this.processes.delete(runKey);
-          const remaining = (thread.activeRuns ?? []).filter((r) => r.scriptName !== scriptName);
-          const isPrimary = thread.devPort != null && thread.activeRuns?.find((r) => r.scriptName === scriptName)?.port === thread.devPort;
-          updateThread(thread.id, {
-            activeRuns: remaining,
-            devPort: isPrimary ? null : thread.devPort
-          });
+          const keys = [
+            worktreeRunProcessKey(thread.worktreePath, scriptName),
+            ...siblings.map((t) => `${t.id}:run:${scriptName}`)
+          ];
+          for (const key of keys) {
+            const proc = this.processes.get(key);
+            if (proc) proc.kill();
+            this.processes.delete(key);
+          }
+          const remaining = shared.activeRuns.filter((r) => r.scriptName !== scriptName);
+          const isPrimary = shared.devPort != null && shared.activeRuns.find((r) => r.scriptName === scriptName)?.port === shared.devPort;
+          this.syncWorktreeRuns(
+            thread.worktreePath,
+            remaining,
+            isPrimary ? null : shared.devPort
+          );
           this.emit({ type: "dev_server_stopped", threadId: thread.id, scriptName });
           return;
         }
         for (const [key, proc] of [...this.processes.entries()]) {
-          if (key.startsWith(`${thread.id}:run:`) || key === `${thread.id}:dev`) {
+          if (isWorktreeRunProcessKey(key, thread.worktreePath) || siblings.some((t) => key.startsWith(`${t.id}:run:`) || key === `${t.id}:dev`)) {
             proc.kill();
             this.processes.delete(key);
           }
         }
-        updateThread(thread.id, { activeRuns: [], devPort: null });
+        this.syncWorktreeRuns(thread.worktreePath, [], null);
         this.emit({ type: "dev_server_stopped", threadId: thread.id });
       }
+      syncWorktreeRuns(worktreePath, activeRuns, devPort) {
+        for (const sibling of threadsSharingWorktree(worktreePath)) {
+          updateThread(sibling.id, { activeRuns, devPort });
+        }
+      }
       listThreadRunScripts(threadRef) {
         const thread = this.requireThread(threadRef);
         return listRunScripts(thread.worktreePath, thread.repoPath);
       }
       getActiveRuns(threadRef) {
-        return this.requireThread(threadRef).activeRuns ?? [];
+        const thread = this.requireThread(threadRef);
+        return mergeWorktreeActiveRuns(threadsSharingWorktree(thread.worktreePath)).activeRuns;
       }
       getSetupLog(threadRef) {
         const thread = this.getThread(threadRef);
         if (!thread) return readSetupLog(threadRef);
-        const snap = readSetupLog(thread.id);
-        if (snap.running && !this.processes.has(`${thread.id}:setup`)) {
+        const siblingIds = [
+          thread.id,
+          ...threadsSharingWorktree(thread.worktreePath).map((t) => t.id)
+        ];
+        const snap = pickRichestSetupLog([
+          readSetupLog(setupLogKeyForWorktree(thread.worktreePath)),
+          ...[...new Set(siblingIds)].map((id) => readSetupLog(id))
+        ]) ?? readSetupLog(thread.id);
+        if (snap.running && !this.hasWorktreeSetupProcess(thread.worktreePath)) {
           return { ...snap, running: false };
         }
         return snap;
       }
+      hasWorktreeSetupProcess(worktreePath) {
+        if (this.processes.has(worktreeSetupProcessKey(worktreePath))) return true;
+        return threadsSharingWorktree(worktreePath).some(
+          (t) => this.processes.has(`${t.id}:setup`)
+        );
+      }
+      writeSetupLog(threadId, worktreePath, fn) {
+        fn(setupLogKeyForWorktree(worktreePath));
+        fn(threadId);
+      }
       async runSetup(threadRef, opts) {
         const thread = this.requireThread(threadRef);
         this.assertNotGlobal(thread, "Setup");
-        const key = `${thread.id}:setup`;
-        if (this.processes.has(key)) {
-          throw new Error("Setup already running for this thread");
+        const key = worktreeSetupProcessKey(thread.worktreePath);
+        if (this.hasWorktreeSetupProcess(thread.worktreePath)) {
+          throw new Error("Setup already running for this worktree");
         }
         const abort = new AbortController();
         this.processes.set(key, {
@@ -21062,13 +21078,17 @@ var init_orchestrator = __esm({
           startedAt: (/* @__PURE__ */ new Date()).toISOString(),
           kill: () => abort.abort()
         });
-        beginSetupLog(thread.id);
+        this.writeSetupLog(thread.id, thread.worktreePath, beginSetupLog);
         this.emit({ type: "setup_started", threadId: thread.id });
         let finished = false;
         const finish = (exitCode, source) => {
           if (finished) return;
           finished = true;
-          finishSetupLog(thread.id, exitCode, source);
+          this.writeSetupLog(
+            thread.id,
+            thread.worktreePath,
+            (logKey) => finishSetupLog(logKey, exitCode, source)
+          );
           this.emit({ type: "setup_finished", threadId: thread.id, exitCode });
         };
         try {
@@ -21076,14 +21096,22 @@ var init_orchestrator = __esm({
             thread.repoPath,
             thread.worktreePath,
             (line) => {
-              appendSetupLog(thread.id, line);
+              this.writeSetupLog(
+                thread.id,
+                thread.worktreePath,
+                (logKey) => appendSetupLog(logKey, line)
+              );
               this.emit({ type: "setup_output", threadId: thread.id, line });
             },
             { signal: abort.signal }
           );
           if (!setup.ran) {
             const line = "No setup script in .sideboard/settings.toml, .conductor/settings.toml, .cursor/worktrees.json, or script/setup (bin/setup, scripts/setup)";
-            appendSetupLog(thread.id, line);
+            this.writeSetupLog(
+              thread.id,
+              thread.worktreePath,
+              (logKey) => appendSetupLog(logKey, line)
+            );
             this.emit({ type: "setup_output", threadId: thread.id, line });
             finish(null, null);
             throw new Error(line);
@@ -21111,8 +21139,14 @@ var init_orchestrator = __esm({
       }
       cancelSetup(threadRef) {
         const thread = this.requireThread(threadRef);
-        const proc = this.processes.get(`${thread.id}:setup`);
-        if (proc) proc.kill();
+        const keys = [
+          worktreeSetupProcessKey(thread.worktreePath),
+          ...threadsSharingWorktree(thread.worktreePath).map((t) => `${t.id}:setup`)
+        ];
+        for (const key of [...new Set(keys)]) {
+          const proc = this.processes.get(key);
+          if (proc) proc.kill();
+        }
       }
       async applyIntoMain(threadRef, opts) {
         const thread = this.requireThread(threadRef);
@@ -21862,7 +21896,7 @@ init_system_ca();
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_zod9 = require("zod");
-var import_node_crypto12 = require("crypto");
+var import_node_crypto13 = require("crypto");
 var import_node_path52 = require("path");
 init_orchestrator();
 init_worktree();
@@ -22289,7 +22323,7 @@ async function createGitHubIssue(input, opts) {
 init_fetch();
 
 // src/integrations/linear-oauth.ts
-var import_node_crypto10 = require("crypto");
+var import_node_crypto11 = require("crypto");
 var import_node_http = require("http");
 init_app_settings();
 init_fetch();
@@ -25272,7 +25306,7 @@ init_worktree();
 init_paths();
 
 // src/board/board-pins.ts
-var import_node_crypto11 = require("crypto");
+var import_node_crypto12 = require("crypto");
 var import_node_fs54 = require("fs");
 var import_node_path50 = require("path");
 init_paths();
@@ -25487,7 +25521,51 @@ async function getHomeBoardInputs(workspaces, opts) {
 
 // src/mcp/server.ts
 init_home_board();
-init_github();
+
+// src/integrations/github.ts
+init_run();
+async function getGitHubStatus() {
+  const which = await run("which", ["gh"], { reject: false });
+  if (which.exitCode !== 0 || !which.stdout.trim()) {
+    return {
+      connected: false,
+      login: null,
+      hosts: [],
+      reason: "gh CLI not found on PATH"
+    };
+  }
+  const loginResult = await run(
+    "gh",
+    ["api", "user", "--jq", ".login"],
+    { reject: false }
+  );
+  if (loginResult.exitCode === 0 && loginResult.stdout.trim()) {
+    return {
+      connected: true,
+      login: loginResult.stdout.trim(),
+      hosts: ["github.com"],
+      reason: null
+    };
+  }
+  const status = await run("gh", ["auth", "status"], { reject: false });
+  const text7 = `${status.stdout}
+${status.stderr}`;
+  const loginMatch = text7.match(/Logged in to ([^\s]+) account (\S+)/i) ?? text7.match(/Logged in to ([^\s]+) as (\S+)/i);
+  if (loginMatch) {
+    return {
+      connected: true,
+      login: loginMatch[2].replace(/['"]/g, ""),
+      hosts: [loginMatch[1]],
+      reason: null
+    };
+  }
+  return {
+    connected: false,
+    login: null,
+    hosts: [],
+    reason: status.stderr.trim() || status.stdout.trim() || "Not logged in to GitHub (run: gh auth login)"
+  };
+}
 
 // src/mcp/create-thread-agent.ts
 init_cursor();
@@ -26077,7 +26155,7 @@ async function startMcpServer() {
           const ident = issue?.identifier ?? ref.trim();
           const attachments = issue ? [
             {
-              id: (0, import_node_crypto12.randomUUID)(),
+              id: (0, import_node_crypto13.randomUUID)(),
               name: issue.identifier,
               kind: "issue",
               content: [