@solaqua/gji 0.12.4 → 0.13.0

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

@@ -1,13 +1,10 @@
 import { confirm, isCancel } from "@clack/prompts";
-import { loadEffectiveConfig } from "./config.js";
-import { isBranchMergedInto, readWorktreeHealth, resolveRemoteDefaultBranch, runGit, } from "./git.js";
-import { isHeadless } from "./headless.js";
-import { releaseWorktreeSlot } from "./slots.js";
+import { loadLinkedWorktrees } from "../../application/worktree/catalog.js";
+import { buildWorktreePromptEntries, promptForMultipleWorktrees, } from "../../presentation/worktree/picker.js";
+import { defaultConfirmForceDeleteBranch, defaultConfirmForceRemoveWorktree, } from "../../presentation/worktree/prompts.js";
+import { defaultCliDependencies, } from "../dependencies.js";
+import { isHeadless } from "../runtime/headless.js";
 import { finalizeUndoOperation, recordUndoOperation } from "./undo.js";
-import { formatLastCommit, formatUpstreamState, readWorktreeInfos, serializeWorktreeInfo, } from "./worktree-info.js";
-import { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isSubmoduleWorktreeRemovalError, isWorktreeDeletionError, isWorktreeForceRemovalError, loadLinkedWorktrees, removeWorktree, } from "./worktree-management.js";
-import { buildWorktreePromptEntries, promptForMultipleWorktrees, } from "./worktree-picker.js";
-import { defaultConfirmForceDeleteBranch, defaultConfirmForceRemoveWorktree, } from "./worktree-prompts.js";
 export function createCleanCommand(dependencies = {}) {
     const promptForWorktrees = dependencies.promptForWorktrees ?? defaultPromptForWorktrees;
     const confirmRemoval = dependencies.confirmRemoval ?? defaultConfirmRemoval;
@@ -15,13 +12,24 @@ export function createCleanCommand(dependencies = {}) {
         defaultConfirmForceRemoveWorktree;
     const confirmForceDeleteBranch = dependencies.confirmForceDeleteBranch ?? defaultConfirmForceDeleteBranch;
     return async function runCleanCommand(options) {
-        const { linkedWorktrees, repository } = await loadLinkedWorktrees(options.cwd);
+        const runtime = options.runtime ?? defaultCliDependencies;
+        const { readWorktreeHealth, isBranchMergedInto, resolveRemoteDefaultBranch, runGit, } = runtime.git;
+        const { loadEffectiveConfig } = runtime.config;
+        const { releaseWorktreeSlot } = runtime.slots;
+        const sourceDependencies = {
+            ...runtime.repositoryContext,
+            ...runtime.repositoryRegistry,
+            ...runtime.worktrees,
+        };
+        const { formatLastCommit, formatUpstreamState, readWorktreeInfos, serializeWorktreeInfo, } = runtime.worktreeInfo;
+        const { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isSubmoduleWorktreeRemovalError, isWorktreeDeletionError, isWorktreeForceRemovalError, removeWorktree, } = runtime.worktreeLifecycle;
+        const { linkedWorktrees, repository } = await loadLinkedWorktrees(options.cwd, sourceDependencies);
         const linkedCleanupCandidates = linkedWorktrees.filter((worktree) => worktree.path !== repository.currentRoot);
         const staleBaseRef = options.stale
-            ? await resolveStaleBaseRef(repository.repoRoot, options.stderr)
+            ? await resolveStaleBaseRef(repository.repoRoot, options.stderr, loadEffectiveConfig, resolveRemoteDefaultBranch, runGit)
             : null;
         const cleanupCandidates = options.stale
-            ? await filterStaleCleanupCandidates(repository.repoRoot, linkedCleanupCandidates, staleBaseRef)
+            ? await filterStaleCleanupCandidates(repository.repoRoot, linkedCleanupCandidates, staleBaseRef, readWorktreeHealth, isBranchMergedInto)
             : linkedCleanupCandidates;
         if (cleanupCandidates.length === 0) {
             if (options.stale) {
@@ -49,7 +57,7 @@ export function createCleanCommand(dependencies = {}) {
             : await promptForWorktrees(await buildWorktreePromptEntries(cleanupCandidates.map((worktree) => ({
                 repoName: repository.repoName,
                 worktree,
-            }))));
+            })), { catalog: runtime.worktreeCatalog }));
         if (!selections || selections.length === 0) {
             options.stderr("Aborted\n");
             return 1;
@@ -74,7 +82,7 @@ export function createCleanCommand(dependencies = {}) {
             }
             else {
                 for (const info of selectedWorktreeInfos) {
-                    options.stdout(`Would remove worktree at ${info.path} (${formatCleanInfo(info)})\n`);
+                    options.stdout(`Would remove worktree at ${info.path} (${formatCleanInfo(info, formatLastCommit, formatUpstreamState)})\n`);
                 }
             }
             return 0;
@@ -83,7 +91,7 @@ export function createCleanCommand(dependencies = {}) {
         const failures = [];
         let journal;
         try {
-            journal = await recordUndoOperation("clean", repository.repoRoot, selectedWorktrees);
+            journal = await recordUndoOperation("clean", repository.repoRoot, selectedWorktrees, undefined, runtime);
         }
         catch (error) {
             emitError(options, `could not write undo journal; no worktrees were removed: ${toMessage(error)}`);
@@ -95,7 +103,7 @@ export function createCleanCommand(dependencies = {}) {
         }
         for (const worktree of selectedWorktrees) {
             if (options.stale &&
-                !(await isStaleCleanupCandidate(repository.repoRoot, worktree, staleBaseRef))) {
+                !(await isStaleCleanupCandidate(repository.repoRoot, worktree, staleBaseRef, readWorktreeHealth, isBranchMergedInto))) {
                 options.stderr(`Skipped ${worktree.path}: no longer a safe stale cleanup candidate\n`);
                 continue;
             }
@@ -167,7 +175,7 @@ export function createCleanCommand(dependencies = {}) {
                 }
             }
         }
-        await finalizeUndoOperation(journal, removedWorktrees);
+        await finalizeUndoOperation(journal, removedWorktrees, undefined, runtime.configStore.GLOBAL_CONFIG_DIRECTORY);
         await Promise.all(removedWorktrees.map((worktree) => releaseWorktreeSlot(worktree.path)));
         if (options.json) {
             const removed = removedWorktrees.map((worktree) => {
@@ -190,31 +198,31 @@ export function createCleanCommand(dependencies = {}) {
     };
 }
 export const runCleanCommand = createCleanCommand();
-async function filterStaleCleanupCandidates(repoRoot, worktrees, baseBranch) {
+async function filterStaleCleanupCandidates(repoRoot, worktrees, baseBranch, readWorktreeHealth, isBranchMergedInto) {
     if (baseBranch === null) {
         return [];
     }
-    const results = await Promise.all(worktrees.map((worktree) => isStaleCleanupCandidate(repoRoot, worktree, baseBranch)));
+    const results = await Promise.all(worktrees.map((worktree) => isStaleCleanupCandidate(repoRoot, worktree, baseBranch, readWorktreeHealth, isBranchMergedInto)));
     return worktrees.filter((_, index) => results[index]);
 }
-async function resolveStaleBaseRef(repoRoot, stderr) {
+async function resolveStaleBaseRef(repoRoot, stderr, loadEffectiveConfig, resolveRemoteDefaultBranch, runGit) {
     const config = await loadEffectiveConfig(repoRoot, undefined, stderr);
     const remote = resolveConfiguredString(config.syncRemote) ?? "origin";
     const configuredDefaultBranch = resolveConfiguredString(config.syncDefaultBranch);
     if (configuredDefaultBranch) {
-        return await resolveFetchedRemoteRef(repoRoot, remote, configuredDefaultBranch);
+        return await resolveFetchedRemoteRef(repoRoot, remote, configuredDefaultBranch, runGit);
     }
     try {
         const remoteDefaultBranch = await resolveRemoteDefaultBranch(repoRoot, remote);
         return remoteDefaultBranch === null
             ? null
-            : await resolveFetchedRemoteRef(repoRoot, remote, remoteDefaultBranch);
+            : await resolveFetchedRemoteRef(repoRoot, remote, remoteDefaultBranch, runGit);
     }
     catch {
         return null;
     }
 }
-async function resolveFetchedRemoteRef(repoRoot, remote, branch) {
+async function resolveFetchedRemoteRef(repoRoot, remote, branch, runGit) {
     try {
         await runGit(repoRoot, ["fetch", "--prune", remote]);
         return `${remote}/${branch}`;
@@ -226,7 +234,7 @@ async function resolveFetchedRemoteRef(repoRoot, remote, branch) {
 function resolveConfiguredString(value) {
     return typeof value === "string" && value.length > 0 ? value : null;
 }
-async function isStaleCleanupCandidate(repoRoot, worktree, baseBranch) {
+async function isStaleCleanupCandidate(repoRoot, worktree, baseBranch, readWorktreeHealth, isBranchMergedInto) {
     if (baseBranch === null) {
         return false;
     }
@@ -260,7 +268,7 @@ function reportCleanFailures(failures, stderr) {
         stderr(`- ${failure.path} (${branch}): ${failure.message}\n`);
     }
 }
-function formatCleanInfo(info) {
+function formatCleanInfo(info, formatLastCommit, formatUpstreamState) {
     const branch = info.branch === null ? "detached" : `branch: ${info.branch}`;
     const status = `status: ${info.status}`;
     const upstream = `upstream: ${formatUpstreamState(info.upstream)}`;

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

@@ -1,5 +1,5 @@
-import { resolveSupportedShell } from "./shell.js";
-import { renderShellCompletion } from "./shell-completion.js";
+import { renderShellCompletion } from "../../presentation/shell/completion.js";
+import { resolveSupportedShell } from "../../presentation/shell/shell.js";
 export async function runCompletionCommand(options) {
     const shell = options.shell
         ? resolveSupportedShell(options.shell, undefined)

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

@@ -1,3 +1,4 @@
+import { type CliRuntime } from "../dependencies.js";
 export interface ConfigCommandOptions {
     action?: string;
     cwd: string;
@@ -5,5 +6,6 @@ export interface ConfigCommandOptions {
     stderr?: (chunk: string) => void;
     stdout: (chunk: string) => void;
     value?: string;
+    runtime?: CliRuntime<"configStore">;
 }
 export declare function runConfigCommand(options: ConfigCommandOptions): Promise<number>;

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

@@ -1,20 +1,22 @@
-import { loadGlobalConfig, parseConfigValue, unsetGlobalConfigKey, updateGlobalConfigKey, } from "./config.js";
+import { defaultCliDependencies } from "../dependencies.js";
 export async function runConfigCommand(options) {
+    const runtime = options.runtime ?? defaultCliDependencies;
+    const config = runtime.configStore;
     switch (options.action) {
         case undefined: {
-            const loaded = await loadGlobalConfig();
+            const loaded = await config.loadGlobalConfig();
             writeJson(options.stdout, loaded.config);
             return 0;
         }
         case "get": {
-            const loaded = await loadGlobalConfig();
+            const loaded = await config.loadGlobalConfig();
             writeJson(options.stdout, options.key ? loaded.config[options.key] : loaded.config);
             return 0;
         }
         case "set":
             if (options.key && options.value !== undefined) {
                 try {
-                    await updateGlobalConfigKey(options.key, parseConfigValue(options.value));
+                    await config.updateGlobalConfigKey(options.key, config.parseConfigValue(options.value));
                 }
                 catch (error) {
                     options.stderr?.(`gji config: ${error instanceof Error ? error.message : String(error)}\n`);
@@ -25,7 +27,7 @@ export async function runConfigCommand(options) {
             break;
         case "unset":
             if (options.key) {
-                await unsetGlobalConfigKey(options.key);
+                await config.unsetGlobalConfigKey(options.key);
                 return 0;
             }
             break;

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

@@ -1,3 +1,4 @@
+import { type CliRuntime } from "../dependencies.js";
 export type DoctorCheckStatus = "fail" | "ok" | "skip";
 export interface DoctorCheck {
     hint?: string;
@@ -22,6 +23,7 @@ export interface DoctorCommandOptions {
     confirmFixes?: (fixes: DoctorFix[]) => Promise<boolean>;
     shell?: string;
     yes?: boolean;
+    runtime?: CliRuntime<"integrations" | "slots" | "repositoryContext" | "configStore" | "registry">;
     stderr?: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }

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,5 @@
-import { type QueryWorktreePullRequests, type WorktreePromptEntry, type WorktreePromptScope } from "./worktree-picker.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 +9,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>;
     queryPullRequests: QueryWorktreePullRequests;
+    runtime: GoRuntime;
 }
 export declare function createGoCommand(dependencies?: Partial<GoCommandDependencies>): (options: GoCommandOptions) => Promise<number>;
 export declare const runGoCommand: (options: GoCommandOptions) => Promise<number>;
+export {};