mintree 0.1.2

package/dist/commands/worktree/remove.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Box, Text } from "ink";
+import Spinner from "ink-spinner";
+import { argument, option } from "pastel";
+import { z } from "zod";
+import { runRemove } from "../../lib/worktreeRemove.js";
+export const description = "Remove a worktree (the branch and metadata are preserved so you can re-attach later)";
+export const args = z.tuple([
+    z.string().describe(argument({
+        name: "branch",
+        description: "Branch whose worktree should be removed (in the same `<type>/<issue>-<desc>` format)",
+    })),
+]);
+export const options = z.object({
+    force: z
+        .boolean()
+        .default(false)
+        .describe(option({
+        description: "Remove even if the worktree has uncommitted changes",
+    })),
+});
+export default function Remove({ args, options }) {
+    const [branch] = args;
+    const [result, setResult] = useState(null);
+    useEffect(() => {
+        setTimeout(() => {
+            try {
+                setResult(runRemove(branch, options.force));
+            }
+            catch (err) {
+                setResult({
+                    ok: false,
+                    message: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }, 0);
+    }, [branch, options.force]);
+    if (!result) {
+        return (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { children: [" Removing worktree for ", branch, "..."] })] }));
+    }
+    if (!result.ok) {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", result.message] }), result.hint && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "yellow", children: ["\u21B3 ", result.hint] }) }))] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "mintree worktree remove" }), _jsxs(Text, { dimColor: true, children: [" \u00B7 ", result.branch] })] }), result.variant === "pruned-orphan" ? (_jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: "!" }), " worktree directory was already deleted; pruned the dangling reference"] })) : (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { color: "green", children: "\u2713" }), " removed", " ", _jsxs(Text, { dimColor: true, children: ["(", result.worktreePath, ")"] })] }), result.wasDirty && (_jsx(Text, { color: "yellow", children: "\u21B3 forced past uncommitted changes" }))] })), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["Branch ", _jsx(Text, { color: "cyan", children: result.branch }), " was preserved (use `git branch -D", " ", result.branch, "` to delete it)."] }), _jsx(Text, { dimColor: true, children: "Issue metadata (incl. session_id) was preserved for re-attach." })] })] }));
+}

