@solaqua/gji 0.11.0 → 0.12.0

package/dist/go.d.ts

@@ -5,6 +5,7 @@ export interface GoCommandOptions {
     json?: boolean;
     print?: boolean;
     root?: boolean;
+    quiet?: boolean;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }

package/dist/go.js

@@ -2,6 +2,7 @@ import { basename } from "node:path";
 import { confirm, isCancel } from "@clack/prompts";
 import { runBackCommand } from "./back.js";
 import { loadEffectiveConfig } from "./config.js";
+import { renderContextCard } from "./context-card.js";
 import { resolveGoBranch } from "./go-resolver.js";
 import { isHeadless } from "./headless.js";
 import { recordWorktreeUsage } from "./history.js";
@@ -11,6 +12,7 @@ import { runNewCommand } from "./new.js";
 import { runPrCommand } from "./pr.js";
 import { detectRepository, listWorktrees, } from "./repo.js";
 import { writeShellOutput } from "./shell-handoff.js";
+import { getWorktreeSlot } from "./slots.js";
 import { buildWorktreePromptEntries, promptForSingleWorktree, } from "./worktree-picker.js";
 import { listRegisteredWorktreeSources } from "./worktree-sources.js";
 const GO_OUTPUT_FILE_ENV = "GJI_GO_OUTPUT_FILE";
@@ -207,7 +209,13 @@ async function navigateToExistingWorktree(options, path, worktree) {
         branch: worktree?.branch ?? undefined,
         path,
         repo: basename(repository.repoRoot),
+        slot: await getWorktreeSlot(path),
     }, options.stderr);
+    if (!options.quiet) {
+        const card = await renderContextCard(path);
+        if (card)
+            options.stderr(`${card}\n`);
+    }
     await recordWorktreeUsage(path, worktree?.branch ?? null);
     await writeShellOutput(GO_OUTPUT_FILE_ENV, path, options.stdout);
     return 0;

package/dist/hooks.d.ts

@@ -8,6 +8,7 @@ export interface HookContext {
     branch?: string;
     path: string;
     repo: string;
+    slot?: number | null;
 }
 export declare function runHook(hookCmd: GjiHookCommand | undefined, cwd: string, context: HookContext, stderr: (chunk: string) => void, stdout?: (chunk: string) => void): Promise<void>;
 export declare function interpolate(template: string, context: HookContext): string;

package/dist/hooks.js

