@solaqua/gji 0.12.5 → 0.14.0

package/README.md

@@ -22,6 +22,18 @@ directory. For repeatable workflows, you can still provide a branch directly:
 gji new feature/payment-refactor
 ```
 
+If you prefer to reuse the current worktree, create a branch in place and
+refresh the configured default branch first:
+
+```sh
+gji new --branch-only feature/payment-refactor
+```
+
+This creates the new branch from the latest configured remote default branch
+without creating another worktree or installing dependencies. The current
+worktree must be clean; use `--no-fetch` to create from the local default
+branch as-is.
+
 ## The problem
 
 You are halfway through a feature when someone asks you to review a pull

package/dist/application/worktree/catalog.d.ts

@@ -0,0 +1,31 @@
+import type { RepositoryContext } from "../../domain/repository/context.js";
+import type { WorktreeSource } from "../../domain/worktree/source.js";
+import type { WorktreeEntry } from "../../domain/worktree/types.js";
+import type { PullRequestInfo, PullRequestPort } from "../../ports/pull-requests.js";
+import type { RepositoryContextPort, WorktreePort } from "../../ports/repository.js";
+import type { WorktreeInfo } from "./read-models.js";
+export interface LinkedWorktreeContext {
+    linkedWorktrees: WorktreeEntry[];
+    repository: RepositoryContext;
+}
+export type WorktreeMetadataMode = "full" | "fast";
+export interface HydratedWorktree {
+    info: WorktreeInfo;
+    lastUsedTimestamp: number | null;
+    pullRequests: PullRequestInfo[];
+    source: WorktreeSource;
+}
+export interface WorktreeCatalogDependencies {
+    loadHistory: () => Promise<ReadonlyArray<{
+        path: string;
+        timestamp: number;
+    }>>;
+    readTask: (worktreePath: string) => Promise<{
+        task: string;
+    } | null>;
+    readWorktreeInfos: (worktrees: WorktreeEntry[]) => Promise<WorktreeInfo[]>;
+    queryPullRequests?: PullRequestPort["listOpenPullRequests"];
+    queryRepositoryPullRequests?: PullRequestPort["listOpenPullRequestsForRepository"];
+}
+export declare function loadWorktreeCatalog(sources: WorktreeSource[], metadata: WorktreeMetadataMode, dependencies: WorktreeCatalogDependencies): Promise<HydratedWorktree[]>;
+export declare function loadLinkedWorktrees(cwd: string, repositoryPort: RepositoryContextPort & WorktreePort): Promise<LinkedWorktreeContext>;

package/dist/application/worktree/catalog.js

@@ -0,0 +1,88 @@
+import { mapWithConcurrency } from "../../domain/shared/concurrency.js";
+const MAX_PULL_REQUEST_REPOSITORY_QUERY_CONCURRENCY = 4;
+const MAX_TASK_READ_CONCURRENCY = 8;
+export async function loadWorktreeCatalog(sources, metadata, dependencies) {
+    const includeMetadata = metadata === "full";
+    const repositoryPullRequests = includeMetadata && dependencies.queryRepositoryPullRequests !== undefined
+        ? readRepositoryPullRequests(sources, dependencies.queryRepositoryPullRequests)
+        : Promise.resolve(null);
+    const [history, infos, pullRequestsByRepository] = await Promise.all([
+        dependencies.loadHistory(),
+        includeMetadata
+            ? dependencies.readWorktreeInfos(sources.map((source) => source.worktree))
+            : mapWithConcurrency(sources, MAX_TASK_READ_CONCURRENCY, async (source) => createUnhydratedWorktreeInfo(source.worktree, dependencies.readTask)),
+        repositoryPullRequests,
+    ]);
+    const pullRequests = includeMetadata
+        ? await Promise.all(sources.map((source) => readSourcePullRequests(source, dependencies.queryPullRequests, pullRequestsByRepository)))
+        : sources.map(() => []);
+    const historyByPath = new Map(history.map((entry) => [entry.path, entry]));
+    return sources.map((source, index) => ({
+        info: infos[index],
+        lastUsedTimestamp: historyByPath.get(source.worktree.path)?.timestamp ?? null,
+        pullRequests: pullRequests[index],
+        source,
+    }));
+}
+export async function loadLinkedWorktrees(cwd, repositoryPort) {
+    const repository = await repositoryPort.detectRepository(cwd);
+    const linkedWorktrees = (await repositoryPort.listWorktrees(cwd)).filter((worktree) => worktree.path !== repository.repoRoot);
+    return {
+        linkedWorktrees,
+        repository,
+    };
+}
+async function createUnhydratedWorktreeInfo(worktree, readTask) {
+    let task = null;
+    try {
+        task = (await readTask(worktree.path))?.task ?? null;
+    }
+    catch {
+        // Task metadata is optional picker decoration.
+    }
+    return {
+        ...worktree,
+        lastCommitTimestamp: null,
+        slot: null,
+        status: "unknown",
+        task,
+        upstream: { kind: "unknown" },
+    };
+}
+async function readSourcePullRequests(source, queryPullRequests, pullRequestsByRepository) {
+    if (source.repoRoot === undefined || source.worktree.branch === null) {
+        return [];
+    }
+    if (pullRequestsByRepository !== null) {
+        return sortPullRequests(pullRequestsByRepository
+            .get(source.repoRoot)
+            ?.filter((pullRequest) => pullRequest.sourceBranch === source.worktree.branch));
+    }
+    if (queryPullRequests === undefined)
+        return [];
+    try {
+        return sortPullRequests(await queryPullRequests(source.repoRoot, source.worktree.branch));
+    }
+    catch {
+        return [];
+    }
+}
+async function readRepositoryPullRequests(sources, queryPullRequests) {
+    const repoRoots = [
+        ...new Set(sources.flatMap((source) => source.repoRoot === undefined || source.worktree.branch === null
+            ? []
+            : [source.repoRoot])),
+    ];
+    const results = await mapWithConcurrency(repoRoots, MAX_PULL_REQUEST_REPOSITORY_QUERY_CONCURRENCY, async (repoRoot) => {
+        try {
+            return [repoRoot, sortPullRequests(await queryPullRequests(repoRoot))];
+        }
+        catch {
+            return [repoRoot, []];
+        }
+    });
+    return new Map(results);
+}
+function sortPullRequests(pullRequests) {
+    return [...(pullRequests ?? [])].sort((left, right) => left.number - right.number);
+}

package/dist/application/worktree/context-card.d.ts

@@ -0,0 +1,14 @@
+import type { WorktreeEntry } from "../../domain/worktree/types.js";
+import type { WorktreeInfo } from "./read-models.js";
+export interface ContextCardDependencies {
+    listWorktrees: (cwd: string) => Promise<WorktreeEntry[]>;
+    readTask: (worktreePath: string) => Promise<{
+        task: string;
+    } | null>;
+    readWorktreeInfo: (worktree: WorktreeEntry) => Promise<WorktreeInfo>;
+}
+export interface ContextCardModel {
+    info: WorktreeInfo;
+    task: string;
+}
+export declare function loadContextCardModel(worktreePath: string, dependencies: ContextCardDependencies): Promise<ContextCardModel | null>;

package/dist/application/worktree/context-card.js

@@ -0,0 +1,12 @@
+export async function loadContextCardModel(worktreePath, dependencies) {
+    const worktree = (await dependencies.listWorktrees(worktreePath)).find((entry) => entry.path === worktreePath);
+    if (!worktree)
+        return null;
+    const task = await dependencies.readTask(worktreePath);
+    if (!task)
+        return null;
+    return {
+        info: await dependencies.readWorktreeInfo(worktree),
+        task: task.task,
+    };
+}

package/dist/{go-resolver.d.ts → application/worktree/go-resolution.d.ts}

@@ -1,6 +1,8 @@
-import { type RepositoryContext } from "./repo.js";
-import type { WorktreeSource } from "./worktree-source.js";
-export type GoBranchResolution = {
+import type { RepositoryContext } from "../../domain/repository/context.js";
+import type { WorktreeSource } from "../../domain/worktree/source.js";
+import type { ConfigPort } from "../../ports/config.js";
+import type { RepositoryContextPort, RepositoryRefPort, RepositoryRegistryPort, WorktreePort } from "../../ports/repository.js";
+type GoBranchResolutionBase = {
     kind: "existing";
     source: WorktreeSource;
 } | {
@@ -26,10 +28,16 @@ export type GoBranchResolution = {
     kind: "error";
     message: string;
 };
+export type GoBranchResolution = GoBranchResolutionBase & {
+    configWarnings?: readonly string[];
+};
 export declare function resolveGoBranch(options: {
     branch: string;
-    configStderr?: (chunk: string) => void;
     cwd: string;
     currentSources: WorktreeSource[];
     repository: RepositoryContext | null;
+    repositoryPort: RepositoryRefPort;
+    sourceDependencies: RepositoryContextPort & RepositoryRegistryPort & WorktreePort;
+    configPort: ConfigPort;
 }): Promise<GoBranchResolution>;
+export {};

package/dist/{go-resolver.js → application/worktree/go-resolution.js}

@@ -1,17 +1,15 @@
-import { loadEffectiveConfig, resolveConfigString } from "./config.js";
-import { parsePrInput } from "./pr.js";
-import { getRepositoryRemoteUrl, hasLocalBranch, hasRemoteBranch, } from "./repo.js";
-import { resolveExactWorktreeQueryMatches, resolveWorktreeQuery, resolveWorktreeQueryMatches, } from "./worktree-picker.js";
-import { listRegisteredWorktreeSources } from "./worktree-sources.js";
+import { resolveExactWorktreeQueryMatches, resolveWorktreeQuery, resolveWorktreeQueryMatches, } from "../../domain/worktree/matching.js";
+import { parsePrInput } from "../../domain/worktree/pr-reference.js";
+import { listRegisteredWorktreeSources } from "./sources.js";
 export async function resolveGoBranch(options) {
-    const { branch, configStderr, cwd, currentSources, repository } = options;
+    const { branch, configPort, cwd, currentSources, repository, repositoryPort, sourceDependencies, } = options;
     const pullRequestNumber = parsePrInput(branch);
     const exactCurrentMatches = resolveExistingExactWorktreeMatches(currentSources, branch, false);
     if (exactCurrentMatches.length === 1) {
         return { kind: "existing", source: exactCurrentMatches[0] };
     }
     const localBranch = repository
-        ? await hasLocalBranch(repository.repoRoot, branch)
+        ? await repositoryPort.hasLocalBranch(repository.repoRoot, branch)
         : false;
     if (!repository && pullRequestNumber !== null) {
         return {
@@ -25,11 +23,9 @@ export async function resolveGoBranch(options) {
     const configWarnings = [];
     if (repository) {
         try {
-            const config = await loadEffectiveConfig(repository.repoRoot, undefined, configStderr === undefined
-                ? undefined
-                : (warning) => configWarnings.push(warning));
-            remote = resolveConfigString(config, "syncRemote") ?? "origin";
-            remoteBranch = await hasRemoteBranch(repository.repoRoot, remote, branch);
+            const config = await configPort.loadEffectiveConfig(repository.repoRoot, undefined, (warning) => configWarnings.push(warning));
+            remote = configPort.resolveConfigString(config, "syncRemote") ?? "origin";
+            remoteBranch = await repositoryPort.hasRemoteBranch(repository.repoRoot, remote, branch);
         }
         catch (error) {
             configError = {
@@ -38,14 +34,8 @@ export async function resolveGoBranch(options) {
             };
         }
     }
-    const flushConfigWarnings = () => {
-        if (configStderr === undefined)
-            return;
-        for (const warning of configWarnings)
-            configStderr(warning);
-    };
     const pullRequestBelongsToRepository = repository && pullRequestNumber !== null
-        ? await isPullRequestForRepository(repository.repoRoot, branch)
+        ? await isPullRequestForRepository(repository.repoRoot, branch, repositoryPort)
         : true;
     if (pullRequestNumber !== null &&
         !localBranch &&
@@ -53,60 +43,74 @@ export async function resolveGoBranch(options) {
         pullRequestBelongsToRepository) {
         const pullRequestMatches = resolveExistingExactWorktreeMatches(currentSources, branch, true);
         if (pullRequestMatches.length === 1) {
-            return { kind: "existing", source: pullRequestMatches[0] };
+            return finish({ kind: "existing", source: pullRequestMatches[0] }, false);
         }
     }
-    let skippedRegisteredRepos = 0;
-    const registeredSources = await listRegisteredWorktreeSources(cwd, () => {
-        skippedRegisteredRepos++;
+    const registered = await listRegisteredWorktreeSources({
+        cwd,
+        repositoryPort: sourceDependencies,
     });
+    const registeredSources = registered.sources;
+    const skippedRegisteredRepos = registered.skipped.length;
     const crossRepoSources = registeredSources.filter((source) => source.repoRoot !== repository?.repoRoot);
-    const crossMatches = await resolveExistingWorktreeMatches(crossRepoSources, branch, (!localBranch && !remoteBranch) || isPullRequestUrl(branch));
+    const crossMatches = await resolveExistingWorktreeMatches(crossRepoSources, branch, (!localBranch && !remoteBranch) || isPullRequestUrl(branch), repositoryPort);
     if (crossMatches.length === 1) {
-        return { kind: "existing", source: crossMatches[0] };
+        return finish({ kind: "existing", source: crossMatches[0] }, false);
     }
     if (crossMatches.length > 1) {
-        return { kind: "ambiguous", matches: crossMatches };
+        return finish({ kind: "ambiguous", matches: crossMatches }, false);
     }
     if (!repository) {
-        return registeredSources.length === 0
+        return finish(registeredSources.length === 0
             ? {
                 kind: "no-repository",
                 staleRegisteredRepos: skippedRegisteredRepos > 0,
             }
-            : { kind: "no-match", staleRegisteredRepos: skippedRegisteredRepos > 0 };
+            : {
+                kind: "no-match",
+                staleRegisteredRepos: skippedRegisteredRepos > 0,
+            });
     }
     if (localBranch) {
         if (configError)
-            return configError;
-        flushConfigWarnings();
-        return { kind: "create", repository, branch, mode: "checkout" };
+            return finish(configError);
+        return finish({ kind: "create", repository, branch, mode: "checkout" });
     }
     if (remoteBranch) {
-        flushConfigWarnings();
-        return { kind: "create", repository, branch, mode: "track", remote };
+        return finish({
+            kind: "create",
+            repository,
+            branch,
+            mode: "track",
+            remote,
+        });
     }
     const localMatch = !pullRequestNumber || !isPullRequestUrl(branch)
         ? resolveWorktreeQuery(currentSources, branch)
         : null;
     if (localMatch) {
-        return { kind: "existing", source: localMatch };
+        return finish({ kind: "existing", source: localMatch });
     }
     if (configError)
-        return configError;
+        return finish(configError);
     if (pullRequestNumber !== null && !pullRequestBelongsToRepository) {
-        flushConfigWarnings();
-        return {
+        return finish({
             kind: "error",
             message: "PR URL does not belong to this repository; run gji go from the matching checkout",
-        };
+        });
     }
     if (pullRequestNumber !== null) {
-        flushConfigWarnings();
-        return { kind: "pull-request", repository, input: branch };
+        return finish({ kind: "pull-request", repository, input: branch });
+    }
+    return finish({
+        kind: "no-match",
+        staleRegisteredRepos: skippedRegisteredRepos > 0,
+    });
+    function finish(resolution, includeWarnings = true) {
+        return !includeWarnings || configWarnings.length === 0
+            ? resolution
+            : { ...resolution, configWarnings };
     }
-    flushConfigWarnings();
-    return { kind: "no-match", staleRegisteredRepos: skippedRegisteredRepos > 0 };
 }
 function resolveExistingExactWorktreeMatches(sources, query, allowPullRequestFallback) {
     const exactMatches = resolveExactWorktreeQueryMatches(sources, query);
@@ -117,7 +121,7 @@ function resolveExistingExactWorktreeMatches(sources, query, allowPullRequestFal
         ? []
         : resolveExactWorktreeQueryMatches(sources, `pr/${pullRequestNumber}`);
 }
-async function resolveExistingWorktreeMatches(sources, query, allowPullRequestFallback) {
+async function resolveExistingWorktreeMatches(sources, query, allowPullRequestFallback, repositoryPort) {
     const exactMatches = resolveExactWorktreeQueryMatches(sources, query);
     if (exactMatches.length > 0)
         return exactMatches;
@@ -132,7 +136,7 @@ async function resolveExistingWorktreeMatches(sources, query, allowPullRequestFa
         const repoRoot = source.repoRoot ?? source.worktree.path;
         let ownership = ownershipByRepository.get(repoRoot);
         if (ownership === undefined) {
-            ownership = isPullRequestForRepository(repoRoot, query);
+            ownership = isPullRequestForRepository(repoRoot, query, repositoryPort);
             ownershipByRepository.set(repoRoot, ownership);
         }
         return (await ownership) ? source : null;
@@ -146,7 +150,7 @@ async function resolveExistingWorktreeMatches(sources, query, allowPullRequestFa
 function isPullRequestUrl(input) {
     return /^[a-z][a-z\d+.-]*:\/\//i.test(input);
 }
-async function isPullRequestForRepository(repoRoot, input) {
+async function isPullRequestForRepository(repoRoot, input, repositoryPort) {
     if (/^\d+$/.test(input) || /^#\d+$/.test(input))
         return true;
     let pullRequestUrl;
@@ -156,7 +160,7 @@ async function isPullRequestForRepository(repoRoot, input) {
     catch {
         return true;
     }
-    const remoteUrl = await getRepositoryRemoteUrl(repoRoot, "origin");
+    const remoteUrl = await repositoryPort.getRepositoryRemoteUrl(repoRoot, "origin");
     if (!remoteUrl)
         return true;
     return (normalizeRepositoryUrl(remoteUrl) ===

package/dist/application/worktree/read-models.d.ts

@@ -0,0 +1,31 @@
+import type { WorktreeEntry } from "../../domain/worktree/types.js";
+export type WorktreeStatus = "clean" | "dirty" | "unknown";
+export type UpstreamState = {
+    kind: "detached";
+} | {
+    kind: "no-upstream";
+} | {
+    kind: "stale";
+} | {
+    kind: "tracked";
+    ahead: number;
+    behind: number;
+} | {
+    kind: "unknown";
+};
+export interface WorktreeInfo extends WorktreeEntry {
+    lastCommitTimestamp: number | null;
+    slot: number | null;
+    status: WorktreeStatus;
+    task: string | null;
+    upstream: UpstreamState;
+}
+export interface SerializedWorktreeInfo {
+    branch: string | null;
+    lastCommitTimestamp: number | null;
+    path: string;
+    slot: number | null;
+    status: WorktreeStatus;
+    task: string | null;
+    upstream: UpstreamState;
+}

package/dist/application/worktree/sources.d.ts

@@ -0,0 +1,16 @@
+import type { RepoRegistryEntry } from "../../domain/repository/registry.js";
+import type { WorktreeSource } from "../../domain/worktree/source.js";
+import type { RepositoryContextPort, RepositoryRegistryPort, WorktreePort } from "../../ports/repository.js";
+export type WorktreeSourceDependencies = RepositoryContextPort & RepositoryRegistryPort & WorktreePort;
+export interface WorktreeSourceDiscovery {
+    skipped: RepoRegistryEntry[];
+    sources: WorktreeSource[];
+}
+export interface ListWorktreeSourcesOptions {
+    cwd: string;
+    repositoryPort: WorktreeSourceDependencies;
+    signal?: AbortSignal;
+}
+export declare function listRegisteredWorktreeSources(options: ListWorktreeSourcesOptions): Promise<WorktreeSourceDiscovery>;
+export declare function listDiscoverableWorktreeSources(options: ListWorktreeSourcesOptions): Promise<WorktreeSourceDiscovery>;
+export declare function deduplicateWorktreeSources(sources: WorktreeSource[]): WorktreeSource[];

package/dist/application/worktree/sources.js

@@ -0,0 +1,86 @@
+import { mapWithConcurrency } from "../../domain/shared/concurrency.js";
+const MAX_REPOSITORY_DISCOVERY_CONCURRENCY = 4;
+export async function listRegisteredWorktreeSources(options) {
+    const { cwd, repositoryPort, signal } = options;
+    throwIfAborted(signal);
+    const registry = await repositoryPort.loadRegistry();
+    const currentRoot = await repositoryPort
+        .detectRepository(cwd)
+        .then((repository) => repository.currentRoot)
+        .catch(() => null);
+    throwIfAborted(signal);
+    const results = await mapWithConcurrency(registry, MAX_REPOSITORY_DISCOVERY_CONCURRENCY, async (entry) => {
+        throwIfAborted(signal);
+        try {
+            const worktrees = await repositoryPort.listWorktrees(entry.path);
+            return { entry, skipped: false, worktrees };
+        }
+        catch {
+            return { entry, skipped: true, worktrees: [] };
+        }
+    }, signal);
+    const allItems = [];
+    const skipped = [];
+    for (const result of results) {
+        if (result.skipped) {
+            skipped.push(result.entry);
+            continue;
+        }
+        const { entry, worktrees } = result;
+        for (const worktree of worktrees) {
+            allItems.push({
+                repoRoot: entry.path,
+                repoName: entry.name,
+                worktree: {
+                    ...worktree,
+                    isCurrent: currentRoot !== null && worktree.path === currentRoot,
+                },
+            });
+        }
+    }
+    return { skipped, sources: allItems };
+}
+export async function listDiscoverableWorktreeSources(options) {
+    const { cwd, repositoryPort } = options;
+    const currentRepository = await repositoryPort
+        .detectRepository(cwd)
+        .catch(() => null);
+    const registered = await listRegisteredWorktreeSources(options);
+    if (currentRepository === null) {
+        return {
+            skipped: registered.skipped,
+            sources: deduplicateWorktreeSources(registered.sources),
+        };
+    }
+    let currentSources = [];
+    try {
+        currentSources = (await repositoryPort.listWorktrees(cwd)).map((worktree) => ({
+            repoName: currentRepository.repoName,
+            repoRoot: currentRepository.repoRoot,
+            worktree,
+        }));
+    }
+    catch {
+        // Registered repositories remain discoverable when the current checkout is transiently unavailable.
+    }
+    return {
+        skipped: registered.skipped,
+        sources: deduplicateWorktreeSources([
+            ...currentSources,
+            ...registered.sources,
+        ]),
+    };
+}
+export function deduplicateWorktreeSources(sources) {
+    const seen = new Set();
+    return sources.filter((source) => {
+        if (seen.has(source.worktree.path))
+            return false;
+        seen.add(source.worktree.path);
+        return true;
+    });
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw new Error("Operation cancelled");
+}

package/dist/{back.d.ts → cli/commands/back.d.ts}

@@ -1,4 +1,5 @@
-import { type HistoryEntry } from "./history.js";
+import type { HistoryEntry } from "../../ports/history.js";
+import { type CliRuntime } from "../dependencies.js";
 export declare const BACK_OUTPUT_FILE_ENV = "GJI_BACK_OUTPUT_FILE";
 export interface BackCommandOptions {
     cwd: string;
@@ -8,6 +9,7 @@ export interface BackCommandOptions {
     commandName?: string;
     outputEnv?: string;
     print?: boolean;
+    runtime?: CliRuntime<"config" | "historyStore" | "hooks" | "repositoryContext">;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }

package/dist/{back.js → cli/commands/back.js}

@@ -1,13 +1,15 @@
 import { access } from "node:fs/promises";
 import { basename } from "node:path";
-import { loadEffectiveConfig } from "./config.js";
-import { appendHistory, loadHistory } from "./history.js";
-import { extractHooks, runHook } from "./hooks.js";
-import { createNavigationRepository, createNavigationTarget, } from "./navigation-output.js";
-import { detectRepository } from "./repo.js";
-import { writeShellOutput } from "./shell-handoff.js";
+import { writeShellOutput } from "../../presentation/shell/handoff.js";
+import { createNavigationRepository, createNavigationTarget, } from "../../presentation/terminal/navigation.js";
+import { defaultCliDependencies } from "../dependencies.js";
 export const BACK_OUTPUT_FILE_ENV = "GJI_BACK_OUTPUT_FILE";
 export async function runBackCommand(options) {
+    const runtime = options.runtime ?? defaultCliDependencies;
+    const { loadEffectiveConfig } = runtime.config;
+    const { appendHistory, loadHistory } = runtime.historyStore;
+    const { extractHooks, runHook } = runtime.hooks;
+    const { detectRepository } = runtime.repositoryContext;
     const history = await loadHistory(options.home);
     const steps = options.n ?? 1;
     if (steps < 1) {

package/dist/{clean.d.ts → cli/commands/clean.d.ts}

@@ -1,11 +1,14 @@
-import type { WorktreeEntry } from "./repo.js";
-import { type WorktreePromptEntry } from "./worktree-picker.js";
+import { type WorktreeCatalogDependencies } from "../../application/worktree/catalog.js";
+import type { WorktreeEntry } from "../../domain/worktree/types.js";
+import { type WorktreePromptEntry, type WorktreePromptScope } from "../../presentation/worktree/picker.js";
+import { type CliRuntime } from "../dependencies.js";
 export interface CleanCommandOptions {
     cwd: string;
     dryRun?: boolean;
     force?: boolean;
     json?: boolean;
     stale?: boolean;
+    runtime?: CliRuntime<"git" | "config" | "configStore" | "slots" | "repositoryContext" | "repositoryRegistry" | "worktrees" | "worktreeInfo" | "worktreeLifecycle" | "worktreeCatalog">;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }
@@ -13,7 +16,7 @@ export interface CleanCommandDependencies {
     confirmForceDeleteBranch: (branch: string) => Promise<boolean>;
     confirmForceRemoveWorktree: (worktreePath: string) => Promise<boolean>;
     confirmRemoval: (worktrees: WorktreeEntry[]) => Promise<boolean>;
-    promptForWorktrees: (worktrees: WorktreePromptEntry[]) => Promise<string[] | null>;
+    promptForWorktrees: (worktrees: WorktreePromptEntry[], scope?: WorktreePromptScope, catalog?: WorktreeCatalogDependencies) => Promise<string[] | null>;
 }
 export declare function createCleanCommand(dependencies?: Partial<CleanCommandDependencies>): (options: CleanCommandOptions) => Promise<number>;
 export declare const runCleanCommand: (options: CleanCommandOptions) => Promise<number>;