@solaqua/gji 0.9.0 → 0.11.0

package/dist/worktree-bootstrap.js

@@ -0,0 +1,93 @@
+import { basename } from "node:path";
+import { executeDependencyBootstrap, prepareDependencyBootstrap, } from "./dependency-bootstrap.js";
+import { cloneDir } from "./dir-clone.js";
+import { syncFiles } from "./file-sync.js";
+import { extractHooks, runHook } from "./hooks.js";
+import { maybeRunInstallPrompt, } from "./install-prompt.js";
+import { executeSyncDirectoryPlan, } from "./sync-directories.js";
+import { prepareSyncDirectoryPlan } from "./sync-plan.js";
+export async function bootstrapWorktree(options) {
+    const dependencyMode = options.config.dependencyBootstrap ?? "off";
+    const dependencyPlan = await prepareDependencyBootstrap(dependencyMode, {
+        currentRoot: options.currentRoot,
+        detectionRoot: options.dependencyDetectionRoot,
+        repoRoot: options.repoRoot,
+        cargoBuildCommand: options.config.dependencyBuildCommand,
+        worktreePath: options.worktreePath,
+    });
+    const syncPlan = await prepareSyncDirectoryPlan(options.repoRoot, options.worktreePath, options.config.syncDirs ?? []);
+    const outcomes = await executeSyncDirectoryPlan(syncPlan, {
+        cloneDirectory: options.cloneDirectory ?? cloneDir,
+        repoRoot: options.repoRoot,
+        reporter: options.reporter,
+    });
+    const clonedDirs = outcomes.flatMap((outcome) => outcome.kind === "cloned" ? [outcome.directory] : []);
+    const skippedDirs = outcomes.flatMap((outcome) => outcome.kind === "skipped"
+        ? [{ dir: outcome.dir, reason: outcome.reason }]
+        : []);
+    const syncFileFailures = [];
+    for (const pattern of options.config.syncFiles ?? []) {
+        try {
+            await syncFiles(options.repoRoot, options.worktreePath, [pattern]);
+        }
+        catch (error) {
+            const message = `failed to sync file "${pattern}": ${toErrorMessage(error)}`;
+            if (!options.json)
+                options.reporter.write(`Warning: ${message}\n`);
+            syncFileFailures.push({
+                adapter: "syncFiles",
+                kind: "sync-file",
+                reason: "sync-file-failed",
+                state: "failed",
+                target: pattern,
+                message,
+            });
+        }
+    }
+    if (syncFileFailures.length > 0) {
+        for (const event of syncFileFailures)
+            options.reporter.dependency(event);
+    }
+    const dependencyBootstrap = syncFileFailures.length > 0
+        ? { mode: dependencyMode, ready: false, events: [] }
+        : await executeDependencyBootstrap(dependencyPlan, {
+            cloneDirectory: options.cloneDirectory,
+            repoRoot: options.repoRoot,
+            reporter: options.reporter,
+            stderr: options.commandStderr ?? options.reporter.write,
+            stdout: options.commandStdout,
+            seededDirectories: clonedDirs.map(({ dir }) => dir),
+            runCommand: options.runCommand,
+        });
+    if (!dependencyBootstrap.ready) {
+        return {
+            clonedDirs,
+            dependencyBootstrap,
+            ready: false,
+            syncFileFailures,
+            skippedDirs,
+        };
+    }
+    if (dependencyMode === "off" &&
+        ["default", "legacy"].includes(options.dependencyBootstrapPolicy?.source ?? "default")) {
+        await maybeRunInstallPrompt(options.worktreePath, options.repoRoot, options.config, options.reporter.write, options.installDependencies, options.nonInteractive);
+    }
+    const hooks = extractHooks(options.config);
+    await runHook(hooks["after-create"], options.worktreePath, {
+        branch: options.branch,
+        path: options.worktreePath,
+        repo: basename(options.repoRoot),
+    }, options.reporter.write, options.json
+        ? () => undefined
+        : (options.commandStdout ?? ((chunk) => process.stdout.write(chunk))));
+    return {
+        clonedDirs,
+        dependencyBootstrap,
+        ready: true,
+        syncFileFailures: [],
+        skippedDirs,
+    };
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/worktree-management.d.ts

@@ -9,5 +9,6 @@ export declare function forceRemoveWorktree(repoRoot: string, worktreePath: stri
 export declare function deleteBranch(repoRoot: string, branch: string): Promise<void>;
 export declare function forceDeleteBranch(repoRoot: string, branch: string): Promise<void>;
 export declare function isWorktreeForceRemovalError(error: unknown): boolean;
+export declare function isSubmoduleWorktreeRemovalError(error: unknown): boolean;
 export declare function isWorktreeDeletionError(error: unknown): boolean;
 export declare function isBranchUnmergedError(error: unknown): boolean;

package/dist/worktree-management.js

@@ -21,12 +21,14 @@ export async function removeWorktree(repoRoot, worktreePath) {
 }
 export async function forceRemoveWorktree(repoRoot, worktreePath) {
     try {
-        await execFileAsync("git", ["worktree", "remove", "--force", worktreePath], {
-            cwd: repoRoot,
-            env: GIT_ENV,
-        });
+        await removeWorktreeWithForce(repoRoot, worktreePath);
     }
     catch (error) {
+        if (isSubmoduleWorktreeRemovalError(error)) {
+            await deinitializeSubmodules(worktreePath);
+            await removeWorktreeWithForce(repoRoot, worktreePath);
+            return;
+        }
         const worktreeIsStillRegistered = (await listWorktrees(repoRoot)).some((worktree) => worktree.path === worktreePath);
         if (worktreeIsStillRegistered) {
             throw error;
@@ -34,6 +36,18 @@ export async function forceRemoveWorktree(repoRoot, worktreePath) {
         await rm(worktreePath, { force: true, recursive: true });
     }
 }
+async function removeWorktreeWithForce(repoRoot, worktreePath) {
+    await execFileAsync("git", ["worktree", "remove", "--force", worktreePath], {
+        cwd: repoRoot,
+        env: GIT_ENV,
+    });
+}
+async function deinitializeSubmodules(worktreePath) {
+    await execFileAsync("git", ["submodule", "deinit", "--force", "--all"], {
+        cwd: worktreePath,
+        env: GIT_ENV,
+    });
+}
 export async function deleteBranch(repoRoot, branch) {
     await execFileAsync("git", ["branch", "-d", branch], {
         cwd: repoRoot,
@@ -51,8 +65,13 @@ export function isWorktreeForceRemovalError(error) {
         return false;
     }
     return (error.stderr.includes("contains modified or untracked files") ||
+        isSubmoduleWorktreeRemovalError(error) ||
         isWorktreeDeletionError(error));
 }
+export function isSubmoduleWorktreeRemovalError(error) {
+    return (hasStderr(error) &&
+        error.stderr.includes("working trees containing submodules cannot be moved or removed"));
+}
 export function isWorktreeDeletionError(error) {
     return hasStderr(error) && error.stderr.includes("failed to delete");
 }

package/dist/worktree-picker.d.ts

@@ -1,11 +1,8 @@
 import type { Readable, Writable } from "node:stream";
 import { type PullRequestInfo } from "./pull-requests.js";
 import type { WorktreeEntry } from "./repo.js";
-export interface WorktreePromptSource {
-    repoRoot?: string;
-    repoName: string;
-    worktree: WorktreeEntry;
-}
+import type { WorktreeSource } from "./worktree-source.js";
+export type WorktreePromptSource = WorktreeSource;
 export interface WorktreePromptEntry extends WorktreeEntry {
     group: "recent" | "other";
     label: string;
@@ -17,9 +14,11 @@ export interface WorktreePromptEntry extends WorktreeEntry {
 export type QueryWorktreePullRequests = (repoRoot: string, sourceBranch: string) => Promise<PullRequestInfo[]>;
 export type QueryRepositoryPullRequests = (repoRoot: string) => Promise<PullRequestInfo[]>;
 export interface BuildWorktreePromptEntriesDependencies {
+    metadata?: WorktreeMetadataMode;
     queryPullRequests?: QueryWorktreePullRequests;
     queryRepositoryPullRequests?: QueryRepositoryPullRequests;
 }
+export type WorktreeMetadataMode = "full" | "fast";
 export interface WorktreePickerIO {
     input?: Readable & {
         isTTY?: boolean;
@@ -30,8 +29,22 @@ export interface WorktreePickerIO {
         rows?: number;
     };
 }
-export declare function buildWorktreePromptEntries(sources: WorktreePromptSource[], dependencies?: BuildWorktreePromptEntriesDependencies): Promise<WorktreePromptEntry[]>;
-export declare function resolveWorktreeQuery(sources: WorktreePromptSource[], query: string): WorktreePromptSource | null;
-export declare function promptForSingleWorktree(message: string, worktrees: WorktreePromptEntry[], io?: WorktreePickerIO): Promise<string | null>;
+export interface WorktreePromptScope {
+    label: string;
+    toggle: () => Promise<WorktreePromptScopeResult>;
+    toggleLabel: string;
+}
+export interface WorktreePromptScopeResult {
+    entries: WorktreePromptEntry[];
+    label: string;
+    toggleLabel: string;
+}
+export declare function buildWorktreePromptEntries(sources: WorktreeSource[], dependencies?: BuildWorktreePromptEntriesDependencies): Promise<WorktreePromptEntry[]>;
+export declare function resolveWorktreeQuery(sources: WorktreeSource[], query: string): WorktreeSource | null;
+export declare function resolveWorktreeQueryMatches(sources: WorktreeSource[], query: string): WorktreeSource[];
+export declare function resolveExactWorktreeQueryMatches(sources: WorktreeSource[], query: string): WorktreeSource[];
+export declare function promptForSingleWorktree(message: string, worktrees: WorktreePromptEntry[], io?: WorktreePickerIO & {
+    scope?: WorktreePromptScope;
+}): Promise<string | null>;
 export declare function promptForMultipleWorktrees(message: string, worktrees: WorktreePromptEntry[], io?: WorktreePickerIO): Promise<string[] | null>;
 export declare function formatWorktreeBranchLabel(branch: string | null, pullRequestNumbers?: number[]): string;

package/dist/worktree-picker.js

@@ -5,35 +5,66 @@ import { createPullRequestQuery, } from "./pull-requests.js";
 import { readWorktreeInfos, } from "./worktree-info.js";
 const MAX_PULL_REQUEST_REPOSITORY_QUERY_CONCURRENCY = 4;
 export async function buildWorktreePromptEntries(sources, dependencies = {}) {
+    const metadataMode = dependencies.metadata ?? "full";
+    const includeMetadata = metadataMode === "full";
     const pullRequestQuery = createPullRequestQuery();
     const queryPullRequests = dependencies.queryPullRequests ?? pullRequestQuery.listOpenPullRequests;
-    const queryRepositoryPullRequests = dependencies.queryRepositoryPullRequests ??
-        (dependencies.queryPullRequests === undefined
-            ? pullRequestQuery.listOpenPullRequestsForRepository
-            : undefined);
+    const queryRepositoryPullRequests = includeMetadata
+        ? (dependencies.queryRepositoryPullRequests ??
+            (dependencies.queryPullRequests === undefined
+                ? pullRequestQuery.listOpenPullRequestsForRepository
+                : undefined))
+        : undefined;
     const repositoryPullRequests = queryRepositoryPullRequests === undefined
         ? Promise.resolve(null)
         : readRepositoryPullRequests(sources, queryRepositoryPullRequests);
     const [history, infos, pullRequestsByRepository] = await Promise.all([
         loadHistory(),
-        readWorktreeInfos(sources.map((source) => source.worktree)),
+        includeMetadata
+            ? readWorktreeInfos(sources.map((source) => source.worktree))
+            : Promise.resolve(sources.map((source) => createUnhydratedWorktreeInfo(source.worktree))),
         repositoryPullRequests,
     ]);
-    const pullRequests = await Promise.all(sources.map((source) => readSourcePullRequests(source, queryPullRequests, pullRequestsByRepository)));
+    const pullRequests = includeMetadata
+        ? await Promise.all(sources.map((source) => readSourcePullRequests(source, queryPullRequests, pullRequestsByRepository)))
+        : sources.map(() => []);
     const historyByPath = new Map(history.map((entry) => [entry.path, entry]));
     const entries = sources.map((source, index) => buildWorktreePromptEntry(source, infos[index], pullRequests[index], historyByPath.get(source.worktree.path)?.timestamp ?? null, Date.now()));
     return entries
         .sort(comparePromptEntries)
         .map(({ lastActivityTimestamp: _lastActivityTimestamp, ...entry }) => entry);
 }
+function createUnhydratedWorktreeInfo(worktree) {
+    return {
+        ...worktree,
+        lastCommitTimestamp: null,
+        status: "unknown",
+        upstream: { kind: "unknown" },
+    };
+}
 export function resolveWorktreeQuery(sources, query) {
+    return resolveWorktreeQueryMatches(sources, query)[0] ?? null;
+}
+export function resolveWorktreeQueryMatches(sources, query) {
     const normalizedQuery = normalizeQuery(query);
     if (normalizedQuery === null)
-        return null;
+        return [];
     const matches = findWorktreePromptSourceMatches(sources, normalizedQuery);
     if (isAmbiguousRepoOnlyQuery(matches, normalizedQuery))
-        return null;
-    return matches[0]?.source ?? null;
+        return [];
+    const bestScore = matches[0]?.matchScore;
+    return matches
+        .filter((match) => match.matchScore === bestScore)
+        .map((match) => match.source);
+}
+export function resolveExactWorktreeQueryMatches(sources, query) {
+    const normalizedQuery = normalizeQuery(query);
+    if (normalizedQuery === null)
+        return [];
+    return sources.filter((source) => scoreWorktreeMatch({
+        ...source.worktree,
+        repoName: source.repoName,
+    }, normalizedQuery) === 1000);
 }
 function findWorktreePromptSourceMatches(sources, normalizedQuery) {
     return sources
@@ -59,6 +90,7 @@ export async function promptForSingleWorktree(message, worktrees, io = {}) {
         message,
         multiple: false,
         output: io.output,
+        scope: io.scope,
     });
     return typeof choice === "string" ? choice : null;
 }
@@ -144,13 +176,18 @@ class SearchablePrompt {
     options;
     output;
     cursor = 0;
+    entries;
     query = "";
     searchActive = false;
     selected = new Set();
+    scope;
+    scopeTogglePending = false;
     prompt;
     constructor(options, input, output) {
         this.options = options;
         this.output = output;
+        this.entries = options.entries;
+        this.scope = options.scope;
         this.cursor = this.firstSelectableIndex();
         const owner = this;
         this.prompt = new WorktreeCorePrompt(this, {
@@ -183,6 +220,10 @@ class SearchablePrompt {
             this.submit(prompt);
             return;
         }
+        if (isScopeToggleKey(character, key)) {
+            void this.toggleScope(prompt);
+            return;
+        }
         if (this.searchActive && this.handleSearchKey(character, key?.name)) {
             this.syncValue();
             renderPrompt(prompt);
@@ -200,6 +241,34 @@ class SearchablePrompt {
         this.syncValue();
         renderPrompt(prompt);
     }
+    async toggleScope(prompt) {
+        const currentScope = this.scope;
+        if (currentScope === undefined || this.scopeTogglePending)
+            return;
+        this.scopeTogglePending = true;
+        renderPrompt(prompt);
+        try {
+            const nextScope = await currentScope.toggle();
+            this.entries = nextScope.entries.map(buildSearchableWorktreeEntry);
+            this.scope = {
+                label: nextScope.label,
+                toggle: currentScope.toggle,
+                toggleLabel: nextScope.toggleLabel,
+            };
+            this.query = "";
+            this.cursor = this.firstSelectableIndex();
+            this.syncValue();
+        }
+        catch (error) {
+            prompt.error =
+                error instanceof Error ? error.message : "Could not load worktrees";
+            prompt.state = "error";
+        }
+        finally {
+            this.scopeTogglePending = false;
+            renderPrompt(prompt);
+        }
+    }
     handleEscapeKey(prompt) {
         if (this.searchActive) {
             this.searchActive = false;
@@ -334,20 +403,40 @@ class SearchablePrompt {
     renderTitle(state, glyphs, colors) {
         const symbol = colors.symbol(promptSymbol(state, glyphs), state);
         const maxTitleLength = Math.max(8, this.columns() - 3);
+        const title = this.scope
+            ? `${this.options.message} · ${this.scope.label}`
+            : this.options.message;
         if (!this.searchActive) {
-            return `${symbol}  ${middleEllipsize(this.options.message, maxTitleLength)}`;
+            return `${symbol}  ${middleEllipsize(title, maxTitleLength)}`;
         }
         const search = ` /${this.query}`;
         const maxSearchLength = Math.min(terminalWidth(search), Math.floor(maxTitleLength / 2));
-        const message = middleEllipsize(this.options.message, Math.max(1, maxTitleLength - maxSearchLength));
+        const message = middleEllipsize(title, Math.max(1, maxTitleLength - maxSearchLength));
         const visibleSearch = middleEllipsize(search, Math.max(1, maxTitleLength - terminalWidth(message)));
         return `${symbol}  ${message}${colors.search(visibleSearch)}`;
     }
     renderSearchHint(colors) {
+        const scopeHint = this.scope
+            ? `${colors.key("tab")} ${colors.hint(this.scope.toggleLabel)}`
+            : null;
+        const separator = colors.hint(" · ");
+        if (this.scopeTogglePending) {
+            return `${colors.hint("loading worktrees")} ${separator}${scopeHint}`;
+        }
         if (this.searchActive) {
-            return `${colors.hint("type to filter")} ${colors.hint("·")} ${colors.key("esc")} ${colors.hint("clears")}`;
+            return [
+                `${colors.hint("type to filter")} ${separator} ${colors.key("esc")} ${colors.hint("clears")}`,
+                scopeHint,
+            ]
+                .filter((hint) => hint !== null)
+                .join(separator);
         }
-        return `${colors.hint("press ")}${colors.key("/")}${colors.hint(" to search")}`;
+        return [
+            `${colors.hint("press ")}${colors.key("/")}${colors.hint(" to search")}`,
+            scopeHint,
+        ]
+            .filter((hint) => hint !== null)
+            .join(separator);
     }
     renderEntries(entries, visibleEntries, glyphs, colors, frame) {
         if (entries.length === 0) {
@@ -460,9 +549,9 @@ class SearchablePrompt {
     visibleEntries() {
         const query = normalizeQuery(this.query);
         if (query === null) {
-            return this.options.entries;
+            return this.entries;
         }
-        return filterSearchablePromptEntries(this.options.entries, query);
+        return filterSearchablePromptEntries(this.entries, query);
     }
     maxItems() {
         const rows = this.output.rows ?? 16;
@@ -505,6 +594,9 @@ function closePrompt(prompt) {
 function onWorktreeKeypress(character, key) {
     this.worktreePrompt.handleKeypress(this, character, key);
 }
+function isScopeToggleKey(character, key) {
+    return key?.name === "tab" || character === "\t";
+}
 function resolvePromptAction(character, key) {
     if ((key?.ctrl && key.name === "c") || character === "\u0003") {
         return "cancel";

package/dist/worktree-prompts.js

@@ -4,7 +4,7 @@ export async function defaultConfirmForceRemoveWorktree(worktreePath) {
         active: "Yes",
         inactive: "No",
         initialValue: false,
-        message: `Worktree at ${worktreePath} has untracked or modified files. Force remove?`,
+        message: `Worktree at ${worktreePath} contains files or initialized submodules that cannot be undone. Force remove?`,
     });
     return !isCancel(choice) && choice;
 }

package/dist/worktree-source.d.ts

@@ -0,0 +1,6 @@
+import type { WorktreeEntry } from "./repo.js";
+export interface WorktreeSource {
+    repoRoot?: string;
+    repoName: string;
+    worktree: WorktreeEntry;
+}

package/dist/worktree-source.js

@@ -0,0 +1 @@
+export {};

package/dist/worktree-sources.d.ts

@@ -0,0 +1,3 @@
+import { type RepoRegistryEntry } from "./repo-registry.js";
+import type { WorktreeSource } from "./worktree-source.js";
+export declare function listRegisteredWorktreeSources(cwd: string, onSkipped?: (entry: RepoRegistryEntry) => void): Promise<WorktreeSource[]>;

package/dist/worktree-sources.js

@@ -0,0 +1,31 @@
+import { detectRepository, listWorktrees } from "./repo.js";
+import { loadRegistry } from "./repo-registry.js";
+export async function listRegisteredWorktreeSources(cwd, onSkipped) {
+    const registry = await loadRegistry();
+    const currentRoot = await detectRepository(cwd)
+        .then((repository) => repository.currentRoot)
+        .catch(() => null);
+    const results = await Promise.allSettled(registry.map(async (entry) => {
+        const worktrees = await listWorktrees(entry.path);
+        return { repoName: entry.name, repoRoot: entry.path, worktrees };
+    }));
+    const allItems = [];
+    for (const [index, result] of results.entries()) {
+        if (result.status === "rejected") {
+            onSkipped?.(registry[index]);
+            continue;
+        }
+        const { repoName, repoRoot, worktrees } = result.value;
+        for (const worktree of worktrees) {
+            allItems.push({
+                repoRoot,
+                repoName,
+                worktree: {
+                    ...worktree,
+                    isCurrent: currentRoot !== null && worktree.path === currentRoot,
+                },
+            });
+        }
+    }
+    return allItems;
+}

package/man/man1/gji-back.1

@@ -1,4 +1,4 @@
-.TH GJI\-BACK 1 "July 2026" "gji 0.9.0" "User Commands"
+.TH GJI\-BACK 1 "July 2026" "gji 0.11.0" "User Commands"
 .SH NAME
 gji\-back \- navigate to the previously visited worktree, optionally N steps back
 .SH SYNOPSIS

package/man/man1/gji-clean.1

@@ -1,4 +1,4 @@
-.TH GJI\-CLEAN 1 "July 2026" "gji 0.9.0" "User Commands"
+.TH GJI\-CLEAN 1 "July 2026" "gji 0.11.0" "User Commands"
 .SH NAME
 gji\-clean \- interactively prune linked worktrees
 .SH SYNOPSIS

package/man/man1/gji-completion.1

@@ -1,4 +1,4 @@
-.TH GJI\-COMPLETION 1 "July 2026" "gji 0.9.0" "User Commands"
+.TH GJI\-COMPLETION 1 "July 2026" "gji 0.11.0" "User Commands"
 .SH NAME
 gji\-completion \- print shell completion definitions
 .SH SYNOPSIS

package/man/man1/gji-config.1

@@ -1,4 +1,4 @@
-.TH GJI\-CONFIG 1 "July 2026" "gji 0.9.0" "User Commands"
+.TH GJI\-CONFIG 1 "July 2026" "gji 0.11.0" "User Commands"
 .SH NAME
 gji\-config \- manage global config defaults
 .SH SYNOPSIS

package/man/man1/gji-doctor.1

@@ -1,4 +1,4 @@
-.TH GJI\-DOCTOR 1 "July 2026" "gji 0.9.0" "User Commands"
+.TH GJI\-DOCTOR 1 "July 2026" "gji 0.11.0" "User Commands"
 .SH NAME
 gji\-doctor \- check gji installation and configuration health
 .SH SYNOPSIS

package/man/man1/gji-done.1

@@ -0,0 +1,19 @@
+.TH GJI\-DONE 1 "July 2026" "gji 0.11.0" "User Commands"
+.SH NAME
+gji\-done \- finish the current linked worktree and return safely
+.SH SYNOPSIS
+.B gji done [\fIoptions\fR] [options] [branch]
+.SH DESCRIPTION
+finish the current linked worktree and return safely
+.SH OPTIONS
+.TP
+.B \-\-force
+remove dirty or unmerged worktrees without prompting
+.TP
+.B \-\-keep\-branch
+remove the worktree but preserve its branch
+.TP
+.B \-\-json
+emit JSON on success or error instead of human\-readable output
+.SH "SEE ALSO"
+.BR gji (1)

package/man/man1/gji-go.1

@@ -1,13 +1,19 @@
-.TH GJI\-GO 1 "July 2026" "gji 0.9.0" "User Commands"
+.TH GJI\-GO 1 "July 2026" "gji 0.11.0" "User Commands"
 .SH NAME
-gji\-go \- print or select a worktree path
+gji\-go \- resolve and jump to a worktree path
 .SH SYNOPSIS
 .B gji go [\fIoptions\fR] [options] [branch]
 .SH DESCRIPTION
-print or select a worktree path
+resolve and jump to a worktree path
 .SH OPTIONS
 .TP
+.B \-\-root
+navigate to the main repository root
+.TP
 .B \-\-print
 print the resolved worktree path explicitly
+.TP
+.B \-\-json
+emit JSON for an existing worktree destination
 .SH "SEE ALSO"
 .BR gji (1)

package/man/man1/gji-history.1

@@ -1,4 +1,4 @@
-.TH GJI\-HISTORY 1 "July 2026" "gji 0.9.0" "User Commands"
+.TH GJI\-HISTORY 1 "July 2026" "gji 0.11.0" "User Commands"
 .SH NAME
 gji\-history \- show navigation history
 .SH SYNOPSIS

package/man/man1/gji-init.1

@@ -1,4 +1,4 @@
-.TH GJI\-INIT 1 "July 2026" "gji 0.9.0" "User Commands"
+.TH GJI\-INIT 1 "July 2026" "gji 0.11.0" "User Commands"
 .SH NAME
 gji\-init \- set up shell integration interactively or print a shell wrapper
 .SH SYNOPSIS

package/man/man1/gji-ls.1

@@ -1,4 +1,4 @@
-.TH GJI\-LS 1 "July 2026" "gji 0.9.0" "User Commands"
+.TH GJI\-LS 1 "July 2026" "gji 0.11.0" "User Commands"
 .SH NAME
 gji\-ls \- list active worktrees
 .SH SYNOPSIS

package/man/man1/gji-new.1

@@ -1,10 +1,16 @@
-.TH GJI\-NEW 1 "July 2026" "gji 0.9.0" "User Commands"
+.TH GJI\-NEW 1 "July 2026" "gji 0.11.0" "User Commands"
 .SH NAME
-gji\-new \- create a new branch or detached linked worktree
+gji\-new \- create a new branch or detached linked worktree and CoW\-bootstrap configured directories
 .SH SYNOPSIS
 .B gji new [\fIoptions\fR] [options] [branch]
 .SH DESCRIPTION
-create a new branch or detached linked worktree
+create a new branch or detached linked worktree and CoW\-bootstrap configured directories
+.SH BOOTSTRAP_POLICY
+dependencyBuildCommand overrides Cargo's default cargo check. Supported lockfiles trigger an interactive dependencyBootstrap choice when no explicit policy exists; the choice is saved according to installSaveTarget. JSON and headless modes never prompt and keep off. npm is always install\-only, and sync\-file failures stop dependency repair, install prompts, and after\-create hooks. JSON bootstrap events include structured reasons, and failed setup reports the created worktree path.
+
+.SH BOOTSTRAP
+syncDirs performs generic copy\-on\-write directory seeding before syncFiles. It never falls back to ordinary copying and never suppresses installation or repair. Set dependencyBootstrap to off, cow\-then\-repair, or install\-only to enable deterministic project\-local package\-manager or build\-cache repair. The lifecycle is CoW seed, syncFiles, repair or install, then after\-create. CoW failures fall back to repair from an empty target; partial clones are removed and existing targets are never deleted. Bundler uses vendor/bundle only; global gem stores and caches are not cloned.
+
 .SH OPTIONS
 .TP
 .B \-f, \-\-force
@@ -13,6 +19,18 @@ remove and recreate the worktree if the target path already exists
 .B \-\-detached
 create a detached worktree without a branch
 .TP
+.B \-\-from\-current
+base the new branch on the current worktree instead of the main worktree (cannot be combined with \-\-detached)
+.TP
+.B \-\-no\-fetch
+skip refreshing the remote default branch before creating the new branch
+.TP
+.B \-\-take
+move current uncommitted changes into the new worktree
+.TP
+.B \-\-copy
+copy current uncommitted changes instead of moving them (requires \-\-take)
+.TP
 .B \-\-open
 open the new worktree in an editor after creation
 .TP

package/man/man1/gji-open.1

@@ -1,4 +1,4 @@
-.TH GJI\-OPEN 1 "July 2026" "gji 0.9.0" "User Commands"
+.TH GJI\-OPEN 1 "July 2026" "gji 0.11.0" "User Commands"
 .SH NAME
 gji\-open \- open the worktree in an editor
 .SH SYNOPSIS
@@ -7,6 +7,9 @@ gji\-open \- open the worktree in an editor
 open the worktree in an editor
 .SH OPTIONS
 .TP
+.B \-\-select
+choose a worktree with the interactive selector
+.TP
 .B \-\-editor <cli>
 editor CLI to use (code, cursor, zed, windsurf, subl, …)
 .TP

package/man/man1/gji-pr.1

@@ -1,10 +1,16 @@
-.TH GJI\-PR 1 "July 2026" "gji 0.9.0" "User Commands"
+.TH GJI\-PR 1 "July 2026" "gji 0.11.0" "User Commands"
 .SH NAME
 gji\-pr \- fetch a pull request by number, #number, or URL into a linked worktree
 .SH SYNOPSIS
 .B gji pr [\fIoptions\fR] [options] <ref>
 .SH DESCRIPTION
 fetch a pull request by number, #number, or URL into a linked worktree
+.SH BOOTSTRAP_POLICY
+dependencyBuildCommand overrides Cargo's default cargo check. Supported lockfiles trigger an interactive dependencyBootstrap choice when no explicit policy exists; the choice is saved according to installSaveTarget. JSON and headless modes never prompt and keep off. npm is always install\-only, and sync\-file failures stop dependency repair, install prompts, and after\-create hooks. JSON bootstrap events include structured reasons, and failed setup reports the created worktree path.
+
+.SH BOOTSTRAP
+syncDirs performs generic copy\-on\-write directory seeding before syncFiles. It never falls back to ordinary copying and never suppresses installation or repair. Set dependencyBootstrap to off, cow\-then\-repair, or install\-only to enable deterministic project\-local package\-manager or build\-cache repair. The lifecycle is CoW seed, syncFiles, repair or install, then after\-create. CoW failures fall back to repair from an empty target; partial clones are removed and existing targets are never deleted. Bundler uses vendor/bundle only; global gem stores and caches are not cloned.
+
 .SH OPTIONS
 .TP
 .B \-\-dry\-run