@kw-yeh/vibeflow 4.6.1 → 4.7.1

package/dist/vibeflow.mjs

@@ -522,9 +522,9 @@ function truncateUtf8(value, maxBytes) {
   return result;
 }
 function safeAttachmentName(name) {
-  const basename2 = name.replace(/\\/g, "/").split("/").pop() ?? "";
+  const basename3 = name.replace(/\\/g, "/").split("/").pop() ?? "";
   const sanitized = truncateUtf8(
-    basename2.replace(/[\u0000-\u001f\u007f]/g, "").trim(),
+    basename3.replace(/[\u0000-\u001f\u007f]/g, "").trim(),
     MAX_FILENAME_BYTES
   );
   return sanitized && sanitized !== "." && sanitized !== ".." ? sanitized : "attachment";
@@ -1333,8 +1333,8 @@ function quitHelp(backend, isHost) {
   if (isHost) return "q         \u96E2\u958B\uFF08\u9019\u500B TUI \u5C31\u662F host\uFF0C\u57F7\u884C\u4E2D\u7684 agent \u6703\u4E00\u8D77\u7D50\u675F\uFF09";
   return "q         \u96E2\u958B\uFF08agent \u7531\u57F7\u884C\u4E2D\u7684 host \u6301\u6709\uFF0C\u6703\u7E7C\u7E8C\u57F7\u884C\uFF09";
 }
-function diffEnv(base, hasDelta) {
-  const env = { ...base };
+function diffEnv(base2, hasDelta) {
+  const env = { ...base2 };
   if (hasDelta) env.GIT_PAGER = "delta --side-by-side --paging=always";
   else if (env.LESS === void 0) env.LESS = "R";
   return env;
@@ -1607,9 +1607,9 @@ function hasCommand(cmd, args) {
   return spawnSync2(cmd, args, { stdio: "ignore" }).status === 0;
 }
 function showDiff(task) {
-  const base = task.baseBranch ?? "HEAD";
+  const base2 = task.baseBranch ?? "HEAD";
   const env = diffEnv(process.env, hasCommand("delta", ["--version"]));
-  spawnSync2("git", ["-C", task.worktreePath, "-c", "color.ui=always", "diff", base], {
+  spawnSync2("git", ["-C", task.worktreePath, "-c", "color.ui=always", "diff", base2], {
     stdio: "inherit",
     env
   });
@@ -2223,6 +2223,10 @@ function createBridge(t) {
     startGithubAuthLogin: () => t.invoke("settings:startGithubAuthLogin"),
     cancelGithubAuthLogin: () => t.invoke("settings:cancelGithubAuthLogin"),
     logoutGithubAuth: () => t.invoke("settings:logoutGithubAuth"),
+    /** Open Issues/PRs of the board's GitHub repos that involve me; cached unless `force`. */
+    getGithubInbox: (opts) => t.invoke("github:inbox", opts ?? {}),
+    /** The Issue/PR each card belongs to, keyed by task id. */
+    getGithubTaskLinks: (opts) => t.invoke("github:taskLinks", opts ?? {}),
     onGithubAuthEvent: (callback) => {
       return t.on("github-auth:event", (payload) => callback(payload));
     },
@@ -2533,8 +2537,8 @@ async function generateBranchName(title, description) {
 }
 
 // packages/core/src/git.ts
-import { execFile as execFile4 } from "child_process";
-import { promisify } from "util";
+import { execFile as execFile5 } from "child_process";
+import { promisify as promisify2 } from "util";
 import path12 from "path";
 import fs8 from "fs/promises";
 
@@ -2881,6 +2885,300 @@ function buildAgentCommand(task, systemPrompt, opts, workspacePath) {
 
 // packages/core/src/git.ts
 init_env();
+
+// packages/core/src/github.ts
+init_env();
+import { execFile as execFile4 } from "child_process";
+import { promisify } from "util";
+var pexec = promisify(execFile4);
+var defaultGhRunner = async (args) => {
+  const { stdout } = await pexec("gh", args, {
+    env: execEnv(),
+    maxBuffer: 16 * 1024 * 1024,
+    timeout: 3e4,
+    windowsHide: true
+  });
+  return stdout.toString();
+};
+function parseGithubRepo(remoteUrl) {
+  if (!remoteUrl) return null;
+  const url = remoteUrl.trim();
+  const match = url.match(/^git@github\.com:([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/) ?? url.match(/^ssh:\/\/git@github\.com(?::\d+)?\/([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/) ?? url.match(/^https?:\/\/(?:[^@/\s]+@)?github\.com\/([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/);
+  return match ? `${match[1]}/${match[2]}` : null;
+}
+var REPO_RE = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+function isGithubRef(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return (v.kind === "issue" || v.kind === "pr") && typeof v.repo === "string" && REPO_RE.test(v.repo) && typeof v.number === "number" && Number.isInteger(v.number) && v.number > 0 && typeof v.url === "string" && v.url.startsWith(`https://github.com/${v.repo}/`);
+}
+var ITEM_FIELDS = "number,title,url,body,author,assignees,labels,milestone,createdAt";
+var ISSUE_FIELDS = `${ITEM_FIELDS},issueType`;
+var PR_FIELDS = `${ITEM_FIELDS},state,isDraft,reviewDecision,headRefName,baseRefName`;
+var PR_INDEX_FIELDS = "number,url,state,isDraft,headRefName,closingIssuesReferences";
+var LIST_LIMIT = "50";
+var PR_INDEX_LIMIT = "100";
+async function runJson(run3, args) {
+  const out = await run3(args);
+  const parsed = JSON.parse(out || "[]");
+  return Array.isArray(parsed) ? parsed : [];
+}
+function user(raw) {
+  const u = raw;
+  if (!u || typeof u.login !== "string") return null;
+  return typeof u.name === "string" && u.name ? { login: u.login, name: u.name } : { login: u.login };
+}
+function base(raw, repo) {
+  const milestone = raw.milestone;
+  return {
+    repo,
+    number: Number(raw.number),
+    title: String(raw.title ?? ""),
+    url: String(raw.url ?? ""),
+    body: typeof raw.body === "string" ? raw.body : "",
+    author: user(raw.author),
+    assignees: Array.isArray(raw.assignees) ? raw.assignees.map(user).filter(Boolean) : [],
+    labels: Array.isArray(raw.labels) ? raw.labels.map((l) => ({ name: String(l.name ?? ""), color: String(l.color ?? "") })) : [],
+    milestone: milestone && typeof milestone.title === "string" ? milestone.title : null,
+    createdAt: String(raw.createdAt ?? "")
+  };
+}
+function prStateOf(raw) {
+  if (raw.state === "MERGED") return "merged";
+  if (raw.state === "CLOSED") return "closed";
+  return raw.isDraft ? "draft" : "open";
+}
+function toIssue(raw, repo) {
+  const type = raw.issueType;
+  return {
+    ...base(raw, repo),
+    kind: "issue",
+    issueType: type && typeof type.name === "string" ? { name: type.name, ...typeof type.color === "string" ? { color: type.color } : {} } : null
+  };
+}
+function toPr(raw, repo) {
+  return {
+    ...base(raw, repo),
+    kind: "pr",
+    state: prStateOf(raw),
+    reviewDecision: typeof raw.reviewDecision === "string" && raw.reviewDecision ? raw.reviewDecision : null,
+    headRefName: String(raw.headRefName ?? ""),
+    baseRefName: String(raw.baseRefName ?? "")
+  };
+}
+function mergeItems(lists) {
+  const byNumber = /* @__PURE__ */ new Map();
+  for (const list of lists) for (const item of list) if (!byNumber.has(item.number)) byNumber.set(item.number, item);
+  return Array.from(byNumber.values()).sort(
+    (a, b) => b.createdAt.localeCompare(a.createdAt) || b.number - a.number
+  );
+}
+async function listIssues(run3, repo, filter) {
+  const args = ["issue", "list", "-R", repo, "--state", "open", "--limit", LIST_LIMIT, ...filter];
+  let rows;
+  try {
+    rows = await runJson(run3, [...args, "--json", ISSUE_FIELDS]);
+  } catch (err) {
+    if (!/issueType/.test(errorText(err))) throw err;
+    rows = await runJson(run3, [...args, "--json", ITEM_FIELDS]);
+  }
+  return rows.map((r) => toIssue(r, repo));
+}
+async function listPrs(run3, repo, filter) {
+  const rows = await runJson(run3, [
+    "pr",
+    "list",
+    "-R",
+    repo,
+    "--state",
+    "open",
+    "--limit",
+    LIST_LIMIT,
+    ...filter,
+    "--json",
+    PR_FIELDS
+  ]);
+  return rows.map((r) => toPr(r, repo));
+}
+async function fetchRepoItems(run3, repo) {
+  const [assignedIssues, authoredIssues, assignedPrs, authoredPrs, reviewPrs] = await Promise.all([
+    listIssues(run3, repo, ["--assignee", "@me"]),
+    listIssues(run3, repo, ["--author", "@me"]),
+    listPrs(run3, repo, ["--assignee", "@me"]),
+    listPrs(run3, repo, ["--author", "@me"]),
+    listPrs(run3, repo, ["--search", "review-requested:@me"])
+  ]);
+  return {
+    issues: mergeItems([assignedIssues, authoredIssues]),
+    prs: mergeItems([assignedPrs, authoredPrs, reviewPrs])
+  };
+}
+async function fetchPrIndex(run3, repo) {
+  const rows = await runJson(run3, [
+    "pr",
+    "list",
+    "-R",
+    repo,
+    "--state",
+    "all",
+    "--limit",
+    PR_INDEX_LIMIT,
+    "--json",
+    PR_INDEX_FIELDS
+  ]);
+  const [owner, name] = repo.split("/");
+  return rows.map((r) => ({
+    number: Number(r.number),
+    url: String(r.url ?? ""),
+    state: prStateOf(r),
+    headRefName: String(r.headRefName ?? ""),
+    closingIssues: (Array.isArray(r.closingIssuesReferences) ? r.closingIssuesReferences : []).filter((ref) => {
+      const repository = ref.repository;
+      const refOwner = repository?.owner?.login;
+      return !repository || repository.name === name && refOwner === owner;
+    }).map((ref) => ({
+      number: Number(ref.number),
+      url: typeof ref.url === "string" ? ref.url : `https://github.com/${repo}/issues/${ref.number}`
+    }))
+  }));
+}
+function linkFromRef(ref, state) {
+  return { kind: ref.kind, number: ref.number, url: ref.url, state };
+}
+function hasRealBranch(task) {
+  return Boolean(task.provisionedAt || task.worktreePath || task.outcome);
+}
+function resolveTaskLinks(tasks, repoOfProject, prIndex) {
+  const links = {};
+  for (const task of tasks) {
+    const source = task.github;
+    const repo = source?.repo ?? (task.projectPath ? repoOfProject.get(task.projectPath) : void 0);
+    const index = repo ? prIndex.get(repo) ?? [] : [];
+    let pr;
+    let prEntry;
+    if (source?.kind === "pr") {
+      prEntry = index.find((e) => e.number === source.number);
+      pr = linkFromRef(source, prEntry?.state ?? "open");
+    } else {
+      if (hasRealBranch(task)) {
+        prEntry = index.filter((e) => e.headRefName === task.branch).sort((a, b) => b.number - a.number)[0];
+      }
+      if (prEntry) {
+        pr = { kind: "pr", number: prEntry.number, url: prEntry.url, state: prEntry.state };
+      } else if (task.outcome?.pr) {
+        const o = task.outcome.pr;
+        pr = { kind: "pr", number: o.number, url: o.url, state: prStateOf({ state: o.state }) };
+      }
+    }
+    const issueState = pr?.state === "merged" ? "closed" : "open";
+    let issue;
+    if (source?.kind === "issue") {
+      issue = linkFromRef(source, issueState);
+    } else if (prEntry?.closingIssues[0]) {
+      const ref = prEntry.closingIssues[0];
+      issue = { kind: "issue", number: ref.number, url: ref.url, state: issueState };
+    }
+    if (pr || issue) links[task.id] = { ...issue ? { issue } : {}, ...pr ? { pr } : {} };
+  }
+  return links;
+}
+function errorText(err) {
+  const e = err;
+  const stderr = e?.stderr ? e.stderr.toString().trim() : "";
+  return stderr || e?.message || String(err);
+}
+var GITHUB_CACHE_TTL_MS = 5 * 60 * 1e3;
+function boardTasks(board) {
+  return [...board.in_progress, ...board.backlog, ...board.done];
+}
+function boardProjects(board) {
+  const latest = /* @__PURE__ */ new Map();
+  for (const t of boardTasks(board)) {
+    if (!t.projectPath) continue;
+    latest.set(t.projectPath, Math.max(latest.get(t.projectPath) ?? 0, t.createdAt ?? 0));
+  }
+  return Array.from(latest.entries()).sort((a, b) => b[1] - a[1]).map(([p]) => p);
+}
+function basename(p) {
+  return p.split(/[/\\]/).filter(Boolean).pop() ?? p;
+}
+function createGithubService(options) {
+  const run3 = options.run ?? defaultGhRunner;
+  const authStatus = options.authStatus;
+  const now = options.now ?? Date.now;
+  const items = /* @__PURE__ */ new Map();
+  const indexes = /* @__PURE__ */ new Map();
+  const repos = /* @__PURE__ */ new Map();
+  function cached2(map, key, force, load) {
+    const hit = map.get(key);
+    if (hit && !force && now() - hit.at < GITHUB_CACHE_TTL_MS) return hit;
+    const entry = { at: now(), value: load() };
+    entry.value.catch(() => {
+    });
+    map.set(key, entry);
+    return entry;
+  }
+  async function projectRepos(board, force) {
+    const out = /* @__PURE__ */ new Map();
+    const projects = boardProjects(board);
+    const resolved = await Promise.all(
+      projects.map((p) => cached2(repos, p, force, () => options.repoOf(p)).value.catch(() => null))
+    );
+    projects.forEach((p, i) => {
+      const repo = resolved[i];
+      if (repo) out.set(p, repo);
+    });
+    return out;
+  }
+  return {
+    async inbox(board, opts = {}) {
+      const force = opts.force === true;
+      const auth = await authStatus();
+      if (!auth.installed) return { status: "gh-missing", fetchedAt: 0, repos: [] };
+      if (!auth.authenticated) return { status: "unauthenticated", fetchedAt: 0, repos: [] };
+      const byProject = await projectRepos(board, force);
+      const repoProject = /* @__PURE__ */ new Map();
+      for (const [project, repo] of byProject) if (!repoProject.has(repo)) repoProject.set(repo, project);
+      const entries = Array.from(repoProject.entries());
+      const results = await Promise.all(
+        entries.map(async ([repo, projectPath]) => {
+          const entry = cached2(items, repo, force, () => fetchRepoItems(run3, repo));
+          const head = { repo, projectPath, projectName: basename(projectPath) };
+          try {
+            return { at: entry.at, inbox: { ...head, ...await entry.value } };
+          } catch (err) {
+            return { at: entry.at, inbox: { ...head, issues: [], prs: [], error: errorText(err) } };
+          }
+        })
+      );
+      return {
+        status: "ok",
+        ...auth.login ? { login: auth.login } : {},
+        fetchedAt: results.length ? Math.min(...results.map((r) => r.at)) : 0,
+        repos: results.map((r) => r.inbox).sort((a, b) => a.repo.localeCompare(b.repo))
+      };
+    },
+    async taskLinks(board, opts = {}) {
+      const force = opts.force === true;
+      const tasks = boardTasks(board);
+      const byProject = await projectRepos(board, force);
+      const wanted = new Set(byProject.values());
+      for (const t of tasks) if (t.github) wanted.add(t.github.repo);
+      const prIndex = /* @__PURE__ */ new Map();
+      await Promise.all(
+        Array.from(wanted).map(async (repo) => {
+          try {
+            prIndex.set(repo, await cached2(indexes, repo, force, () => fetchPrIndex(run3, repo)).value);
+          } catch {
+          }
+        })
+      );
+      return resolveTaskLinks(tasks, byProject, prIndex);
+    }
+  };
+}
+
+// packages/core/src/git.ts
 init_attachments();
 
 // packages/core/src/artifacts.ts
@@ -3038,9 +3336,9 @@ function deleteArtifacts(baseDir, worktreePath) {
 }
 
 // packages/core/src/git.ts
-var pexec = promisify(execFile4);
+var pexec2 = promisify2(execFile5);
 async function git(cwd, args) {
-  const { stdout } = await pexec("git", args, {
+  const { stdout } = await pexec2("git", args, {
     cwd,
     maxBuffer: 32 * 1024 * 1024,
     env: execEnv()
@@ -3409,7 +3707,7 @@ function copyIgnoredDependenciesInBackground(projectPath, worktreePath, entries)
     }
   })();
 }
-async function adoptRemoteBranch(projectPath, worktreePath, branch, base) {
+async function adoptRemoteBranch(projectPath, worktreePath, branch, base2) {
   try {
     await git(projectPath, ["fetch", "origin", branch]);
   } catch {
@@ -3431,32 +3729,32 @@ async function adoptRemoteBranch(projectPath, worktreePath, branch, base) {
   }
   const ignoredEntries = await copySmallIgnoredFiles(projectPath, worktreePath);
   copyIgnoredDependenciesInBackground(projectPath, worktreePath, ignoredEntries);
-  return { branch, worktreePath, pushed: true, baseBranch: base };
+  return { branch, worktreePath, pushed: true, baseBranch: base2 };
 }
 async function provisionWorktree(projectPath, workspacePath, taskId, baseBranch, preferredBranch, opts = {}) {
   await ensureLocalExclude(projectPath);
   const branch = opts.explicitBranch && preferredBranch ? preferredBranch : await resolveBranchName(projectPath, workspacePath, taskId, preferredBranch);
   const worktreePath = path12.join(workspacePath, worktreeDirName(branch));
   const info = await getGitInfo(projectPath);
-  const base = baseBranch || info.defaultBase || info.currentBranch || "HEAD";
+  const base2 = baseBranch || info.defaultBase || info.currentBranch || "HEAD";
   if (opts.explicitBranch && info.hasRemote && await remoteBranchExists(projectPath, branch)) {
-    return adoptRemoteBranch(projectPath, worktreePath, branch, base);
+    return adoptRemoteBranch(projectPath, worktreePath, branch, base2);
   }
-  let startPoint = base;
+  let startPoint = base2;
   if (info.hasRemote) {
     try {
-      await git(projectPath, ["fetch", "origin", `${base}:${base}`]);
+      await git(projectPath, ["fetch", "origin", `${base2}:${base2}`]);
     } catch {
       try {
-        await git(projectPath, ["fetch", "origin", base]);
+        await git(projectPath, ["fetch", "origin", base2]);
       } catch {
       }
     }
     try {
-      await git(projectPath, ["rev-parse", "--verify", `origin/${base}`]);
-      startPoint = `origin/${base}`;
+      await git(projectPath, ["rev-parse", "--verify", `origin/${base2}`]);
+      startPoint = `origin/${base2}`;
     } catch {
-      startPoint = base;
+      startPoint = base2;
     }
   }
   try {
@@ -3486,7 +3784,7 @@ async function provisionWorktree(projectPath, workspacePath, taskId, baseBranch,
     copySmallIgnoredFiles(projectPath, worktreePath)
   ]);
   copyIgnoredDependenciesInBackground(projectPath, worktreePath, ignoredEntries);
-  return { branch, worktreePath, pushed, baseBranch: base };
+  return { branch, worktreePath, pushed, baseBranch: base2 };
 }
 async function removeWorktree(projectPath, worktreePath) {
   try {
@@ -3698,7 +3996,7 @@ var MAX_OUTCOME_COMMITS = 50;
 var OUTCOME_LOG_FORMAT = "%h%x00%s";
 async function getOutcomePr(worktreePath) {
   try {
-    const { stdout } = await pexec(
+    const { stdout } = await pexec2(
       "gh",
       ["pr", "view", "--json", "url,number,state,title,body"],
       { cwd: worktreePath, env: execEnv() }
@@ -3759,7 +4057,7 @@ async function captureTaskOutcome(worktreePath, baseBranch) {
 }
 async function getPrStatus(worktreePath) {
   try {
-    const { stdout } = await pexec(
+    const { stdout } = await pexec2(
       "gh",
       ["pr", "view", "--json", "url,number,state"],
       { cwd: worktreePath, env: execEnv() }
@@ -3775,17 +4073,9 @@ async function getGithubCompareUrl(worktreePath, baseBranch) {
   try {
     const remoteUrl = await git(worktreePath, ["remote", "get-url", "origin"]);
     const branch = await git(worktreePath, ["rev-parse", "--abbrev-ref", "HEAD"]);
-    let webUrl;
-    const sshMatch = remoteUrl.match(/git@github\.com:(.+?)(?:\.git)?$/);
-    const httpsMatch = remoteUrl.match(/https?:\/\/github\.com\/(.+?)(?:\.git)?$/);
-    if (sshMatch) {
-      webUrl = `https://github.com/${sshMatch[1]}`;
-    } else if (httpsMatch) {
-      webUrl = `https://github.com/${httpsMatch[1]}`;
-    } else {
-      return null;
-    }
-    return `${webUrl}/compare/${baseBranch}...${branch}?expand=1`;
+    const repo = parseGithubRepo(remoteUrl);
+    if (!repo) return null;
+    return `https://github.com/${repo}/compare/${baseBranch}...${branch}?expand=1`;
   } catch {
     return null;
   }
@@ -3852,9 +4142,9 @@ function taskAttachmentStagingPath(workspacePath, taskId) {
 
 // packages/core/src/agents.ts
 init_env();
-import { execFile as execFile5 } from "child_process";
-import { promisify as promisify2 } from "util";
-var pexec2 = promisify2(execFile5);
+import { execFile as execFile6 } from "child_process";
+import { promisify as promisify3 } from "util";
+var pexec3 = promisify3(execFile6);
 var AGENT_EFFORTS = ["low", "medium", "high", "xhigh"];
 var DEFAULT_TASK_EFFORT = "medium";
 var AGENT_CLIS = [
@@ -3882,7 +4172,7 @@ var AGENT_CLIS = [
 async function commandExists(bin) {
   try {
     const command = process.platform === "win32" ? "where.exe" : "which";
-    await pexec2(command, [bin], {
+    await pexec3(command, [bin], {
       env: execEnv(),
       timeout: 2500,
       windowsHide: true
@@ -3957,7 +4247,8 @@ async function createTaskFromInput(input) {
     agentCli: input.agentCli ?? "claude",
     model: input.model || void 0,
     effort: input.effort ?? DEFAULT_TASK_EFFORT,
-    autoMode: input.autoMode
+    autoMode: input.autoMode,
+    ...input.github ? { github: input.github } : {}
   };
   try {
     const board = store.get("board");
@@ -4311,9 +4602,9 @@ function truncateUtf82(value, maxBytes) {
   return result;
 }
 function safeLibraryName(name) {
-  const basename2 = name.replace(/\\/g, "/").split("/").pop() ?? "";
+  const basename3 = name.replace(/\\/g, "/").split("/").pop() ?? "";
   const cleaned = truncateUtf82(
-    basename2.replace(/[\u0000-\u001f\u007f]/g, "").trim(),
+    basename3.replace(/[\u0000-\u001f\u007f]/g, "").trim(),
     MAX_NAME_BYTES
   );
   return cleaned && cleaned !== "." && cleaned !== ".." ? cleaned : "untitled";
@@ -4789,13 +5080,13 @@ import path21 from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 
 // packages/core/src/agent-models.ts
-import { execFile as execFile6 } from "child_process";
+import { execFile as execFile7 } from "child_process";
 import fs12 from "fs";
 import os4 from "os";
 import path16 from "path";
-import { promisify as promisify3 } from "util";
+import { promisify as promisify4 } from "util";
 init_env();
-var pexec3 = promisify3(execFile6);
+var pexec4 = promisify4(execFile7);
 var CODEX_MODELS_TIMEOUT_MS = 2e4;
 function builtinModels(id) {
   return (AGENT_CLIS.find((a) => a.id === id) ?? AGENT_CLIS[0]).models;
@@ -4805,7 +5096,7 @@ function defaultCodexHome() {
   return configured ? configured : path16.join(os4.homedir(), ".codex");
 }
 async function defaultRunCodexModels() {
-  const { stdout } = await pexec3("codex", ["debug", "models"], {
+  const { stdout } = await pexec4("codex", ["debug", "models"], {
     env: execEnv(),
     timeout: CODEX_MODELS_TIMEOUT_MS,
     maxBuffer: 16 * 1024 * 1024,
@@ -4862,10 +5153,10 @@ async function listAgentModels(id, opts = {}) {
 
 // packages/core/src/github-auth.ts
 init_env();
-import { execFile as execFile7 } from "child_process";
-import { promisify as promisify4 } from "util";
+import { execFile as execFile8 } from "child_process";
+import { promisify as promisify5 } from "util";
 import * as nodePty3 from "node-pty";
-var pexec4 = promisify4(execFile7);
+var pexec5 = promisify5(execFile8);
 var GITHUB_HOST = "github.com";
 var DEVICE_URL = "https://github.com/login/device";
 var activeLogin = null;
@@ -4900,7 +5191,7 @@ function errorMessage2(err) {
 }
 async function getGitHubCliAuthStatus() {
   try {
-    const { stdout } = await pexec4(
+    const { stdout } = await pexec5(
       "gh",
       ["auth", "status", "--hostname", GITHUB_HOST, "--json", "hosts"],
       {
@@ -4932,7 +5223,7 @@ async function logoutGitHubCli() {
   const status = await getGitHubCliAuthStatus();
   if (!status.installed) throw new Error("\u627E\u4E0D\u5230 GitHub CLI\uFF08gh\uFF09\u3002");
   if (!status.login) return status;
-  await pexec4(
+  await pexec5(
     "gh",
     ["auth", "logout", "--hostname", GITHUB_HOST, "--user", status.login],
     {
@@ -5184,7 +5475,7 @@ function clearMessages(taskId, newSessionId) {
 
 // packages/core/src/chat-session.ts
 init_attachments();
-function basename(p) {
+function basename2(p) {
   return p.split("/").pop() ?? p;
 }
 function truncate(s, n) {
@@ -5200,14 +5491,14 @@ function summarizeToolUse(name, input) {
       break;
     }
     case "Read":
-      summary = `Reading \`${basename(String(input.file_path ?? ""))}\``;
+      summary = `Reading \`${basename2(String(input.file_path ?? ""))}\``;
       break;
     case "Write":
-      summary = `Writing \`${basename(String(input.file_path ?? ""))}\``;
+      summary = `Writing \`${basename2(String(input.file_path ?? ""))}\``;
       break;
     case "Edit":
     case "MultiEdit":
-      summary = `Editing \`${basename(String(input.file_path ?? ""))}\``;
+      summary = `Editing \`${basename2(String(input.file_path ?? ""))}\``;
       break;
     case "Glob":
     case "Grep":
@@ -5765,7 +6056,7 @@ function validBoard(value) {
   }
   return next;
 }
-function createCore({ sessions, bus, version, homeDir }) {
+function createCore({ sessions, bus, version, homeDir, ghRunner, githubAuthStatus }) {
   const sink = bus.sink();
   let libraryCodexHome = null;
   void libraryRoot().then((root) => {
@@ -5907,6 +6198,11 @@ function createCore({ sessions, bus, version, homeDir }) {
     bus.emit("state:changed", getState());
   }
   let folderDialog = null;
+  const github = createGithubService({
+    run: ghRunner,
+    authStatus: githubAuthStatus ?? getGitHubCliAuthStatus,
+    repoOf: async (projectPath) => parseGithubRepo((await getGitInfo(projectPath)).remoteUrl)
+  });
   const handlers = {
     "vibeflow:getState": () => getState(),
     // A card's progress right now (todo list, usage, activity), for a frontend
@@ -5937,6 +6233,16 @@ function createCore({ sessions, bus, version, homeDir }) {
       cancelGitHubCliLogin();
     },
     "settings:logoutGithubAuth": () => logoutGitHubCli(),
+    // Open Issues/PRs of the board's GitHub repos that involve the signed-in
+    // `gh` user; cached per repo, `force` refetches.
+    "github:inbox": async (payload) => {
+      const p = payload === void 0 ? {} : obj(payload, "payload");
+      return github.inbox(getState().board, { force: p.force === true });
+    },
+    "github:taskLinks": async (payload) => {
+      const p = payload === void 0 ? {} : obj(payload, "payload");
+      return github.taskLinks(getState().board, { force: p.force === true });
+    },
     "env:detectAgents": () => detectAgents(),
     "agents:listModels": (payload) => {
       const { agentId: rawId, refresh } = obj(payload, "payload");
@@ -5966,6 +6272,7 @@ function createCore({ sessions, bus, version, homeDir }) {
       str(p.title ?? "", "title");
       if (p.effort !== void 0 && !AGENT_EFFORTS.includes(p.effort)) invalid("unknown effort");
       if (p.agentCli !== void 0 && !AGENT_IDS2.includes(p.agentCli)) invalid("unknown agent");
+      if (p.github !== void 0 && !isGithubRef(p.github)) invalid("github must be an issue or pr ref on github.com");
       const { task } = await createTaskFromInput({
         projectPath: p.projectPath,
         title: p.title,
@@ -5977,7 +6284,8 @@ function createCore({ sessions, bus, version, homeDir }) {
         model: p.model,
         effort: p.effort,
         autoMode: p.autoMode,
-        attachments: p.attachments
+        attachments: p.attachments,
+        github: p.github
       });
       return { state: getState(), task };
     },
@@ -6193,12 +6501,12 @@ function createCore({ sessions, bus, version, homeDir }) {
     },
     "task:getSpecs": async (taskId) => {
       const task = requireTask(taskId);
-      const base = task.baseBranch ?? "main";
-      if (task.worktreePath) return readWorktreeSpecs(task.worktreePath, base);
+      const base2 = task.baseBranch ?? "main";
+      if (task.worktreePath) return readWorktreeSpecs(task.worktreePath, base2);
       const since = task.provisionedAt ?? task.launchedAt ?? (task.pushed !== void 0 ? task.createdAt : void 0);
       if (!task.projectPath || !since) return [];
       const changed = task.outcome?.files.filter((f) => f.status !== "D").map((f) => f.path);
-      return readBranchSpecs(task.projectPath, task.branch, base, changed, since);
+      return readBranchSpecs(task.projectPath, task.branch, base2, changed, since);
     },
     "board:getCliLaunchInfo": () => boardCliLaunchInfo(),
     "library:list": async () => listLibrary(await libraryRoot(), builtinSkillsDir()),
@@ -6466,11 +6774,11 @@ function resolveStatic(root, urlPath) {
   }
   if (decoded.includes("\0")) return null;
   const rel = path22.posix.normalize(decoded).replace(/^\/+/, "");
-  const base = path22.resolve(root);
+  const base2 = path22.resolve(root);
   const candidates = [rel, path22.posix.join(rel, "index.html"), `${rel}.html`];
   for (const c of candidates) {
-    const full = path22.resolve(base, c);
-    if (full !== base && !full.startsWith(base + path22.sep)) return null;
+    const full = path22.resolve(base2, c);
+    if (full !== base2 && !full.startsWith(base2 + path22.sep)) return null;
     try {
       if (fs18.statSync(full).isFile()) return full;
     } catch {
@@ -6621,7 +6929,13 @@ Content-Length: 0\r
       });
     });
   }
-  const v4 = await listen("127.0.0.1", port);
+  let v4;
+  try {
+    v4 = await listen("127.0.0.1", port);
+  } catch (err) {
+    if (!options.fallbackToFreePort || port === 0 || err.code !== "EADDRINUSE") throw err;
+    v4 = await listen("127.0.0.1", 0);
+  }
   servers.push(v4);
   port = v4.address().port;
   try {
@@ -6639,6 +6953,7 @@ Content-Length: 0\r
 }
 
 // packages/cli/src/host.ts
+var DEFAULT_HOST_PORT = 47820;
 async function waitForPort(userDataDir, timeoutMs = 1e4) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
@@ -6697,7 +7012,8 @@ async function startHost(options) {
       bus,
       token: lock.token,
       staticDir: options.staticDir,
-      port: options.port
+      port: options.port ?? DEFAULT_HOST_PORT,
+      fallbackToFreePort: options.port === void 0
     });
     lock.port = server.port;
     updateLock(options.userDataDir, lock);
@@ -6837,12 +7153,12 @@ function connectToHost(lock) {
 // packages/cli/src/doctor.ts
 import fs20 from "fs";
 import path24 from "path";
-import { execFile as execFile8 } from "child_process";
-import { promisify as promisify5 } from "util";
+import { execFile as execFile9 } from "child_process";
+import { promisify as promisify6 } from "util";
 init_env();
 init_git_bash();
 init_tmux_backend();
-var pexec5 = promisify5(execFile8);
+var pexec6 = promisify6(execFile9);
 function parseVersion(text) {
   const m = /(\d+)\.(\d+)(?:\.(\d+))?/.exec(text);
   return m ? [Number(m[1]), Number(m[2]), Number(m[3] ?? 0)] : [];
@@ -6856,7 +7172,7 @@ function versionAtLeast(have, want) {
 }
 async function run2(cmd, args) {
   try {
-    const { stdout } = await pexec5(cmd, args, { env: execEnv(), timeout: 1e4, windowsHide: true });
+    const { stdout } = await pexec6(cmd, args, { env: execEnv(), timeout: 1e4, windowsHide: true });
     return String(stdout).trim();
   } catch {
     return null;
@@ -7025,7 +7341,7 @@ Options:
   --profile dev|prod       Store profile (dev = the "(development)" store npm run dev uses)
   --store-path <dir>       Explicit store directory
   --backend auto|tmux|pty  Session backend for a new host (default: auto = tmux when installed)
-  --port <n>               Port for a new host (default: random)
+  --port <n>               Port for a new host (default: 47820, or a free one when taken)
   --no-open                Do not open a browser
   --json                   Machine-readable output (status)
   -v, --version            Print the version