@@ -72,6 +72,9 @@ function hookEnvironment(context) {
         GJI_BRANCH: context.branch ?? "",
         GJI_PATH: context.path,
         GJI_REPO: context.repo,
+        ...(context.slot === null || context.slot === undefined
+            ? {}
+            : { GJI_SLOT: String(context.slot) }),
     };
 }
 function formatArgvHook(command, args) {
@@ -81,7 +84,10 @@ export function interpolate(template, context) {
     return template
         .replace(/\{\{branch\}\}/g, context.branch ?? "")
         .replace(/\{\{path\}\}/g, context.path)
-        .replace(/\{\{repo\}\}/g, context.repo);
+        .replace(/\{\{repo\}\}/g, context.repo)
+        .replace(/\{\{slot\}\}/g, context.slot === null || context.slot === undefined
+        ? ""
+        : String(context.slot));
 }
 export function extractHooks(config) {
     const raw = config.hooks;

package/dist/hub.d.ts

@@ -0,0 +1,31 @@
+import { type PullRequestInfo } from "./pull-requests.js";
+import { type WorktreeInfo } from "./worktree-info.js";
+export interface HubCommandOptions {
+    cwd: string;
+    columns?: number;
+    json?: boolean;
+    now?: number;
+    stderr: (chunk: string) => void;
+    stdout: (chunk: string) => void;
+}
+export interface HubCommandDependencies {
+    queryRepositoryPullRequests: (repoRoot: string) => Promise<PullRequestInfo[]>;
+}
+export interface HubWorktree extends WorktreeInfo {
+    lastUsedTimestamp: number | null;
+    pullRequests: PullRequestInfo[];
+}
+export interface HubRepository {
+    current: boolean;
+    name: string;
+    pullRequests: PullRequestInfo[];
+    root: string;
+    worktrees: HubWorktree[];
+}
+export interface HubData {
+    currentRepository: string | null;
+    repositories: HubRepository[];
+}
+export declare function buildHubData(cwd: string, dependencies?: Partial<HubCommandDependencies>): Promise<HubData>;
+export declare function runHubCommand(options: HubCommandOptions, dependencies?: Partial<HubCommandDependencies>): Promise<number>;
+export declare function formatHubOutput(data: HubData, columns?: number, now?: number): string;

package/dist/hub.js

@@ -0,0 +1,287 @@
+import { basename } from "node:path";
+import { loadHistory } from "./history.js";
+import { createPullRequestQuery, } from "./pull-requests.js";
+import { detectRepository } from "./repo.js";
+import { middleEllipsize, sanitizeTerminalText, terminalWidth, } from "./terminal-text.js";
+import { formatRelativeAge, formatUpstreamState, readWorktreeInfos, } from "./worktree-info.js";
+import { listDiscoverableWorktreeSources } from "./worktree-sources.js";
+const MAX_HUB_REPOSITORY_CONCURRENCY = 4;
+const defaultDependencies = {
+    queryRepositoryPullRequests: createPullRequestQuery().listOpenPullRequestsForRepository,
+};
+export async function buildHubData(cwd, dependencies = {}) {
+    const queryRepositoryPullRequests = dependencies.queryRepositoryPullRequests ??
+        defaultDependencies.queryRepositoryPullRequests;
+    const currentRepository = await detectRepository(cwd).catch(() => null);
+    const history = await loadHistory();
+    const lastUsedByPath = new Map(history.map((entry) => [entry.path, entry.timestamp]));
+    const sources = await listDiscoverableWorktreeSources(cwd);
+    const groups = new Map();
+    for (const source of sources) {
+        if (!source.repoRoot)
+            continue;
+        const repoRoot = source.repoRoot;
+        const existing = groups.get(repoRoot);
+        if (existing) {
+            existing.sources.push(source);
+        }
+        else {
+            groups.set(repoRoot, {
+                name: source.repoName || basename(repoRoot),
+                sources: [source],
+            });
+        }
+    }
+    const repositories = await mapWithConcurrency([...groups.entries()], MAX_HUB_REPOSITORY_CONCURRENCY, async ([root, group]) => {
+        const infos = await readWorktreeInfos(group.sources.map((source) => source.worktree));
+        let pullRequests = [];
+        try {
+            pullRequests = await queryRepositoryPullRequests(root);
+        }
+        catch {
+            // PR metadata is optional. The hub remains useful when a provider is unavailable.
+        }
+        const worktrees = infos.map((info) => ({
+            ...info,
+            lastUsedTimestamp: lastUsedByPath.get(info.path) ?? null,
+            pullRequests: pullRequests.filter((pullRequest) => pullRequest.sourceBranch === info.branch),
+        }));
+        return {
+            current: currentRepository?.repoRoot === root,
+            name: group.name,
+            pullRequests,
+            root,
+            worktrees,
+        };
+    });
+    repositories.sort((left, right) => {
+        if (left.current !== right.current)
+            return left.current ? -1 : 1;
+        return left.name.localeCompare(right.name);
+    });
+    return {
+        currentRepository: currentRepository?.repoRoot ?? null,
+        repositories,
+    };
+}
+export async function runHubCommand(options, dependencies = {}) {
+    const data = await buildHubData(options.cwd, dependencies);
+    if (options.json) {
+        options.stdout(`${JSON.stringify(data, null, 2)}\n`);
+        return 0;
+    }
+    options.stdout(`${formatHubOutput(data, options.columns ?? process.stdout.columns ?? 80, options.now ?? Date.now())}\n`);
+    return 0;
+}
+export function formatHubOutput(data, columns = process.stdout.columns ?? 80, now = Date.now()) {
+    if (data.repositories.length === 0) {
+        return "No registered repositories. Run gji from a repository to add one.";
+    }
+    const lineWidth = Math.max(1, columns);
+    const allWorktrees = data.repositories.flatMap((repository) => repository.worktrees.map((worktree) => ({ repository, worktree })));
+    const attention = allWorktrees.filter(({ worktree }) => isActionable(worktree));
+    const current = allWorktrees.find(({ worktree }) => worktree.isCurrent) ?? null;
+    const next = chooseNextWorktree(allWorktrees);
+    const remainingAttention = attention.filter((entry) => entry !== current && entry !== next);
+    const quiet = allWorktrees.filter((entry) => entry !== current && entry !== next && !attention.includes(entry));
+    const recentOther = [...quiet]
+        .sort((left, right) => (right.worktree.lastCommitTimestamp ?? 0) -
+        (left.worktree.lastCommitTimestamp ?? 0))
+        .slice(0, 5);
+    const hiddenCount = quiet.length - recentOther.length;
+    const lines = [
+        `GJI  ${data.repositories.length} repositories · ${allWorktrees.length} worktrees${attention.length > 0 ? ` · ${attention.length} need attention` : ""}`,
+        "",
+    ];
+    if (data.repositories.length > 1) {
+        lines.push("REPOSITORIES");
+        for (const repository of data.repositories) {
+            lines.push(formatRepositorySummary(repository, lineWidth));
+        }
+        lines.push("");
+    }
+    if (current !== null) {
+        lines.push("CURRENT");
+        lines.push(...formatHubWorktree(current, lineWidth, "@", now));
+        lines.push("");
+    }
+    if (next !== null && next !== current) {
+        lines.push("NEXT");
+        lines.push(...formatHubWorktree(next, lineWidth, "›", now));
+        lines.push("");
+    }
+    if (remainingAttention.length > 0) {
+        lines.push("ATTENTION");
+        for (const entry of remainingAttention) {
+            lines.push(...formatHubWorktree(entry, lineWidth, "!", now));
+        }
+        lines.push("");
+    }
+    if (recentOther.length > 0) {
+        lines.push("OTHER");
+        for (const entry of recentOther) {
+            lines.push(...formatHubWorktree(entry, lineWidth, " ", now));
+        }
+        if (hiddenCount > 0) {
+            lines.push(`  ${hiddenCount} quiet worktree${hiddenCount === 1 ? "" : "s"} hidden`);
+        }
+        lines.push("");
+    }
+    if (next === null &&
+        remainingAttention.length === 0 &&
+        recentOther.length === 0) {
+        lines.push("No active worktrees.");
+    }
+    lines.push("Run `gji go <repo>/<branch>` to switch worktrees.");
+    return lines
+        .map((line) => terminalWidth(line) > lineWidth ? middleEllipsize(line, lineWidth) : line)
+        .join("\n")
+        .trimEnd();
+}
+function formatRepositorySummary(repository, lineWidth) {
+    const attentionCount = repository.worktrees.filter(isActionable).length;
+    const attention = attentionCount === 0 ? "healthy" : `${attentionCount} attention`;
+    const marker = repository.current ? "*" : " ";
+    return middleEllipsize(`${marker} ${repository.name} · ${repository.worktrees.length} worktree${repository.worktrees.length === 1 ? "" : "s"} · ${attention}`, lineWidth);
+}
+function chooseNextWorktree(entries) {
+    return ([...entries].sort((left, right) => {
+        const scoreDifference = nextWorktreeScore(right) - nextWorktreeScore(left);
+        if (scoreDifference !== 0)
+            return scoreDifference;
+        const lastUsedDifference = (right.worktree.lastUsedTimestamp ?? 0) -
+            (left.worktree.lastUsedTimestamp ?? 0);
+        if (lastUsedDifference !== 0)
+            return lastUsedDifference;
+        return ((right.worktree.lastCommitTimestamp ?? 0) -
+            (left.worktree.lastCommitTimestamp ?? 0));
+    })[0] ?? null);
+}
+function nextWorktreeScore(entry) {
+    const { worktree } = entry;
+    let score = worktree.isCurrent && (worktree.task !== null || isActionable(worktree))
+        ? 100
+        : 0;
+    if (worktree.task !== null)
+        score += 40;
+    if (worktree.status === "dirty")
+        score += 30;
+    if (worktree.upstream.kind === "stale")
+        score += 25;
+    if (worktree.upstream.kind === "tracked" && worktree.upstream.behind > 0) {
+        score += 25;
+    }
+    if (worktree.pullRequests.length > 0)
+        score += 20;
+    if (worktree.lastUsedTimestamp !== null && worktree.lastUsedTimestamp > 0) {
+        score += 15;
+    }
+    return score;
+}
+function isActionable(worktree) {
+    return (worktree.status === "dirty" ||
+        worktree.upstream.kind === "stale" ||
+        (worktree.upstream.kind === "tracked" && worktree.upstream.behind > 0) ||
+        worktree.pullRequests.length > 0);
+}
+function formatHubWorktree(entry, lineWidth, marker, now) {
+    const { repository, worktree } = entry;
+    const branch = worktree.branch ?? "(detached)";
+    const status = [
+        formatWorktreeHealth(worktree),
+        formatWorktreeUpstream(worktree),
+        worktree.pullRequests.length > 0
+            ? worktree.pullRequests
+                .map((pullRequest) => pullRequest.title
+                ? `#${pullRequest.number} ${formatHumanText(pullRequest.title, 60)}`
+                : `#${pullRequest.number}`)
+                .join(", ")
+            : null,
+        formatWorktreeActivity(worktree, now),
+    ]
+        .filter((value) => value !== null)
+        .join(" · ");
+    const task = worktree.task === null
+        ? null
+        : `task: ${formatHumanText(worktree.task, 80)}`;
+    const target = `${repository.name}/${branch}`;
+    const lines = [`${marker} ${middleEllipsize(target, lineWidth - 2)}`];
+    if (status.length > 0) {
+        lines.push(`  ${middleEllipsize(status, lineWidth - 2)}`);
+    }
+    if (task !== null) {
+        lines.push(`  ${middleEllipsize(task, lineWidth - 2)}`);
+    }
+    if (marker === "@" || marker === "›" || marker === "!") {
+        lines.push(`  ${middleEllipsize(nextAction(worktree), lineWidth - 2)}`);
+    }
+    return lines;
+}
+function formatWorktreeHealth(worktree) {
+    if (worktree.status === "dirty")
+        return "! dirty";
+    if (worktree.status === "unknown")
+        return "? health unknown";
+    return null;
+}
+function formatWorktreeUpstream(worktree) {
+    if (worktree.upstream.kind === "stale")
+        return "! stale upstream";
+    if (worktree.upstream.kind === "tracked" &&
+        (worktree.upstream.behind > 0 || worktree.upstream.ahead > 0)) {
+        return formatUpstreamState(worktree.upstream);
+    }
+    return null;
+}
+function formatWorktreeActivity(worktree, now) {
+    if (worktree.isCurrent)
+        return null;
+    const timestamps = [
+        worktree.lastUsedTimestamp ?? 0,
+        (worktree.lastCommitTimestamp ?? 0) * 1000,
+    ].filter((timestamp) => timestamp > 0);
+    if (timestamps.length === 0)
+        return null;
+    const latest = Math.max(...timestamps);
+    const ageSeconds = Math.floor((now - latest) / 1000);
+    if (ageSeconds < 24 * 60 * 60)
+        return null;
+    return `inactive ${formatRelativeAge(Math.floor(latest / 1000), Math.floor(now / 1000))}`;
+}
+function nextAction(worktree) {
+    if (worktree.isCurrent && worktree.task !== null) {
+        return "next: continue task";
+    }
+    if (worktree.status === "dirty") {
+        return "next: switch → inspect changes";
+    }
+    if (worktree.upstream.kind === "stale" ||
+        (worktree.upstream.kind === "tracked" && worktree.upstream.behind > 0)) {
+        return "next: switch → sync";
+    }
+    const pullRequest = worktree.pullRequests[0];
+    if (pullRequest !== undefined) {
+        return `next: switch → open PR '#${pullRequest.number}'`;
+    }
+    return "next: switch worktree";
+}
+function formatHumanText(value, maxLength) {
+    const sanitized = sanitizeTerminalText(value);
+    return sanitized.length <= maxLength
+        ? sanitized
+        : `${sanitized.slice(0, Math.max(0, maxLength - 1))}…`;
+}
+async function mapWithConcurrency(items, limit, mapper) {
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    async function readNext() {
+        for (;;) {
+            const index = nextIndex++;
+            if (index >= items.length)
+                return;
+            results[index] = await mapper(items[index]);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => readNext()));
+    return results;
+}

package/dist/ls.js

@@ -26,12 +26,15 @@ export function formatDetailedWorktreeTable(worktrees) {
         lastCommit: formatLastCommit(worktree.lastCommitTimestamp),
         path: worktree.path,
         status: worktree.status,
+        task: worktree.task,
         upstream: formatUpstreamState(worktree.upstream),
     }));
     const branchWidth = Math.max("BRANCH".length, ...rows.map((row) => row.branch.length));
     const statusWidth = Math.max("STATUS".length, ...rows.map((row) => row.status.length));
     const upstreamWidth = Math.max("UPSTREAM".length, ...rows.map((row) => row.upstream.length));
     const lastCommitWidth = Math.max("LAST".length, ...rows.map((row) => row.lastCommit.length));