package/dist/commands/worktree/work.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const description = "Launch Claude in the current worktree (creates or resumes a session)";
+export declare const options: z.ZodObject<{
+    prompt: z.ZodOptional<z.ZodString>;
+    promptFile: z.ZodOptional<z.ZodString>;
+    permissionMode: z.ZodDefault<z.ZodEnum<{
+        default: "default";
+        auto: "auto";
+    }>>;
+}, z.core.$strip>;
+type Props = {
+    options: z.infer<typeof options>;
+};
+export default function Work({ options }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/commands/worktree/work.js

@@ -0,0 +1,192 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Box, Text } from "ink";
+import Spinner from "ink-spinner";
+import { option } from "pastel";
+import { z } from "zod";
+import { randomUUID } from "crypto";
+import { readFileSync, unlinkSync } from "fs";
+import * as path from "path";
+import { parseBranch, isParseError } from "../../lib/branch.js";
+import { findMainRepoRoot, getMintreeDir, getWorktreesDir, getCurrentBranch, pathExists, } from "../../lib/git.js";
+import { getSessionId, setSessionId } from "../../lib/metadata.js";
+import { launchClaude, PERMISSION_MODES } from "../../lib/claude.js";
+export const description = "Launch Claude in the current worktree (creates or resumes a session)";
+export const options = z.object({
+    prompt: z
+        .string()
+        .optional()
+        .describe(option({
+        description: "Initial prompt injected as the first user message (literal, no templating)",
+    })),
+    promptFile: z
+        .string()
+        .optional()
+        .describe(option({
+        description: "Read prompt from this file (deleted after read). Used by `worktree create --work` to bridge text from the create marker. Mutually exclusive with --prompt.",
+    })),
+    permissionMode: z
+        .enum(PERMISSION_MODES)
+        .default("default")
+        .describe(option({
+        description: `Claude --permission-mode (one of: ${PERMISSION_MODES.join(", ")})`,
+        alias: "m",
+    })),
+});
+function resolve(cwd) {
+    const repoRoot = findMainRepoRoot(cwd);
+    if (!repoRoot) {
+        return {
+            ok: false,
+            message: "Not in a git repository.",
+            hint: "Run `mintree worktree work` from inside a mintree worktree.",
+        };
+    }
+    if (!pathExists(getMintreeDir(repoRoot))) {
+        return {
+            ok: false,
+            message: ".mintree/ not found in this repo.",
+            hint: "Run `mintree init` first.",
+        };
+    }
+    const worktreesDir = path.resolve(getWorktreesDir(repoRoot));
+    const cwdAbs = path.resolve(cwd);
+    const insideMintreeWorktree = cwdAbs === worktreesDir
+        ? false
+        : cwdAbs.startsWith(worktreesDir + path.sep);
+    if (!insideMintreeWorktree) {
+        return {
+            ok: false,
+            message: "This directory isn't a mintree worktree.",
+            hint: "Run `mintree worktree work` from inside `.mintree/worktrees/<issue>-<desc>`.",
+        };
+    }
+    const branch = getCurrentBranch(cwdAbs);
+    if (!branch) {
+        return {
+            ok: false,
+            message: "Could not determine the current branch (detached HEAD?)",
+        };
+    }
+    const parsed = parseBranch(branch);
+    if (isParseError(parsed)) {
+        return {
+            ok: false,
+            message: `Branch '${branch}' does not match the mintree convention.`,
+            hint: parsed.hint,
+        };
+    }
+    // The worktree path that git knows about is the *root* of this checkout.
+    // Walk up from cwd until we land directly under .mintree/worktrees/<name>.
+    const segmentBeneathWorktreesDir = cwdAbs.slice(worktreesDir.length + 1).split(path.sep)[0];
+    const worktreePath = segmentBeneathWorktreesDir
+        ? path.join(worktreesDir, segmentBeneathWorktreesDir)
+        : cwdAbs;
+    const existing = getSessionId(repoRoot, parsed.issueId);
+    let sessionId;
+    let resume;
+    if (existing) {
+        sessionId = existing;
+        resume = true;
+    }
+    else {
+        sessionId = randomUUID();
+        setSessionId(repoRoot, parsed.issueId, sessionId);
+        resume = false;
+    }
+    return {
+        ok: true,
+        data: {
+            repoRoot,
+            worktreePath,
+            branch,
+            issueId: parsed.issueId,
+            sessionId,
+            resume,
+        },
+    };
+}
+export default function Work({ options }) {
+    const [state, setState] = useState({ phase: "loading" });
+    useEffect(() => {
+        // Defer one tick so the spinner gets to render before sync work starts.
+        setTimeout(() => {
+            if (options.prompt && options.promptFile) {
+                setState({
+                    phase: "error",
+                    message: "--prompt and --prompt-file are mutually exclusive.",
+                });
+                return;
+            }
+            const result = resolve(process.cwd());
+            if (!result.ok) {
+                setState({ phase: "error", message: result.message, hint: result.hint });
+                return;
+            }
+            setState({ phase: "launching", resolved: result.data });
+        }, 0);
+    }, []);
+    useEffect(() => {
+        if (state.phase !== "launching")
+            return;
+        const { resolved } = state;
+        // --prompt-file handling: read once, delete the file. The file is the
+        // transport between `worktree create --work --prompt` and us — both
+        // sides own its cleanup so even a crash mid-handoff doesn't leave junk
+        // in /tmp forever (OS sweeps tmpdir eventually anyway).
+        let effectivePrompt = options.prompt;
+        if (options.promptFile) {
+            try {
+                effectivePrompt = readFileSync(options.promptFile, "utf-8");
+            }
+            catch {
+                // Missing/unreadable — fall through with no prompt.
+            }
+            try {
+                unlinkSync(options.promptFile);
+            }
+            catch {
+                // Cleanup failure is non-fatal.
+            }
+        }
+        try {
+            const child = launchClaude({
+                permissionMode: options.permissionMode,
+                sessionId: resolved.sessionId,
+                resume: resolved.resume,
+                prompt: effectivePrompt,
+                cwd: resolved.worktreePath,
+            });
+            child.on("error", (err) => {
+                setState({
+                    phase: "error",
+                    message: `Failed to launch claude: ${err.message}`,
+                });
+            });
+            child.on("close", (code) => {
+                process.exit(code ?? 0);
+            });
+        }
+        catch (err) {
+            setState({
+                phase: "error",
+                message: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }, [state.phase, options.permissionMode, options.prompt]);
+    if (state.phase === "loading") {
+        return (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { children: " Resolving worktree..." })] }));
+    }
+    if (state.phase === "error") {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", state.message] }), state.hint && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "yellow", children: ["\u21B3 ", state.hint] }) }))] }));
+    }
+    const { resolved } = state;
+    const sessionShort = resolved.sessionId.slice(0, 8);
+    const action = resolved.resume ? "resuming" : "starting";
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "mintree worktree work" }), _jsxs(Text, { dimColor: true, children: [" \u00B7 ", resolved.branch] })] }), _jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "session: " }), _jsxs(Text, { children: [sessionShort, "\u2026"] }), _jsxs(Text, { dimColor: true, children: [" (", action, ")"] })] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "permission-mode: " }), _jsx(Text, { children: options.permissionMode })] }), options.prompt && (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "initial prompt: " }), _jsxs(Text, { children: ["\"", truncate(options.prompt, 60), "\""] })] })), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "cwd: " }), _jsx(Text, { dimColor: true, children: resolved.worktreePath })] })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "green", bold: true, children: "\u2713 Launching Claude..." }) })] }));
+}
+function truncate(s, max) {
+    if (s.length <= max)
+        return s;
+    return s.slice(0, max - 1) + "…";
+}

