@solaqua/gji 0.12.5 → 0.14.0

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

@@ -5,17 +5,14 @@ import { homedir } from "node:os";
 import { basename, dirname, join } from "node:path";
 import { promisify } from "node:util";
 import { confirm, isCancel } from "@clack/prompts";
-import { CONFIG_FILE_NAME, GLOBAL_CONFIG_FILE_PATH, KNOWN_CONFIG_KEYS, KNOWN_GLOBAL_CONFIG_KEYS, } from "./config.js";
-import { EDITORS } from "./editor.js";
-import { isHeadless } from "./headless.js";
-import { detectRepository } from "./repo.js";
-import { loadRegistry, REGISTRY_FILE_PATH, removeMissingRegistryEntries, } from "./repo-registry.js";
-import { resolveSupportedShell } from "./shell.js";
-import { executableExists, hasShellIntegration, resolveCompletionPath, resolveShellConfigPath, } from "./shell-setup.js";
-import { loadSlots } from "./slots.js";
+import { executableExists, hasShellIntegration, resolveCompletionPath, resolveShellConfigPath, } from "../../presentation/shell/setup.js";
+import { resolveSupportedShell, } from "../../presentation/shell/shell.js";
+import { defaultCliDependencies, } from "../dependencies.js";
+import { isHeadless } from "../runtime/headless.js";
 const execFileAsync = promisify(execFile);
 const MINIMUM_GIT_VERSION = { major: 2, minor: 17 };
 export async function runDoctorCommand(options) {
+    const runtime = options.runtime ?? defaultCliDependencies;
     if (options.yes && !options.fix) {
         const message = "--yes requires --fix";
         if (options.json) {
@@ -28,14 +25,14 @@ export async function runDoctorCommand(options) {
     }
     const home = options.home ?? homedir();
     const shell = resolveSupportedShell(undefined, options.shell ?? process.env.SHELL);
-    let inspection = await collectDoctorInspection(options.cwd, home, shell);
+    let inspection = await collectDoctorInspection(options.cwd, home, shell, runtime);
     let fixes = [];
     if (options.fix) {
         fixes = buildDoctorFixes(inspection.missingRegistryPaths);
         if (fixes.length > 0) {
             const approval = await requestFixApproval(fixes, options);
             if (approval === "apply") {
-                fixes = await applyDoctorFixes(fixes, home);
+                fixes = await applyDoctorFixes(fixes, home, runtime.registry);
             }
             else {
                 fixes = fixes.map((fix) => ({
@@ -47,7 +44,7 @@ export async function runDoctorCommand(options) {
                 }));
             }
         }
-        inspection = await collectDoctorInspection(options.cwd, home, shell);
+        inspection = await collectDoctorInspection(options.cwd, home, shell, runtime);
     }
     const problems = inspection.checks.filter((check) => check.status === "fail").length;
     if (options.json) {
@@ -64,14 +61,15 @@ export async function runDoctorCommand(options) {
     }
     return problems > 0 ? 1 : 0;
 }
-async function collectDoctorInspection(cwd, home, shell) {
-    const repository = await detectRepositoryOrSkip(cwd);
+async function collectDoctorInspection(cwd, home, shell, runtime) {
+    const { CONFIG_FILE_NAME, GLOBAL_CONFIG_FILE_PATH, KNOWN_CONFIG_KEYS, KNOWN_GLOBAL_CONFIG_KEYS, } = runtime.configStore;
+    const repository = await detectRepositoryOrSkip(cwd, runtime.repositoryContext.detectRepository);
     const globalConfig = await inspectConfig(GLOBAL_CONFIG_FILE_PATH(home), "global", KNOWN_GLOBAL_CONFIG_KEYS);
     const localConfig = repository
         ? await inspectConfig(join(repository.repoRoot, CONFIG_FILE_NAME), "local", KNOWN_CONFIG_KEYS)
         : null;
     const effectiveConfig = resolveEffectiveConfig(globalConfig.config, localConfig?.config ?? {}, repository?.repoRoot, home);
-    const registry = await inspectRegistry(home);
+    const registry = await inspectRegistry(home, runtime.registry);
     return {
         checks: [
             await checkGitVersion(),
@@ -82,13 +80,13 @@ async function collectDoctorInspection(cwd, home, shell) {
                 skippedCheck("local-config", "local config not checked outside a Git repository"),
             await checkWorktreeBase(repository, effectiveConfig, home),
             registry.check,
-            await checkEditor(effectiveConfig),
-            await checkOrphanSlots(home),
+            await checkEditor(effectiveConfig, runtime.integrations.EDITORS),
+            await checkOrphanSlots(home, runtime.slots.loadSlots),
         ],
         missingRegistryPaths: registry.missingPaths,
     };
 }
-async function checkOrphanSlots(home) {
+async function checkOrphanSlots(home, loadSlots) {
     const slots = await loadSlots(home);
     const missing = (await Promise.all(Object.keys(slots).map(async (path) => {
         try {
@@ -142,10 +140,10 @@ function isDoctorInteractive(options) {
         return options.interactive;
     return process.stdin.isTTY === true && process.stdout.isTTY === true;
 }
-async function applyDoctorFixes(fixes, home) {
+async function applyDoctorFixes(fixes, home, registry) {
     return Promise.all(fixes.map(async (fix) => {
         try {
-            const result = await removeMissingRegistryEntries(new Set(fix.paths ?? []), home);
+            const result = await registry.removeMissingRegistryEntries(new Set(fix.paths ?? []), home);
             const removedCount = result.removedPaths.length;
             const skippedCount = result.skippedPaths.length;
             return {
@@ -168,7 +166,7 @@ async function applyDoctorFixes(fixes, home) {
         }
     }));
 }
-async function detectRepositoryOrSkip(cwd) {
+async function detectRepositoryOrSkip(cwd, detectRepository) {
     try {
         return await detectRepository(cwd);
     }
@@ -342,8 +340,8 @@ async function findNearestExistingPath(path) {
         }
     }
 }
-async function inspectRegistry(home) {
-    const entries = await loadRegistry(home);
+async function inspectRegistry(home, registry) {
+    const entries = await registry.loadRegistry(home);
     const missingEntries = await Promise.all(entries.map(async (entry) => ({
         entry,
         status: await inspectRegistryPath(entry.path),
@@ -368,7 +366,7 @@ async function inspectRegistry(home) {
     }
     return {
         check: failedCheck("repo-registry", `${entries.length} repos registered, ${messageParts.join(", ")}`, missingCount > 0
-            ? `remove confirmed stale entries from ${REGISTRY_FILE_PATH(home)}; check permissions for inaccessible paths`
+            ? `remove confirmed stale entries from ${registry.REGISTRY_FILE_PATH(home)}; check permissions for inaccessible paths`
             : "check permissions for inaccessible paths before removing registry entries"),
         missingPaths,
     };
@@ -399,7 +397,7 @@ async function pathExists(path) {
         return false;
     }
 }
-async function checkEditor(config) {
+async function checkEditor(config, editors) {
     const editor = config.editor;
     if (typeof editor !== "string" || editor.length === 0) {
         return skippedCheck("editor", "editor not configured (optional)");
@@ -407,7 +405,7 @@ async function checkEditor(config) {
     if (await executableExists(editor)) {
         return okCheck("editor", `editor "${editor}" found on PATH`);
     }
-    const knownEditor = EDITORS.some(({ cli }) => cli === editor);
+    const knownEditor = editors.some(({ cli }) => cli === editor);
     return failedCheck("editor", `editor "${editor}" was not found on PATH`, knownEditor
         ? `install ${editor} or choose another editor with: gji open --save`
         : "choose another editor with: gji open --save");

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

@@ -1,9 +1,11 @@
+import { type CliRuntime } from "../dependencies.js";
 export interface DoneCommandOptions {
     branch?: string;
     cwd: string;
     force?: boolean;
     json?: boolean;
     keepBranch?: boolean;
+    runtime?: CliRuntime<"git" | "config" | "configStore" | "historyStore" | "slots" | "hooks" | "repositoryContext" | "worktrees" | "worktreeLifecycle">;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }

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

@@ -1,17 +1,20 @@
 import { basename } from "node:path";
 import { confirm, isCancel } from "@clack/prompts";
-import { loadEffectiveConfig, resolveConfigString } from "./config.js";
-import { isBranchMergedInto, readWorktreeHealth, resolveRemoteDefaultBranch, runGit, } from "./git.js";
-import { isHeadless } from "./headless.js";
-import { loadHistory } from "./history.js";
-import { extractHooks, runHook } from "./hooks.js";
-import { detectRepository, listWorktrees } from "./repo.js";
-import { writeShellOutput } from "./shell-handoff.js";
-import { releaseWorktreeSlot } from "./slots.js";
+import { writeShellOutput } from "../../presentation/shell/handoff.js";
+import { defaultCliDependencies, } from "../dependencies.js";
+import { isHeadless } from "../runtime/headless.js";
 import { finalizeUndoOperation, recordUndoOperation } from "./undo.js";
-import { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isWorktreeForceRemovalError, removeWorktree, } from "./worktree-management.js";
 const DONE_OUTPUT_FILE_ENV = "GJI_DONE_OUTPUT_FILE";
 export async function runDoneCommand(options) {
+    const runtime = options.runtime ?? defaultCliDependencies;
+    const { readWorktreeHealth, isBranchMergedInto, resolveRemoteDefaultBranch, runGit, } = runtime.git;
+    const { loadEffectiveConfig, resolveConfigString } = runtime.config;
+    const { loadHistory } = runtime.historyStore;
+    const { releaseWorktreeSlot } = runtime.slots;
+    const { extractHooks, runHook } = runtime.hooks;
+    const { detectRepository } = runtime.repositoryContext;
+    const { listWorktrees } = runtime.worktrees;
+    const { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isWorktreeForceRemovalError, removeWorktree, } = runtime.worktreeLifecycle;
     const repository = await detectRepository(options.cwd);
     if (!repository.isWorktree && !options.branch)
         return doneError(options, "gji done: not inside a linked worktree");
@@ -24,12 +27,12 @@ export async function runDoneCommand(options) {
             ? `gji done: no linked worktree found for ${options.branch}`
             : "gji done: not inside a linked worktree");
     const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
-    await refreshUpstream(repository.repoRoot, target.path);
+    await refreshUpstream(repository.repoRoot, target.path, runGit);
     const health = await readWorktreeHealth(target.path);
     if (target.branch &&
         !options.force &&
         !options.keepBranch &&
-        !(await isSafeToComplete(repository.repoRoot, target.branch, health, config))) {
+        !(await isSafeToComplete(repository.repoRoot, target.branch, health, config, resolveConfigString, resolveRemoteDefaultBranch, isBranchMergedInto, runGit))) {
         if (options.json || isHeadless())
             return doneError(options, "branch is not merged and its upstream is not gone; use --force");
         const choice = await confirm({
@@ -55,7 +58,7 @@ export async function runDoneCommand(options) {
     }
     let journal;
     try {
-        journal = await recordUndoOperation("done", repository.repoRoot, [target]);
+        journal = await recordUndoOperation("done", repository.repoRoot, [target], undefined, runtime);
     }
     catch (error) {
         return doneError(options, `could not write undo journal; no worktree was removed: ${toMessage(error)}`);
@@ -72,12 +75,12 @@ export async function runDoneCommand(options) {
     }
     catch (error) {
         if (!isWorktreeForceRemovalError(error)) {
-            await finalizeUndoOperation(journal, []);
+            await finalizeUndoOperation(journal, [], undefined, runtime.configStore.GLOBAL_CONFIG_DIRECTORY);
             return doneError(options, `Failed to remove worktree at ${target.path}: ${toMessage(error)}`);
         }
         if (!options.force) {
             if (options.json || isHeadless()) {
-                await finalizeUndoOperation(journal, []);
+                await finalizeUndoOperation(journal, [], undefined, runtime.configStore.GLOBAL_CONFIG_DIRECTORY);
                 return doneError(options, "worktree requires force removal; use --force");
             }
             const choice = await confirm({
@@ -87,7 +90,7 @@ export async function runDoneCommand(options) {
                 initialValue: false,
             });
             if (isCancel(choice) || !choice) {
-                await finalizeUndoOperation(journal, []);
+                await finalizeUndoOperation(journal, [], undefined, runtime.configStore.GLOBAL_CONFIG_DIRECTORY);
                 return doneError(options, "Aborted");
             }
         }
@@ -95,7 +98,7 @@ export async function runDoneCommand(options) {
             await forceRemoveWorktree(repository.repoRoot, target.path);
         }
         catch (forceError) {
-            await finalizeUndoOperation(journal, []);
+            await finalizeUndoOperation(journal, [], undefined, runtime.configStore.GLOBAL_CONFIG_DIRECTORY);
             return doneError(options, `Failed to remove worktree at ${target.path}: ${toMessage(forceError)}`);
         }
     }
@@ -122,12 +125,12 @@ export async function runDoneCommand(options) {
             }
         }
     }
-    await finalizeUndoOperation(journal, [target]);
+    await finalizeUndoOperation(journal, [target], undefined, runtime.configStore.GLOBAL_CONFIG_DIRECTORY);
     await releaseWorktreeSlot(target.path);
     await runGit(repository.repoRoot, ["worktree", "prune"]).catch(() => undefined);
     const shouldMove = options.branch === undefined || target.path === repository.currentRoot;
     const movedTo = shouldMove
-        ? await resolveDoneDestination(repository.repoRoot, target.path)
+        ? await resolveDoneDestination(repository.repoRoot, target.path, loadHistory, runGit)
         : null;
     if (!options.json && movedTo)
         await writeShellOutput(DONE_OUTPUT_FILE_ENV, movedTo, options.stdout);
@@ -139,7 +142,7 @@ export async function runDoneCommand(options) {
         options.stderr(`✓ removed ${target.branch ?? "detached worktree"} (worktree${branchDeleted ? " + branch" : ""})${movedTo ? ` → back at ${movedTo}` : ""} · undo: gji undo\n`);
     return 0;
 }
-async function isSafeToComplete(repoRoot, branch, health, config) {
+async function isSafeToComplete(repoRoot, branch, health, config, resolveConfigString, resolveRemoteDefaultBranch, isBranchMergedInto, runGit) {
     if (health.upstreamGone)
         return true;
     const remote = resolveConfigString(config, "syncRemote") ?? "origin";
@@ -148,7 +151,7 @@ async function isSafeToComplete(repoRoot, branch, health, config) {
         (await resolveRemoteDefaultBranch(repoRoot, remote).catch(() => null));
     if (remoteDefault) {
         for (const base of [`${remote}/${remoteDefault}`, remoteDefault]) {
-            if (await gitRefExists(repoRoot, base))
+            if (await gitRefExists(repoRoot, base, runGit))
                 return isBranchMergedInto(repoRoot, branch, base).catch(() => false);
         }
         return false;
@@ -162,7 +165,7 @@ async function isSafeToComplete(repoRoot, branch, health, config) {
         ? false
         : isBranchMergedInto(repoRoot, branch, base).catch(() => false);
 }
-async function gitRefExists(repoRoot, ref) {
+async function gitRefExists(repoRoot, ref, runGit) {
     try {
         await runGit(repoRoot, ["rev-parse", "--verify", ref]);
         return true;
@@ -171,7 +174,7 @@ async function gitRefExists(repoRoot, ref) {
         return false;
     }
 }
-async function refreshUpstream(repoRoot, worktreePath) {
+async function refreshUpstream(repoRoot, worktreePath, runGit) {
     const upstream = await runGit(worktreePath, [
         "rev-parse",
         "--abbrev-ref",
@@ -183,7 +186,7 @@ async function refreshUpstream(repoRoot, worktreePath) {
         return;
     await runGit(repoRoot, ["fetch", "--prune", "--quiet", remote]).catch(() => undefined);
 }
-async function resolveDoneDestination(repoRoot, removedPath) {
+async function resolveDoneDestination(repoRoot, removedPath, loadHistory, runGit) {
     const history = await loadHistory();
     for (const entry of history) {
         if (entry.path !== removedPath && entry.path !== repoRoot) {

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

@@ -1,4 +1,6 @@
-import { type QueryWorktreePullRequests, type WorktreePromptEntry, type WorktreePromptScope } from "./worktree-picker.js";
+import type { WorktreeCatalogDependencies } from "../../application/worktree/catalog.js";
+import { type QueryWorktreePullRequests, type WorktreePromptEntry, type WorktreePromptScope } from "../../presentation/worktree/picker.js";
+import { type CliRuntime } from "../dependencies.js";
 export interface GoCommandOptions {
     branch?: string;
     cwd: string;
@@ -8,11 +10,15 @@ export interface GoCommandOptions {
     quiet?: boolean;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
+    runtime?: GoRuntime;
 }
+type GoRuntime = CliRuntime<"bootstrap" | "config" | "contextCard" | "git" | "history" | "historyStore" | "hooks" | "integrations" | "repositoryContext" | "repositoryRefs" | "repositoryRegistry" | "slots" | "tasks" | "worktrees" | "worktreeCatalog">;
 export interface GoCommandDependencies {
     confirmBranchCreation: (branch: string) => Promise<boolean>;
-    promptForWorktree: (worktrees: WorktreePromptEntry[], scope?: WorktreePromptScope) => Promise<string | null>;
+    promptForWorktree: (worktrees: WorktreePromptEntry[], scope?: WorktreePromptScope, catalog?: WorktreeCatalogDependencies) => Promise<string | null>;
     queryPullRequests: QueryWorktreePullRequests;
+    runtime: GoRuntime;
 }
 export declare function createGoCommand(dependencies?: Partial<GoCommandDependencies>): (options: GoCommandOptions) => Promise<number>;
 export declare const runGoCommand: (options: GoCommandOptions) => Promise<number>;
+export {};

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

@@ -1,30 +1,29 @@
 import { basename } from "node:path";
 import { confirm, isCancel } from "@clack/prompts";
+import { loadContextCardModel } from "../../application/worktree/context-card.js";
+import { resolveGoBranch, } from "../../application/worktree/go-resolution.js";
+import { listRegisteredWorktreeSources } from "../../application/worktree/sources.js";
+import { writeShellOutput } from "../../presentation/shell/handoff.js";
+import { renderContextCard } from "../../presentation/terminal/context-card.js";
+import { createNavigationRepository, createNavigationTarget, } from "../../presentation/terminal/navigation.js";
+import { buildWorktreePromptEntries, promptForSingleWorktree, } from "../../presentation/worktree/picker.js";
+import { defaultCliDependencies, withPullRequestQueries, } from "../dependencies.js";
+import { isHeadless } from "../runtime/headless.js";
 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";
-import { extractHooks, runHook } from "./hooks.js";
-import { createNavigationRepository, createNavigationTarget, } from "./navigation-output.js";
 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";
 export function createGoCommand(dependencies = {}) {
     const confirmBranchCreation = dependencies.confirmBranchCreation ?? defaultConfirmBranchCreation;
     const prompt = dependencies.promptForWorktree ?? promptForWorktree;
+    const configuredRuntime = dependencies.runtime;
     return async function runGoCommand(options) {
+        const runtime = configuredRuntime ?? options.runtime ?? defaultCliDependencies;
         if (options.root) {
             if (options.branch !== undefined) {
                 return emitError(options, "--root cannot be combined with a branch");
             }
-            return navigateToRepositoryRoot(options);
+            return navigateToRepositoryRoot(options, runtime);
         }
         if (options.branch === "-") {
             return runBackCommand({
@@ -34,9 +33,10 @@ export function createGoCommand(dependencies = {}) {
                 outputEnv: GO_OUTPUT_FILE_ENV,
                 stderr: options.stderr,
                 stdout: options.stdout,
+                runtime,
             });
         }
-        const [repository, currentWorktrees] = await readCurrentRepository(options.cwd);
+        const [repository, currentWorktrees] = await readCurrentRepository(options.cwd, runtime);
         const currentSources = repository
             ? toPromptSources(repository.repoRoot, repository.repoName, currentWorktrees)
             : [];
@@ -49,9 +49,16 @@ export function createGoCommand(dependencies = {}) {
             let promptSources = currentSources;
             const loadAllSources = async () => {
                 if (registeredSources === null) {
-                    registeredSources = await listRegisteredWorktreeSources(options.cwd, () => {
-                        skippedRegisteredRepos++;
+                    const registered = await listRegisteredWorktreeSources({
+                        cwd: options.cwd,
+                        repositoryPort: {
+                            ...runtime.repositoryContext,
+                            ...runtime.repositoryRegistry,
+                            ...runtime.worktrees,
+                        },
                     });
+                    registeredSources = registered.sources;
+                    skippedRegisteredRepos = registered.skipped.length;
                 }
                 return deduplicateSources([...currentSources, ...registeredSources]);
             };
@@ -75,10 +82,8 @@ export function createGoCommand(dependencies = {}) {
                         currentRepositoryScope = nextCurrentRepositoryScope;
                         promptSources = nextSources;
                         return {
-                            entries: await buildWorktreePromptEntries(promptSources, {
-                                metadata: currentRepositoryScope ? "full" : "fast",
-                                queryPullRequests: dependencies.queryPullRequests,
-                            }),
+                            sources: promptSources,
+                            metadata: currentRepositoryScope ? "full" : "fast",
                             label: currentRepositoryScope
                                 ? "current repository"
                                 : "all repositories",
@@ -91,38 +96,48 @@ export function createGoCommand(dependencies = {}) {
             }
             const promptEntries = await buildWorktreePromptEntries(promptSources, {
                 metadata: repository ? "full" : "fast",
-                queryPullRequests: dependencies.queryPullRequests,
+                catalog: withPullRequestQueries(runtime, dependencies.queryPullRequests),
             });
-            const selectedPath = await prompt(promptEntries, scope);
+            const selectedPath = await prompt(promptEntries, scope, withPullRequestQueries(runtime, dependencies.queryPullRequests));
             if (!selectedPath) {
                 options.stderr("Aborted\n");
                 return 1;
             }
             const selected = promptSources.find((source) => source.worktree.path === selectedPath);
-            return navigateToExistingWorktree(options, selectedPath, selected?.worktree);
+            return navigateToExistingWorktree(options, selectedPath, selected?.worktree, runtime);
         }
         const resolution = await resolveGoBranch({
             branch: options.branch,
-            configStderr: options.json ? undefined : options.stderr,
             cwd: options.cwd,
             currentSources,
             repository,
+            repositoryPort: runtime.repositoryRefs,
+            sourceDependencies: {
+                ...runtime.repositoryContext,
+                ...runtime.repositoryRegistry,
+                ...runtime.worktrees,
+            },
+            configPort: runtime.config,
         });
-        return handleGoBranchResolution(options, resolution, confirmBranchCreation, prompt, dependencies.queryPullRequests);
+        return handleGoBranchResolution(options, resolution, confirmBranchCreation, prompt, runtime, dependencies.queryPullRequests);
     };
 }
 export const runGoCommand = createGoCommand();
-async function handleGoBranchResolution(options, resolution, confirmBranchCreation, prompt, queryPullRequests) {
+async function handleGoBranchResolution(options, resolution, confirmBranchCreation, prompt, runtime, queryPullRequests) {
+    if (!options.json) {
+        for (const warning of resolution.configWarnings ?? [])
+            options.stderr(warning);
+    }
     switch (resolution.kind) {
         case "existing":
-            return navigateToExistingWorktree(options, resolution.source.worktree.path, resolution.source.worktree);
+            return navigateToExistingWorktree(options, resolution.source.worktree.path, resolution.source.worktree, runtime);
         case "ambiguous": {
             if (options.json || isHeadless() || options.print) {
                 return emitAmbiguousCrossRepoError(options, resolution.matches);
             }
             const candidates = await buildWorktreePromptEntries(resolution.matches, {
                 metadata: "fast",
-                queryPullRequests,
+                catalog: withPullRequestQueries(runtime, queryPullRequests),
             });
             const selectedPath = await prompt(candidates);
             if (!selectedPath) {
@@ -130,10 +145,10 @@ async function handleGoBranchResolution(options, resolution, confirmBranchCreati
                 return 1;
             }
             const selected = resolution.matches.find((source) => source.worktree.path === selectedPath);
-            return navigateToExistingWorktree(options, selectedPath, selected?.worktree);
+            return navigateToExistingWorktree(options, selectedPath, selected?.worktree, runtime);
         }
         case "create":
-            return createExistingBranchWorktree(options, confirmBranchCreation, resolution.repository, resolution.branch, resolution.mode, resolution.remote);
+            return createExistingBranchWorktree(options, confirmBranchCreation, resolution.repository, resolution.branch, resolution.mode, resolution.remote, runtime);
         case "pull-request":
             if (options.json || isHeadless() || options.print) {
                 return emitError(options, "PR navigation creates a worktree; use `gji pr <ref>` in an interactive shell");
@@ -144,6 +159,7 @@ async function handleGoBranchResolution(options, resolution, confirmBranchCreati
                 outputEnv: GO_OUTPUT_FILE_ENV,
                 stderr: options.stderr,
                 stdout: options.stdout,
+                runtime,
             });
         case "no-repository":
             return emitNoRepositoryError(options, resolution.staleRegisteredRepos);
@@ -153,11 +169,11 @@ async function handleGoBranchResolution(options, resolution, confirmBranchCreati
             return emitError(options, resolution.message);
     }
 }
-async function readCurrentRepository(cwd) {
+async function readCurrentRepository(cwd, runtime) {
     try {
         const [repository, worktrees] = await Promise.all([
-            detectRepository(cwd),
-            listWorktrees(cwd),
+            runtime.repositoryContext.detectRepository(cwd),
+            runtime.worktrees.listWorktrees(cwd),
         ]);
         return [repository, worktrees];
     }
@@ -179,7 +195,7 @@ function deduplicateSources(sources) {
     }
     return deduplicated;
 }
-async function createExistingBranchWorktree(options, confirmBranchCreation, repository, branch, mode, remote) {
+async function createExistingBranchWorktree(options, confirmBranchCreation, repository, branch, mode, remote, runtime) {
     if (options.json || isHeadless() || options.print) {
         return emitError(options, `branch "${branch}" exists but has no worktree; use interactive gji go ${branch} to create one`);
     }
@@ -195,41 +211,42 @@ async function createExistingBranchWorktree(options, confirmBranchCreation, repo
         remote,
         stderr: options.stderr,
         stdout: options.stdout,
+        runtime,
     });
 }
-async function navigateToExistingWorktree(options, path, worktree) {
-    const repository = await detectRepository(path);
+async function navigateToExistingWorktree(options, path, worktree, runtime) {
+    const repository = await runtime.repositoryContext.detectRepository(path);
     if (options.json) {
         options.stdout(`${JSON.stringify(createNavigationTarget(createNavigationRepository(repository.repoName, repository.repoRoot), path, worktree?.branch ?? null), null, 2)}\n`);
         return 0;
     }
-    const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
-    const hooks = extractHooks(config);
-    await runHook(hooks["after-enter"], path, {
+    const config = await runtime.config.loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
+    const hooks = runtime.hooks.extractHooks(config);
+    await runtime.hooks.runHook(hooks["after-enter"], path, {
         branch: worktree?.branch ?? undefined,
         path,
         repo: basename(repository.repoRoot),
-        slot: await getWorktreeSlot(path),
+        slot: await runtime.slots.getWorktreeSlot(path),
     }, options.stderr);
     if (!options.quiet) {
-        const card = await renderContextCard(path);
+        const card = await loadContextCardModel(path, runtime.contextCard);
         if (card)
-            options.stderr(`${card}\n`);
+            options.stderr(`${renderContextCard(card)}\n`);
     }
-    await recordWorktreeUsage(path, worktree?.branch ?? null);
+    await runtime.history.recordWorktreeUsage(path, worktree?.branch ?? null);
     await writeShellOutput(GO_OUTPUT_FILE_ENV, path, options.stdout);
     return 0;
 }
-async function navigateToRepositoryRoot(options) {
+async function navigateToRepositoryRoot(options, runtime) {
     let repository;
     try {
-        repository = await detectRepository(options.cwd);
+        repository = await runtime.repositoryContext.detectRepository(options.cwd);
     }
     catch {
         return emitError(options, "not inside a git repository");
     }
     if (options.json) {
-        const rootWorktree = (await listWorktrees(repository.repoRoot)).find((worktree) => worktree.path === repository.repoRoot);
+        const rootWorktree = (await runtime.worktrees.listWorktrees(repository.repoRoot)).find((worktree) => worktree.path === repository.repoRoot);
         options.stdout(`${JSON.stringify(createNavigationTarget(createNavigationRepository(repository.repoName, repository.repoRoot), repository.repoRoot, rootWorktree?.branch ?? null), null, 2)}\n`);
         return 0;
     }
@@ -288,6 +305,9 @@ async function defaultConfirmBranchCreation(branch) {
     });
     return !isCancel(choice) && choice;
 }
-async function promptForWorktree(worktrees, scope) {
-    return promptForSingleWorktree("Choose a worktree", worktrees, { scope });
+async function promptForWorktree(worktrees, scope, catalog) {
+    return promptForSingleWorktree("Choose a worktree", worktrees, {
+        catalog,
+        scope,
+    });
 }

package/dist/{history-command.d.ts → cli/commands/history-command.d.ts}

@@ -1,7 +1,9 @@
+import { type CliRuntime } from "../dependencies.js";
 export interface HistoryCommandOptions {
     cwd: string;
     home?: string;
     json?: boolean;
+    runtime?: CliRuntime<"historyStore">;
     stdout: (chunk: string) => void;
 }
 export declare function runHistoryCommand(options: HistoryCommandOptions): Promise<number>;

package/dist/{history-command.js → cli/commands/history-command.js}

@@ -1,6 +1,8 @@
+import { defaultCliDependencies } from "../dependencies.js";
 import { formatHistoryList } from "./back.js";
-import { loadHistory } from "./history.js";
 export async function runHistoryCommand(options) {
+    const { loadHistory } = (options.runtime ?? defaultCliDependencies)
+        .historyStore;
     const history = await loadHistory(options.home);
     if (options.json) {
         options.stdout(`${JSON.stringify(history, null, 2)}\n`);

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

@@ -1,5 +1,6 @@
-import { type PullRequestInfo } from "./pull-requests.js";
-import { type WorktreeInfo } from "./worktree-info.js";
+import type { WorktreeInfo } from "../../application/worktree/read-models.js";
+import type { PullRequestInfo } from "../../ports/pull-requests.js";
+import { type CliRuntime } from "../dependencies.js";
 export interface HubCommandOptions {
     cwd: string;
     columns?: number;
@@ -7,6 +8,7 @@ export interface HubCommandOptions {
     now?: number;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
+    runtime?: HubRuntime;
 }
 export interface HubCommandDependencies {
     queryRepositoryPullRequests: (repoRoot: string) => Promise<PullRequestInfo[]>;
@@ -22,10 +24,12 @@ export interface HubRepository {
     root: string;
     worktrees: HubWorktree[];
 }
+type HubRuntime = CliRuntime<"pullRequests" | "repositoryContext" | "repositoryRegistry" | "worktrees" | "worktreeCatalog">;
 export interface HubData {
     currentRepository: string | null;
     repositories: HubRepository[];
 }
-export declare function buildHubData(cwd: string, dependencies?: Partial<HubCommandDependencies>): Promise<HubData>;
+export declare function buildHubData(cwd: string, dependencies?: Partial<HubCommandDependencies>, runtime?: HubRuntime): Promise<HubData>;
 export declare function runHubCommand(options: HubCommandOptions, dependencies?: Partial<HubCommandDependencies>): Promise<number>;
 export declare function formatHubOutput(data: HubData, columns?: number, now?: number): string;
+export {};