@solaqua/gji 0.12.4 → 0.13.0

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,7 +49,11 @@ export function createGoCommand(dependencies = {}) {
             let promptSources = currentSources;
             const loadAllSources = async () => {
                 if (registeredSources === null) {
-                    registeredSources = await listRegisteredWorktreeSources(options.cwd, () => {
+                    registeredSources = await listRegisteredWorktreeSources(options.cwd, {
+                        ...runtime.repositoryContext,
+                        ...runtime.repositoryRegistry,
+                        ...runtime.worktrees,
+                    }, () => {
                         skippedRegisteredRepos++;
                     });
                 }
@@ -77,7 +81,7 @@ export function createGoCommand(dependencies = {}) {
                         return {
                             entries: await buildWorktreePromptEntries(promptSources, {
                                 metadata: currentRepositoryScope ? "full" : "fast",
-                                queryPullRequests: dependencies.queryPullRequests,
+                                catalog: withPullRequestQueries(runtime, dependencies.queryPullRequests),
                             }),
                             label: currentRepositoryScope
                                 ? "current repository"
@@ -91,7 +95,7 @@ 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);
             if (!selectedPath) {
@@ -99,30 +103,40 @@ export function createGoCommand(dependencies = {}) {
                 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 +144,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 +158,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 +168,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 +194,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 +210,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;
     }

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 {};

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

@@ -1,23 +1,24 @@
 import { basename } from "node:path";
 import { stdin, stdout } from "node:process";
 import { spinner } from "@clack/prompts";
-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";
+import { loadWorktreeCatalog } from "../../application/worktree/catalog.js";
+import { listDiscoverableWorktreeSources } from "../../application/worktree/sources.js";
+import { mapWithConcurrency } from "../../domain/shared/concurrency.js";
+import { middleEllipsize, sanitizeTerminalText, terminalWidth, } from "../../presentation/terminal/text.js";
+import { formatRelativeAge, formatUpstreamState, } from "../../presentation/worktree/format.js";
+import { defaultCliDependencies } from "../dependencies.js";
 const MAX_HUB_REPOSITORY_CONCURRENCY = 4;
-const defaultDependencies = {
-    queryRepositoryPullRequests: createPullRequestQuery().listOpenPullRequestsForRepository,
-};
-export async function buildHubData(cwd, dependencies = {}) {
+export async function buildHubData(cwd, dependencies = {}, runtime = defaultCliDependencies) {
+    const { detectRepository } = runtime.repositoryContext;
+    const sourceDependencies = {
+        ...runtime.repositoryContext,
+        ...runtime.repositoryRegistry,
+        ...runtime.worktrees,
+    };
     const queryRepositoryPullRequests = dependencies.queryRepositoryPullRequests ??
-        defaultDependencies.queryRepositoryPullRequests;
+        runtime.pullRequests.listOpenPullRequestsForRepository;
     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 sources = await listDiscoverableWorktreeSources(cwd, sourceDependencies);
     const groups = new Map();
     for (const source of sources) {
         if (!source.repoRoot)
@@ -35,7 +36,6 @@ export async function buildHubData(cwd, dependencies = {}) {
         }
     }
     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);
@@ -43,10 +43,14 @@ export async function buildHubData(cwd, dependencies = {}) {
         catch {
             // PR metadata is optional. The hub remains useful when a provider is unavailable.
         }
-        const worktrees = infos.map((info) => ({
+        const hydrated = await loadWorktreeCatalog(group.sources, "full", {
+            ...runtime.worktreeCatalog,
+            queryRepositoryPullRequests: async () => pullRequests,
+        });
+        const worktrees = hydrated.map(({ info, lastUsedTimestamp, pullRequests }) => ({
             ...info,
-            lastUsedTimestamp: lastUsedByPath.get(info.path) ?? null,
-            pullRequests: pullRequests.filter((pullRequest) => pullRequest.sourceBranch === info.branch),
+            lastUsedTimestamp,
+            pullRequests,
         }));
         return {
             current: currentRepository?.repoRoot === root,
@@ -73,7 +77,7 @@ export async function runHubCommand(options, dependencies = {}) {
     loading?.start("Loading worktrees");
     let data;
     try {
-        data = await buildHubData(options.cwd, dependencies);
+        data = await buildHubData(options.cwd, dependencies, options.runtime);
     }
     finally {
         loading?.stop();
@@ -283,17 +287,3 @@ function formatHumanText(value, 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/{init.d.ts → cli/commands/init.d.ts}

@@ -1,4 +1,5 @@
-import { type SupportedShell } from "./shell.js";
+import { type SupportedShell } from "../../presentation/shell/shell.js";
+import { type CliRuntime } from "../dependencies.js";
 export type InstallSaveTarget = "local" | "global";
 export type ShellIntegrationChoice = "existing" | "install" | "skip";
 export interface SetupWizardResult {
@@ -29,6 +30,7 @@ export interface InitCommandOptions {
     promptForOnboarding?: (context: InitOnboardingContext) => Promise<InitOnboardingResult | null>;
     promptForSetup?: () => Promise<SetupWizardResult | null>;
     shell?: string;
+    runtime?: CliRuntime<"integrations" | "configStore">;
     stderr?: (chunk: string) => void;
     stdout: (chunk: string) => void;
     write?: boolean;

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

@@ -3,12 +3,11 @@ import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname } from "node:path";
 import { confirm, intro, isCancel, log, outro, select, text, } from "@clack/prompts";
-import { loadConfig, loadGlobalConfig, saveGlobalConfig, saveLocalConfig, updateGlobalConfigKey, } from "./config.js";
-import { EDITORS } from "./editor.js";
-import { isHeadless } from "./headless.js";
-import { resolveSupportedShell } from "./shell.js";
-import { renderShellCompletion } from "./shell-completion.js";
-import { SHELL_INTEGRATION_END_MARKER as END_MARKER, executableExists, hasShellIntegration, ONBOARDING_SHELL_INTEGRATION_END_MARKER as ONBOARDING_END_MARKER, ONBOARDING_SHELL_INTEGRATION_START_MARKER as ONBOARDING_START_MARKER, resolveCompletionPath, resolveShellConfigPath, SHELL_INTEGRATION_START_MARKER as START_MARKER, } from "./shell-setup.js";
+import { renderShellCompletion } from "../../presentation/shell/completion.js";
+import { SHELL_INTEGRATION_END_MARKER as END_MARKER, executableExists, hasShellIntegration, ONBOARDING_SHELL_INTEGRATION_END_MARKER as ONBOARDING_END_MARKER, ONBOARDING_SHELL_INTEGRATION_START_MARKER as ONBOARDING_START_MARKER, resolveCompletionPath, resolveShellConfigPath, SHELL_INTEGRATION_START_MARKER as START_MARKER, } from "../../presentation/shell/setup.js";
+import { resolveSupportedShell, } from "../../presentation/shell/shell.js";
+import { defaultCliDependencies, } from "../dependencies.js";
+import { isHeadless } from "../runtime/headless.js";
 const ZSH_COMPLETION_PATH_LINE = "fpath=(~/.zsh/completions $fpath)";
 const SHELL_WRAPPED_COMMANDS = [
     {
@@ -69,12 +68,13 @@ const SHELL_WRAPPED_COMMANDS = [
     },
 ];
 export async function runInitCommand(options) {
+    const runtime = options.runtime ?? defaultCliDependencies;
     if (options.shell === undefined) {
-        return runOnboardingInitCommand(options);
+        return runOnboardingInitCommand(options, runtime);
     }
-    return runLegacyInitCommand(options);
+    return runLegacyInitCommand(options, runtime);
 }
-async function runOnboardingInitCommand(options) {
+async function runOnboardingInitCommand(options, runtime) {
     if (options.json || isHeadless() || !canRunOnboarding(options)) {
         return writeNonInteractiveInitError(options);
     }
@@ -84,14 +84,14 @@ async function runOnboardingInitCommand(options) {
         home,
     };
     if (options.promptForOnboarding === undefined) {
-        return runDefaultOnboarding(context);
+        return runDefaultOnboarding(context, runtime);
     }
     const result = await options.promptForOnboarding(context);
     if (!result) {
         options.stderr?.("Aborted.\n");
         return 1;
     }
-    await applyOnboardingResult(result, home);
+    await applyOnboardingResult(result, home, runtime);
     return 0;
 }
 function canRunOnboarding(options) {
@@ -104,7 +104,7 @@ function writeNonInteractiveInitError(options) {
     options.stderr?.(options.json ? `${JSON.stringify({ error })}\n` : `${error}\n`);
     return 1;
 }
-async function runDefaultOnboarding(context) {
+async function runDefaultOnboarding(context, runtime) {
     intro("gji init");
     const shell = await select({
         message: "Which shell should gji configure?",
@@ -124,7 +124,7 @@ async function runDefaultOnboarding(context) {
         return abortDefaultOnboarding();
     const completionPath = resolveCompletionPath(shell, context.home);
     const completionAlreadyInstalled = await fileExists(completionPath);
-    await applyShellIntegration(shell, shellIntegration, context.home);
+    await applyShellIntegration(shell, shellIntegration, context.home, runtime);
     const installCompletion = await promptForCompletion(shell, completionPath);
     if (installCompletion === null)
         return abortDefaultOnboarding();
@@ -135,21 +135,21 @@ async function runDefaultOnboarding(context) {
     if (shell === "zsh" && (completionAlreadyInstalled || installCompletion)) {
         await ensureZshCompletionPath(rcPath);
     }
-    const editor = await promptForEditor();
+    const editor = await promptForEditor(runtime.integrations.EDITORS);
     if (editor === null)
         return abortDefaultOnboarding();
     if (editor) {
-        await updateGlobalConfigKey("editor", editor, context.home);
+        await runtime.configStore.updateGlobalConfigKey("editor", editor, context.home);
     }
     outro(`Setup complete. Restart your shell or run: source ${rcPath}\nVerify with: gji doctor`);
     return 0;
 }
-async function applyShellIntegration(shell, choice, home) {
+async function applyShellIntegration(shell, choice, home, runtime) {
     if (choice === "install") {
         await installOnboardingShellIntegration(shell, home);
     }
     if (choice !== "skip") {
-        await updateGlobalConfigKey("shellIntegration", true, home);
+        await runtime.configStore.updateGlobalConfigKey("shellIntegration", true, home);
     }
 }
 function abortDefaultOnboarding() {
@@ -187,8 +187,8 @@ async function promptForCompletion(shell, completionPath) {
         return null;
     return confirmed;
 }
-async function promptForEditor() {
-    const availableEditors = await findAvailableEditors();
+async function promptForEditor(editors) {
+    const availableEditors = await findAvailableEditors(editors);
     if (availableEditors.length === 0) {
         log.info("No supported editor CLIs found on PATH; skipping editor setup.");
         return undefined;
@@ -209,20 +209,20 @@ async function promptForEditor() {
         return null;
     return selected === skipValue ? undefined : selected;
 }
-async function findAvailableEditors() {
+async function findAvailableEditors(editors) {
     const availableEditors = [];
-    for (const editor of EDITORS) {
+    for (const editor of editors) {
         if (await executableExists(editor.cli)) {
             availableEditors.push(editor);
         }
     }
     return availableEditors;
 }
-async function applyOnboardingResult(result, home) {
+async function applyOnboardingResult(result, home, runtime) {
     const rcPath = resolveShellConfigPath(result.shell, home);
     const completionPath = resolveCompletionPath(result.shell, home);
     const completionAlreadyInstalled = await fileExists(completionPath);
-    await applyShellIntegration(result.shell, result.shellIntegration, home);
+    await applyShellIntegration(result.shell, result.shellIntegration, home, runtime);
     if (result.installCompletion) {
         await mkdir(dirname(completionPath), { recursive: true });
         await writeFile(completionPath, renderShellCompletion(result.shell), "utf8");
@@ -232,7 +232,7 @@ async function applyOnboardingResult(result, home) {
         await ensureZshCompletionPath(rcPath);
     }
     if (result.editor) {
-        await updateGlobalConfigKey("editor", result.editor, home);
+        await runtime.configStore.updateGlobalConfigKey("editor", result.editor, home);
     }
 }
 async function installOnboardingShellIntegration(shell, home) {
@@ -290,7 +290,7 @@ async function fileExists(path) {
         return false;
     }
 }
-async function runLegacyInitCommand(options) {
+async function runLegacyInitCommand(options, runtime) {
     const shell = resolveSupportedShell(options.shell, process.env.SHELL);
     const home = options.home ?? homedir();
     if (!shell) {
@@ -309,7 +309,7 @@ async function runLegacyInitCommand(options) {
     await writeFile(rcPath, next, "utf8");
     options.stdout(`${rcPath}\n`);
     // Run the setup wizard on the first-ever init (not on subsequent re-runs).
-    const { config: globalConfig } = await loadGlobalConfig(home);
+    const { config: globalConfig } = await runtime.configStore.loadGlobalConfig(home);
     const alreadyConfigured = "shellIntegration" in globalConfig || "installSaveTarget" in globalConfig;
     const hasCustomPrompt = options.promptForSetup !== undefined;
     const canPrompt = !isHeadless() && (hasCustomPrompt || process.stdout.isTTY === true);
@@ -317,12 +317,12 @@ async function runLegacyInitCommand(options) {
         const prompt = options.promptForSetup ?? defaultPromptForSetup;
         const result = await prompt();
         if (result) {
-            await updateGlobalConfigKey("installSaveTarget", result.installSaveTarget, home);
-            await saveWizardConfig(result, options.cwd, home);
+            await runtime.configStore.updateGlobalConfigKey("installSaveTarget", result.installSaveTarget, home);
+            await saveWizardConfig(result, options.cwd, home, runtime);
         }
     }
     // Mark shell integration as installed so the first-run nudge is suppressed.
-    await updateGlobalConfigKey("shellIntegration", true, home);
+    await runtime.configStore.updateGlobalConfigKey("shellIntegration", true, home);
     return 0;
 }
 export function renderShellIntegration(shell) {
@@ -361,7 +361,7 @@ export function upsertShellIntegration(existingConfig, script) {
     }
     return ensureTrailingNewline(`${prefix}\n\n${trimmedScript}`);
 }
-async function saveWizardConfig(result, cwd, home) {
+async function saveWizardConfig(result, cwd, home, runtime) {
     const values = {};
     if (result.branchPrefix)
         values.branchPrefix = result.branchPrefix;
@@ -379,12 +379,15 @@ async function saveWizardConfig(result, cwd, home) {
     if (Object.keys(values).length === 0)
         return;
     if (result.installSaveTarget === "local") {
-        const loaded = await loadConfig(cwd);
-        await saveLocalConfig(cwd, { ...loaded.config, ...values });
+        const loaded = await runtime.configStore.loadConfig(cwd);
+        await runtime.configStore.saveLocalConfig(cwd, {
+            ...loaded.config,
+            ...values,
+        });
     }
     else {
-        const { config: existing } = await loadGlobalConfig(home);
-        await saveGlobalConfig({ ...existing, ...values }, home);
+        const { config: existing } = await runtime.configStore.loadGlobalConfig(home);
+        await runtime.configStore.saveGlobalConfig({ ...existing, ...values }, home);
     }
 }
 async function readExistingConfig(path) {

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

@@ -1,9 +1,11 @@
-import { type WorktreeEntry } from "./repo.js";
-import { type WorktreeInfo } from "./worktree-info.js";
+import type { WorktreeInfo } from "../../application/worktree/read-models.js";
+import type { WorktreeEntry } from "../../domain/worktree/types.js";
+import { type CliRuntime } from "../dependencies.js";
 export interface LsCommandOptions {
     compact?: boolean;
     cwd: string;
     json?: boolean;
+    runtime?: CliRuntime<"worktrees" | "worktreeInfo">;
     stdout: (chunk: string) => void;
 }
 export declare function runLsCommand(options: LsCommandOptions): Promise<number>;

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

@@ -1,7 +1,10 @@
-import { comparePaths } from "./paths.js";
-import { listWorktrees } from "./repo.js";
-import { formatLastCommit, formatUpstreamState, readWorktreeInfos, } from "./worktree-info.js";
+import { comparePaths } from "../../domain/shared/paths.js";
+import { formatLastCommit, formatUpstreamState, } from "../../presentation/worktree/format.js";
+import { defaultCliDependencies } from "../dependencies.js";
 export async function runLsCommand(options) {
+    const runtime = options.runtime ?? defaultCliDependencies;
+    const { listWorktrees } = runtime.worktrees;
+    const { readWorktreeInfos } = runtime.worktreeInfo;
     const worktrees = sortWorktrees(await listWorktrees(options.cwd));
     if (options.compact) {
         if (options.json) {
@@ -44,7 +47,7 @@ export function formatDetailedWorktreeTable(worktrees) {
             "UPSTREAM".padEnd(upstreamWidth, " ") +
             " " +
             "LAST".padEnd(lastCommitWidth, " ") +
-            (hasTasks ? " " + "TASK".padEnd(taskWidth, " ") : "") +
+            (hasTasks ? ` ${"TASK".padEnd(taskWidth, " ")}` : "") +
             " PATH",
     ];
     for (const row of rows) {
@@ -68,7 +71,7 @@ export function formatWorktreeTable(worktrees) {
         path: worktree.path,
     }));
     const branchWidth = Math.max("BRANCH".length, ...rows.map((row) => row.branch.length));
-    const lines = ["  " + "BRANCH".padEnd(branchWidth, " ") + " PATH"];
+    const lines = [`  ${"BRANCH".padEnd(branchWidth, " ")} PATH`];
     for (const row of rows) {
         lines.push(`${row.isCurrent ? "*" : " "} ${row.branch.padEnd(branchWidth, " ")} ${row.path}`);
     }