package/dist/lib/branch.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Branch convention enforced by mintree:
+ *
+ *     <type>/<issue>-<kebab-desc>
+ *
+ * `<type>` is one of the 11 conventional prefixes; `<issue>` is the GitHub
+ * issue number (digits only, no `#`); `<desc>` is lower-case kebab-case.
+ *
+ * Examples that PARSE: feat/100-readme-update, fix/55-upload-timeout
+ * Examples that REJECT: feat/abc-foo, /100-foo, gh-100-foo, feat/100, feat/100-FooBar
+ */
+export declare const ALLOWED_TYPES: readonly ["feat", "fix", "docs", "chore", "refactor", "test", "build", "ci", "perf", "style", "revert"];
+export type BranchType = (typeof ALLOWED_TYPES)[number];
+export type ParsedBranch = {
+    branch: string;
+    type: BranchType;
+    issueId: string;
+    desc: string;
+    worktreeDirName: string;
+};
+export type ParseError = {
+    error: string;
+    hint: string;
+};
+export declare function parseBranch(branch: string): ParsedBranch | ParseError;
+export declare function isParseError(result: ParsedBranch | ParseError): result is ParseError;

package/dist/lib/branch.js

@@ -0,0 +1,57 @@
+/**
+ * Branch convention enforced by mintree:
+ *
+ *     <type>/<issue>-<kebab-desc>
+ *
+ * `<type>` is one of the 11 conventional prefixes; `<issue>` is the GitHub
+ * issue number (digits only, no `#`); `<desc>` is lower-case kebab-case.
+ *
+ * Examples that PARSE: feat/100-readme-update, fix/55-upload-timeout
+ * Examples that REJECT: feat/abc-foo, /100-foo, gh-100-foo, feat/100, feat/100-FooBar
+ */
+export const ALLOWED_TYPES = [
+    "feat",
+    "fix",
+    "docs",
+    "chore",
+    "refactor",
+    "test",
+    "build",
+    "ci",
+    "perf",
+    "style",
+    "revert",
+];
+const BRANCH_REGEX = /^([a-z]+)\/(\d+)-([a-z0-9][a-z0-9-]*)$/;
+export function parseBranch(branch) {
+    const match = BRANCH_REGEX.exec(branch);
+    if (!match) {
+        return {
+            error: `Invalid branch name: ${branch}`,
+            hint: "Expected `<type>/<issue>-<kebab-desc>`. Example: feat/100-claude-md-inicial",
+        };
+    }
+    const [, type, issueId, desc] = match;
+    if (!type || !issueId || !desc) {
+        return {
+            error: `Invalid branch name: ${branch}`,
+            hint: "Expected `<type>/<issue>-<kebab-desc>`. Example: feat/100-claude-md-inicial",
+        };
+    }
+    if (!ALLOWED_TYPES.includes(type)) {
+        return {
+            error: `Unknown branch type \`${type}\``,
+            hint: `Allowed types: ${ALLOWED_TYPES.join(", ")}`,
+        };
+    }
+    return {
+        branch,
+        type: type,
+        issueId,
+        desc,
+        worktreeDirName: `${issueId}-${desc}`,
+    };
+}
+export function isParseError(result) {
+    return "error" in result;
+}