+    const hasTasks = rows.some((row) => row.task !== null);
+    const taskWidth = Math.max("TASK".length, ...rows.map((row) => row.task?.slice(0, 40).length ?? 0));
     const lines = [
         "  " +
             "BRANCH".padEnd(branchWidth, " ") +
@@ -41,6 +44,7 @@ export function formatDetailedWorktreeTable(worktrees) {
             "UPSTREAM".padEnd(upstreamWidth, " ") +
             " " +
             "LAST".padEnd(lastCommitWidth, " ") +
+            (hasTasks ? " " + "TASK".padEnd(taskWidth, " ") : "") +
             " PATH",
     ];
     for (const row of rows) {
@@ -48,7 +52,11 @@ export function formatDetailedWorktreeTable(worktrees) {
             `${row.branch.padEnd(branchWidth, " ")} ` +
             `${row.status.padEnd(statusWidth, " ")} ` +
             `${row.upstream.padEnd(upstreamWidth, " ")} ` +
-            `${row.lastCommit.padEnd(lastCommitWidth, " ")} ` +
+            `${row.lastCommit.padEnd(lastCommitWidth, " ")}` +
+            (hasTasks
+                ? ` ${(row.task?.slice(0, 40) ?? "").padEnd(taskWidth, " ")}`
+                : "") +
+            " " +
             row.path);
     }
     return lines.join("\n");

package/dist/new.d.ts

@@ -22,6 +22,7 @@ export interface NewCommandOptions {
     take?: boolean;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
+    task?: string;
 }
 export interface NewCommandDependencies extends InstallPromptDependencies, DependencyBootstrapPromptDependencies {
     cloneDir: CloneDirectory;

package/dist/new.js

@@ -18,6 +18,7 @@ import { createNavigationRepository, createNavigationTarget, } from "./navigatio
 import { detectRepository, resolveWorktreePath, validateBranchName, } from "./repo.js";
 import { writeShellOutput } from "./shell-handoff.js";
 import { estimateSyncDirectories } from "./sync-plan.js";
+import { writeTask } from "./task.js";
 import { bootstrapWorktree } from "./worktree-bootstrap.js";
 const execFileAsync = promisify(execFile);
 const NEW_OUTPUT_FILE_ENV = "GJI_NEW_OUTPUT_FILE";
@@ -319,6 +320,14 @@ export function createNewCommand(dependencies = {}) {
             }
             return emitNewError(options, `could not apply taken changes; your changes are safe in stash: ${stashSha}`);
         }
+        if (options.task !== undefined) {
+            try {
+                await writeTask(worktreePath, options.task);
+            }
+            catch (error) {
+                options.stderr(`Warning: could not save task metadata: ${error instanceof Error ? error.message : String(error)}\n`);
+            }
+        }
         const bootstrap = await bootstrapWorktree({
             branch: worktreeName,
             cloneDirectory,

package/dist/pr-open.js

@@ -130,7 +130,7 @@ async function openFromWorktreeSelector(repoRoot, repoName, options, promptForWo
     const entries = await buildWorktreePromptEntries(sources, {
         queryPullRequests: async (_root, branch) => pullRequestsByBranch.get(branch) ?? [],
     });
-    const connectedEntries = entries.filter((entry) => (entry.pullRequestNumbers?.length ?? 0) > 0);
+    const connectedEntries = entries.filter((entry) => (entry.pullRequests?.length ?? 0) > 0);
     if (connectedEntries.length === 0) {
         if (lookupError !== null) {
             options.stderr(`gji pr open: failed to look up open PRs: ${formatError(lookupError)}\n`);
@@ -225,15 +225,7 @@ async function openForBranch(repoRoot, branch, options, queryPullRequests, promp
     return openPullRequests(pullRequests, options, promptForPullRequest, openInBrowser);
 }
 async function openSelectedEntry(entry, options, promptForPullRequest, openInBrowser) {
-    const numbers = entry.pullRequestNumbers ?? [];
-    const urls = entry.pullRequestUrls ?? [];
-    const pullRequests = numbers
-        .map((number, index) => ({
-        number,
-        sourceBranch: entry.branch ?? "",
-        url: urls[index] ?? "",
-    }))
-        .filter((pullRequest) => pullRequest.url.length > 0);
+    const pullRequests = entry.pullRequests ?? [];
     return openPullRequests(pullRequests, options, promptForPullRequest, openInBrowser);
 }
 async function openPullRequests(pullRequests, options, promptForPullRequest, openInBrowser) {

package/dist/pull-requests.d.ts

@@ -2,6 +2,7 @@ export type PullRequestForge = "bitbucket" | "github" | "gitlab";
 export interface PullRequestInfo {
     number: number;
     sourceBranch: string;
+    title?: string;
     url: string;
 }
 export interface PullRequestRemote {

package/dist/pull-requests.js

@@ -2,6 +2,7 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
 const PULL_REQUEST_QUERY_TIMEOUT_MS = 2500;
+const PULL_REQUEST_CACHE_TTL_MS = 30_000;
 export function parsePullRequestRemote(remoteUrl) {
     const parsed = parseRemoteUrl(remoteUrl.trim());
     if (parsed === null)
@@ -46,10 +47,36 @@ export function parsePullRequestRemote(remoteUrl) {
 export function createPullRequestQuery(dependencies = {}) {
     const runCommand = dependencies.runCommand ?? defaultRunCommand;
     const fetcher = dependencies.fetch ?? fetch;
+    const repositoryCache = new Map();
+    const repositoryInFlight = new Map();
+    const listRepositoryPullRequests = (repoRoot) => {
+        const cached = repositoryCache.get(repoRoot);
+        if (cached !== undefined && cached.expiresAt > Date.now()) {
+            return Promise.resolve(cached.value);
+        }
+        const inFlight = repositoryInFlight.get(repoRoot);
+        if (inFlight !== undefined)
+            return inFlight;
+        const request = listOpenPullRequestsForRepository(repoRoot, runCommand, fetcher)
+            .then((value) => {
+            repositoryCache.set(repoRoot, {
+                expiresAt: Date.now() + PULL_REQUEST_CACHE_TTL_MS,
+                value,
+            });
+            repositoryInFlight.delete(repoRoot);
+            return value;
+        })
+            .catch((error) => {
+            repositoryInFlight.delete(repoRoot);
+            throw error;
+        });
+        repositoryInFlight.set(repoRoot, request);
+        return request;
+    };
     return {
         findOpenPullRequest: (repoRoot, number) => findOpenPullRequest(repoRoot, number, runCommand, fetcher),
         listOpenPullRequests: (repoRoot, sourceBranch) => listOpenPullRequests(repoRoot, sourceBranch, runCommand, fetcher),
-        listOpenPullRequestsForRepository: (repoRoot) => listOpenPullRequestsForRepository(repoRoot, runCommand, fetcher),
+        listOpenPullRequestsForRepository: listRepositoryPullRequests,
     };
 }
 async function listOpenPullRequests(repoRoot, sourceBranch, runCommand, fetcher) {
@@ -153,7 +180,7 @@ function providerCliCommand(remote, query) {
                         "view",
                         String(query.number),
                         "--json",
-                        "number,url,headRefName,state",
+                        "number,url,headRefName,title,state",
                         "--repo",
                         coordinate,
                     ],
@@ -168,7 +195,7 @@ function providerCliCommand(remote, query) {
                     "open",
                     ...(query.kind === "branch" ? ["--head", sourceBranch] : []),
                     "--json",
-                    "number,url,headRefName,state",
+                    "number,url,headRefName,title,state",
                     "--limit",
                     "100",
                     "--repo",
@@ -302,6 +329,7 @@ function normalizePullRequest(value, query) {
         (isRecord(value.links) && isRecord(value.links.html)
             ? value.links.html.href
             : undefined));
+    const title = stringValue(value.title);
     const state = stringValue(value.state)?.toLowerCase();
     if (number === null || url === null)
         return null;
@@ -314,6 +342,7 @@ function normalizePullRequest(value, query) {
     return {
         number,
         sourceBranch: sourceBranch ?? "",
+        ...(title === null ? {} : { title }),
         url,
     };
 }

package/dist/remove.js

@@ -4,6 +4,7 @@ import { loadEffectiveConfig } from "./config.js";
 import { isHeadless } from "./headless.js";
 import { extractHooks, runHook } from "./hooks.js";
 import { writeShellOutput } from "./shell-handoff.js";
+import { releaseWorktreeSlot } from "./slots.js";
 import { finalizeUndoOperation, recordUndoOperation } from "./undo.js";
 import { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isWorktreeForceRemovalError, loadLinkedWorktrees, removeWorktree, } from "./worktree-management.js";
 import { buildWorktreePromptEntries, promptForSingleWorktree, } from "./worktree-picker.js";
@@ -118,6 +119,7 @@ export function createRemoveCommand(dependencies = {}) {
             }
         }
         await finalizeUndoOperation(journal, [worktree]);
+        await releaseWorktreeSlot(worktree.path);
         if (worktree.branch) {
             try {
                 await deleteBranch(repository.repoRoot, worktree.branch);

package/dist/repo.d.ts

@@ -11,6 +11,7 @@ export interface WorktreeEntry {
     path: string;
 }
 export declare function detectRepository(cwd: string): Promise<RepositoryContext>;
+export declare function worktreeGitDir(worktreePath: string): Promise<string>;
 export declare function resolveWorktreePath(repoRoot: string, branch: string, basePath?: string): string;
 export declare function validateBranchName(name: string): string | null;
 export declare function hasLocalBranch(repoRoot: string, branch: string): Promise<boolean>;

package/dist/repo.js

@@ -17,6 +17,10 @@ export async function detectRepository(cwd) {
         repoRoot,
     };
 }
+export async function worktreeGitDir(worktreePath) {
+    const rawGitDir = await runGit(worktreePath, ["rev-parse", "--git-dir"]);
+    return isAbsolute(rawGitDir) ? rawGitDir : resolve(worktreePath, rawGitDir);
+}
 export function resolveWorktreePath(repoRoot, branch, basePath) {
     const segments = branch.split("/").filter(Boolean);
     if (segments.length === 0) {

package/dist/run-hook.js

@@ -1,6 +1,7 @@
 import { loadEffectiveConfig } from "./config.js";
 import { extractHooks, runHook } from "./hooks.js";
 import { detectRepository, listWorktrees } from "./repo.js";
+import { getWorktreeSlot } from "./slots.js";
 const VALID_HOOKS = [
     "after-create",
     "after-enter",
@@ -31,6 +32,7 @@ export async function runHookCommand(options) {
         branch: currentWorktree?.branch ?? undefined,
         path: repository.currentRoot,
         repo: repository.repoName,
+        slot: await getWorktreeSlot(repository.currentRoot),
     }, options.stderr);
     return 0;
 }