package/dist/lib/claude.d.ts

@@ -0,0 +1,26 @@
+import { type ChildProcess } from "child_process";
+export declare const PERMISSION_MODES: readonly ["default", "auto"];
+export type PermissionMode = (typeof PERMISSION_MODES)[number];
+/**
+ * Resolves the absolute path of the Claude Code CLI binary, or null if not on
+ * PATH. Falls back to ~/.claude/local/claude (the Anthropic installer
+ * location) when PATH lookup fails — this is the single most common reason a
+ * Node child sees "claude not found" while the user sees it on the shell.
+ */
+export declare function resolveClaudeBinary(): string | null;
+export type LaunchClaudeOptions = {
+    permissionMode: PermissionMode;
+    sessionId: string;
+    resume: boolean;
+    prompt?: string;
+    cwd: string;
+};
+/**
+ * Spawns the Claude CLI with stdio inherited so the child takes over the TTY.
+ * The session is started fresh with `--session-id` or resumed with `--resume`
+ * depending on `resume`. Returns the ChildProcess so the caller can wire
+ * exit/error handlers.
+ *
+ * Throws if the claude binary is not resolvable.
+ */
+export declare function launchClaude(options: LaunchClaudeOptions): ChildProcess;

package/dist/lib/claude.js

@@ -0,0 +1,67 @@
+import { execSync, spawn } from "child_process";
+import { existsSync, writeFileSync } from "fs";
+import { homedir, tmpdir } from "os";
+import { join } from "path";
+export const PERMISSION_MODES = ["default", "auto"];
+/**
+ * Resolves the absolute path of the Claude Code CLI binary, or null if not on
+ * PATH. Falls back to ~/.claude/local/claude (the Anthropic installer
+ * location) when PATH lookup fails — this is the single most common reason a
+ * Node child sees "claude not found" while the user sees it on the shell.
+ */
+export function resolveClaudeBinary() {
+    try {
+        const out = execSync("which claude", { stdio: ["ignore", "pipe", "ignore"] })
+            .toString()
+            .trim();
+        if (out)
+            return out;
+    }
+    catch {
+        // fall through
+    }
+    const local = join(homedir(), ".claude", "local", "claude");
+    if (existsSync(local))
+        return local;
+    return null;
+}
+// macOS ARG_MAX is 256KB; leave room for env vars.
+const ARG_MAX_SAFE = 200 * 1024;
+/**
+ * If `prompt` fits in argv, returns it as-is. Otherwise writes it to a temp
+ * file and returns a short instruction the agent can follow to read it. This
+ * keeps the launch flow safe against very long prompts without forcing
+ * callers to handle the spill case.
+ */
+function promptArg(prompt) {
+    if (Buffer.byteLength(prompt) <= ARG_MAX_SAFE)
+        return prompt;
+    const filePath = join(tmpdir(), `mintree-prompt-${Date.now()}.md`);
+    writeFileSync(filePath, prompt);
+    return `Read ${filePath} and follow the instructions inside.`;
+}
+/**
+ * Spawns the Claude CLI with stdio inherited so the child takes over the TTY.
+ * The session is started fresh with `--session-id` or resumed with `--resume`
+ * depending on `resume`. Returns the ChildProcess so the caller can wire
+ * exit/error handlers.
+ *
+ * Throws if the claude binary is not resolvable.
+ */
+export function launchClaude(options) {
+    const bin = resolveClaudeBinary();
+    if (!bin) {
+        throw new Error("Claude CLI not found. Install it with: npm install -g @anthropic-ai/claude-code");
+    }
+    const args = ["--permission-mode", options.permissionMode];
+    if (options.resume) {
+        args.push("--resume", options.sessionId);
+    }
+    else {
+        args.push("--session-id", options.sessionId);
+    }
+    if (options.prompt && options.prompt.length > 0) {
+        args.push("--", promptArg(options.prompt));
+    }
+    return spawn(bin, args, { stdio: "inherit", cwd: options.cwd });
+}

package/dist/lib/dashboard.d.ts

@@ -0,0 +1,50 @@
+import { type AheadBehind } from "./git.js";
+export type GhIssue = {
+    number: number;
+    title: string;
+    state: string;
+    url: string;
+    labels: {
+        name: string;
+    }[];
+    body: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type WorktreeInfo = {
+    path: string;
+    branch: string;
+    dirty: boolean;
+    ab: AheadBehind | null;
+    sessionId?: string;
+};
+export type SessionStateValue = "active" | "idle" | "waiting" | "exited";
+export type SessionStateInfo = {
+    state: SessionStateValue;
+    at: string;
+    message: string | null;
+};
+export type PrInfo = {
+    number: number;
+    state: "OPEN" | "CLOSED" | "MERGED";
+    url: string;
+};
+export type DashboardIssue = {
+    issue: GhIssue;
+    worktree: WorktreeInfo | null;
+    session: SessionStateInfo | null;
+    pr: PrInfo | null;
+};
+/**
+ * Fetches open issues assigned to the authenticated GitHub user for the
+ * current cwd's repo. Returns null when `gh` isn't authenticated, the cwd
+ * isn't a GitHub repo, or the API call fails — the caller surfaces the
+ * appropriate hint.
+ */
+export declare function fetchAssignedIssues(): Promise<GhIssue[] | null>;
+/**
+ * Top-level loader: enriches each assigned issue with its worktree and
+ * session snapshot. Designed to be called on dashboard mount and on every
+ * `r` refresh — cheap because all the per-worktree probes are local.
+ */
+export declare function loadDashboard(repoRoot: string): Promise<DashboardIssue[] | null>;

package/dist/lib/dashboard.js

@@ -0,0 +1,139 @@
+import * as fs from "fs";
+import * as path from "path";
+import { tryExec } from "./exec.js";
+import { listWorktrees, getWorktreesDir, isDirty, getAheadBehind, } from "./git.js";
+import { readMetadata } from "./metadata.js";
+const ISSUE_LIST_LIMIT = 50;
+/**
+ * Fetches open issues assigned to the authenticated GitHub user for the
+ * current cwd's repo. Returns null when `gh` isn't authenticated, the cwd
+ * isn't a GitHub repo, or the API call fails — the caller surfaces the
+ * appropriate hint.
+ */
+export async function fetchAssignedIssues() {
+    const json = await tryExec(`gh issue list --assignee @me --state open --json number,title,state,url,labels,body,createdAt,updatedAt --limit ${ISSUE_LIST_LIMIT} 2>/dev/null`);
+    if (!json)
+        return null;
+    try {
+        const parsed = JSON.parse(json);
+        if (!Array.isArray(parsed))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Builds a map from issue id (number, as string) to the matching mintree
+ * worktree, parsing each branch with the same `<type>/<issue>-<desc>` regex
+ * the create command enforces. Worktrees with branches that don't follow
+ * the convention are simply skipped.
+ */
+function buildWorktreeIndex(repoRoot) {
+    const worktreesRoot = path.resolve(getWorktreesDir(repoRoot));
+    const branchRegex = /^[a-z]+\/(\d+)-/;
+    const index = new Map();
+    for (const w of listWorktrees(repoRoot)) {
+        if (!w.branch)
+            continue;
+        const wAbs = path.resolve(w.path);
+        if (wAbs !== worktreesRoot && !wAbs.startsWith(worktreesRoot + path.sep))
+            continue;
+        const m = w.branch.match(branchRegex);
+        const issueId = m && m[1] ? m[1] : null;
+        if (!issueId)
+            continue;
+        index.set(issueId, {
+            path: w.path,
+            branch: w.branch,
+            dirty: isDirty(w.path),
+            ab: getAheadBehind(w.path),
+        });
+    }
+    return index;
+}
+/**
+ * Reads the live state file written by the session-signal hooks. Returns null
+ * when the file doesn't exist, can't be parsed, or holds an unrecognised state
+ * value — the dashboard treats those as "no live session".
+ */
+function readSessionState(repoRoot, issueId) {
+    const file = path.join(repoRoot, ".mintree", "session-states", `${issueId}.json`);
+    if (!fs.existsSync(file))
+        return null;
+    try {
+        const data = JSON.parse(fs.readFileSync(file, "utf-8"));
+        const state = data?.state;
+        if (!isSessionState(state))
+            return null;
+        return {
+            state,
+            at: typeof data.at === "string" ? data.at : "",
+            message: typeof data.message === "string" ? data.message : null,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function isSessionState(v) {
+    return v === "active" || v === "idle" || v === "waiting" || v === "exited";
+}
+function shQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+/**
+ * Looks up the most recent PR for a branch (any state). Returns null when
+ * there's no PR or `gh` can't reach the API. Used to populate the detail
+ * pane's "Pull Request" section.
+ */
+async function fetchPrForBranch(branch) {
+    const out = await tryExec(`gh pr list --head ${shQuote(branch)} --state all --json number,state,url --limit 1 2>/dev/null`);
+    if (!out)
+        return null;
+    try {
+        const arr = JSON.parse(out);
+        if (Array.isArray(arr) && arr.length > 0 && arr[0])
+            return arr[0];
+    }
+    catch {
+        // fall through
+    }
+    return null;
+}
+/**
+ * Top-level loader: enriches each assigned issue with its worktree and
+ * session snapshot. Designed to be called on dashboard mount and on every
+ * `r` refresh — cheap because all the per-worktree probes are local.
+ */
+export async function loadDashboard(repoRoot) {
+    const issues = await fetchAssignedIssues();
+    if (!issues)
+        return null;
+    const worktreesByIssue = buildWorktreeIndex(repoRoot);
+    const metadata = readMetadata(repoRoot);
+    // Fetch PRs in parallel for branches that actually have a worktree —
+    // issues without one wouldn't have a branch on this user's repo, so we
+    // skip the per-issue gh call for them.
+    const prByBranch = new Map();
+    const prFetches = Array.from(worktreesByIssue.values()).map(async (w) => {
+        const pr = await fetchPrForBranch(w.branch);
+        if (pr)
+            prByBranch.set(w.branch, pr);
+    });
+    await Promise.all(prFetches);
+    return issues.map(issue => {
+        const issueId = String(issue.number);
+        const worktreeRaw = worktreesByIssue.get(issueId) ?? null;
+        const sessionId = metadata.issues[issueId]?.session_id;
+        const worktree = worktreeRaw ? { ...worktreeRaw, sessionId } : null;
+        const pr = worktree ? (prByBranch.get(worktree.branch) ?? null) : null;
+        return {
+            issue,
+            worktree,
+            session: readSessionState(repoRoot, issueId),
+            pr,
+        };
+    });
+}

package/dist/lib/exec.d.ts

@@ -0,0 +1,2 @@
+export declare function tryExec(command: string): Promise<string | null>;
+export declare function getPath(command: string): Promise<string | null>;

package/dist/lib/exec.js

@@ -0,0 +1,15 @@
+import { exec } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+export async function tryExec(command) {
+    try {
+        const { stdout } = await execAsync(command);
+        return stdout.trim();
+    }
+    catch {
+        return null;
+    }
+}
+export async function getPath(command) {
+    return tryExec(`which ${command}`);
+}