@solaqua/gji 0.10.0 → 0.12.0

package/dist/safe-destination.js

@@ -0,0 +1,166 @@
+import { constants } from "node:fs";
+import { lstat, mkdir, open } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { isAlreadyExistsError, isNotDirectoryError, isNotFoundError, } from "./fs-utils.js";
+export async function openDestinationDirectory(root, path) {
+    const segments = destinationSegments(root, path);
+    if (process.platform !== "linux") {
+        await ensureDestinationDirectory(root, path);
+        return { path: resolve(path), close: async () => undefined };
+    }
+    let handle = await open(root, destinationDirectoryFlags());
+    try {
+        for (const segment of segments) {
+            const childPath = join(fileDescriptorPath(handle.fd), segment);
+            try {
+                await mkdir(childPath);
+            }
+            catch (error) {
+                if (!isAlreadyExistsError(error))
+                    throw error;
+            }
+            const childHandle = await open(childPath, destinationDirectoryFlags());
+            await handle.close();
+            handle = childHandle;
+        }
+        return {
+            path: fileDescriptorPath(handle.fd),
+            close: async () => handle.close(),
+        };
+    }
+    catch (error) {
+        await handle.close().catch(() => undefined);
+        throw error;
+    }
+}
+export async function inspectDestination(root, path) {
+    const resolvedPath = resolve(path);
+    const resolvedRoot = resolve(root);
+    const distance = relative(resolvedRoot, resolvedPath);
+    if (isAbsolute(distance) ||
+        distance === ".." ||
+        distance.startsWith(`..${sep}`)) {
+        return { kind: "unsafe", reason: "destination escapes the worktree" };
+    }
+    let current = resolvedRoot;
+    try {
+        const rootStats = await lstat(current);
+        if (rootStats.isSymbolicLink() || !rootStats.isDirectory()) {
+            return { kind: "unsafe", reason: "worktree root is not a directory" };
+        }
+    }
+    catch (error) {
+        if (isNotFoundError(error))
+            return { kind: "missing" };
+        throw error;
+    }
+    const segments = distance.split(sep).filter(Boolean);
+    for (const [index, segment] of segments.entries()) {
+        current = resolve(current, segment);
+        try {
+            const stats = await lstat(current);
+            if (stats.isSymbolicLink()) {
+                return {
+                    kind: "unsafe",
+                    reason: `destination has a symbolic-link component: ${current}`,
+                };
+            }
+            if (index < segments.length - 1 && !stats.isDirectory()) {
+                return {
+                    kind: "unsafe",
+                    reason: `destination has a non-directory ancestor: ${current}`,
+                };
+            }
+            if (index === segments.length - 1) {
+                return stats.isDirectory()
+                    ? { kind: "exists" }
+                    : {
+                        kind: "unsafe",
+                        reason: `destination is not a directory: ${current}`,
+                    };
+            }
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return { kind: "missing" };
+            if (isNotDirectoryError(error)) {
+                return {
+                    kind: "unsafe",
+                    reason: `destination has a non-directory ancestor: ${current}`,
+                };
+            }
+            throw error;
+        }
+    }
+    try {
+        const stats = await lstat(current);
+        return stats.isDirectory()
+            ? { kind: "exists" }
+            : { kind: "unsafe", reason: "destination is not a directory" };
+    }
+    catch (error) {
+        if (isNotFoundError(error))
+            return { kind: "missing" };
+        throw error;
+    }
+}
+function destinationSegments(root, path) {
+    const resolvedRoot = resolve(root);
+    const resolvedPath = resolve(path);
+    const distance = relative(resolvedRoot, resolvedPath);
+    if (isAbsolute(distance) ||
+        distance === ".." ||
+        distance.startsWith(`..${sep}`)) {
+        throw new Error("destination escapes the worktree");
+    }
+    return distance.split(sep).filter(Boolean);
+}
+function destinationDirectoryFlags() {
+    return constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW;
+}
+function fileDescriptorPath(fd) {
+    if (process.platform === "linux")
+        return `/proc/self/fd/${fd}`;
+    if (process.platform === "darwin")
+        return `/dev/fd/${fd}`;
+    throw new Error(`safe destination handles are unsupported on ${process.platform}`);
+}
+export async function ensureDestinationDirectory(root, path) {
+    const resolvedRoot = resolve(root);
+    const resolvedPath = resolve(path);
+    const distance = relative(resolvedRoot, resolvedPath);
+    if (isAbsolute(distance) ||
+        distance === ".." ||
+        distance.startsWith(`..${sep}`)) {
+        throw new Error("destination escapes the worktree");
+    }
+    let current = resolvedRoot;
+    const rootStats = await lstat(current);
+    if (rootStats.isSymbolicLink() || !rootStats.isDirectory()) {
+        throw new Error("worktree root is not a directory");
+    }
+    for (const segment of distance.split(sep).filter(Boolean)) {
+        current = resolve(current, segment);
+        try {
+            const stats = await lstat(current);
+            if (stats.isSymbolicLink() || !stats.isDirectory()) {
+                throw new Error(`destination has an unsafe component: ${current}`);
+            }
+        }
+        catch (error) {
+            if (!isNotFoundError(error))
+                throw error;
+            try {
+                await mkdir(current);
+            }
+            catch (mkdirError) {
+                if (!isAlreadyExistsError(mkdirError))
+                    throw mkdirError;
+            }
+            const stats = await lstat(current);
+            if (stats.isSymbolicLink() || !stats.isDirectory()) {
+                throw new Error(`destination has an unsafe component: ${current}`);
+            }
+        }
+    }
+}

package/dist/shell-completion.js

@@ -2,7 +2,15 @@ import { KNOWN_GLOBAL_CONFIG_KEYS } from "./config.js";
 const TOP_LEVEL_COMMANDS = [
     {
         name: "new",
-        description: "create a new branch or detached linked worktree",
+        description: "create a new branch or detached linked worktree and CoW-bootstrap configured directories",
+    },
+    {
+        name: "done",
+        description: "finish the current linked worktree and return safely",
+    },
+    {
+        name: "undo",
+        description: "restore the most recent destructive worktree operation",
     },
     {
         name: "init",
@@ -17,10 +25,11 @@ const TOP_LEVEL_COMMANDS = [
     { name: "back", description: "navigate to the previously visited worktree" },
     { name: "history", description: "show navigation history" },
     { name: "open", description: "open the worktree in an editor" },
-    { name: "go", description: "print or select a worktree path" },
+    { name: "go", description: "resolve and jump to a worktree path" },
     { name: "jump", description: "alias of go" },
     { name: "root", description: "print the main repository root path" },
     { name: "status", description: "summarize repository and worktree health" },
+    { name: "task", description: "show or update the current worktree task" },
     { name: "sync", description: "fetch and update one or all worktrees" },
     {
         name: "sync-files",
@@ -30,14 +39,17 @@ const TOP_LEVEL_COMMANDS = [
     { name: "clean", description: "interactively prune linked worktrees" },
     {
         name: "remove",
-        description: "remove a linked worktree and delete its branch when present",
+        description: "deprecated: use done for one worktree or clean for bulk cleanup",
     },
-    { name: "rm", description: "alias of remove" },
+    { name: "rm", description: "deprecated alias of remove" },
     {
         name: "run-hook",
         description: "run a named hook in the current worktree",
     },
-    { name: "warp", description: "jump to any worktree across all known repos" },
+    {
+        name: "warp",
+        description: "deprecated: use go (press Tab for all known repos)",
+    },
     { name: "config", description: "manage global config defaults" },
 ];
 const SHELL_NAMES = ["bash", "fish", "zsh"];
@@ -129,7 +141,7 @@ _gji_completion() {
   cur="\${COMP_WORDS[COMP_CWORD]:-}"
 
   if [ "$COMP_CWORD" -eq 1 ]; then
-    COMPREPLY=( $(compgen -W "${topLevelCommands}" -- "$cur") )
+		COMPREPLY=( $(compgen -W "${topLevelCommands} --json --help" -- "$cur") )
     return 0
   fi
 
@@ -137,7 +149,13 @@ _gji_completion() {
 
   case "$command_name" in
     new)
-      COMPREPLY=( $(compgen -W "--detached --from-current --force --open --editor --dry-run --json --help" -- "$cur") )
+				COMPREPLY=( $(compgen -W "--detached --from-current --no-fetch --take --copy --task --force --open --editor --dry-run --json --help" -- "$cur") )
+      ;;
+    done)
+      COMPREPLY=( $(compgen -W "--force --keep-branch --json --help" -- "$cur") )
+      ;;
+    undo)
+      COMPREPLY=( $(compgen -W "--list --json --help" -- "$cur") )
       ;;
     init)
       COMPREPLY=( $(compgen -W "${shells} --write --json --help" -- "$cur") )
@@ -182,7 +200,7 @@ _gji_completion() {
       COMPREPLY=( $(compgen -W "$(__gji_worktree_branches) --editor --select --save --workspace --help" -- "$cur") )
       ;;
     go|jump)
-      COMPREPLY=( $(compgen -W "$(__gji_worktree_branches) --print --help" -- "$cur") )
+      COMPREPLY=( $(compgen -W "$(__gji_worktree_branches) --root --print --json --help" -- "$cur") )
       ;;
     root)
       COMPREPLY=( $(compgen -W "--print --help" -- "$cur") )
@@ -212,7 +230,7 @@ _gji_completion() {
       COMPREPLY=( $(compgen -W "${hooks} --help" -- "$cur") )
       ;;
     warp)
-      COMPREPLY=( $(compgen -W "-n --new --print --json --help" -- "$cur") )
+      COMPREPLY=( $(compgen -W "--print --json --help" -- "$cur") )
       ;;
     config)
       if [ "$COMP_CWORD" -eq 2 ]; then
@@ -361,10 +379,18 @@ function __gji_should_complete_config_key
 end
 
 complete -c gji -f
+complete -c gji -n '__fish_seen_subcommand_from done' -l force -d 'remove dirty or unmerged worktrees without prompting'
+complete -c gji -n '__fish_seen_subcommand_from done' -l keep-branch -d 'remove the worktree but preserve its branch'
+complete -c gji -n '__fish_seen_subcommand_from done' -l json -d 'emit JSON on success or error instead of human-readable output'
+complete -c gji -n '__fish_seen_subcommand_from undo' -l list -d 'list recoverable operations'
+complete -c gji -n '__fish_seen_subcommand_from undo' -l json -d 'emit JSON on success or error instead of human-readable output'
 ${commandLines}
 
 complete -c gji -n '__fish_seen_subcommand_from new' -l detached -d 'create a detached worktree without a branch'
 complete -c gji -n '__fish_seen_subcommand_from new' -l from-current -d 'base the new branch on the current worktree instead of the main worktree'
+complete -c gji -n '__fish_seen_subcommand_from new' -l take -d 'move current uncommitted changes into the new worktree'
+complete -c gji -n '__fish_seen_subcommand_from new' -l copy -d 'copy current uncommitted changes instead of moving them (requires --take)'
+complete -c gji -n '__fish_seen_subcommand_from new' -l task -r -d 'record the purpose of the new worktree'
 complete -c gji -n '__fish_seen_subcommand_from new' -l force -d 'remove and recreate the worktree if the target path already exists'
 complete -c gji -n '__fish_seen_subcommand_from new' -l open -d 'open the new worktree in an editor after creation'
 complete -c gji -n '__fish_seen_subcommand_from new' -l editor -r -d 'editor CLI to use with --open (code, cursor, zed, …)'
@@ -400,11 +426,16 @@ complete -c gji -n '__fish_seen_subcommand_from open' -l workspace -d 'generate
 complete -c gji -n '__fish_seen_subcommand_from open' -a '(__gji_worktree_branches)' -d 'worktree branch'
 
 complete -c gji -n '__fish_seen_subcommand_from go jump' -l print -d 'print the resolved worktree path explicitly'
+complete -c gji -n '__fish_seen_subcommand_from go jump' -l root -d 'navigate to the main repository root'
+complete -c gji -n '__fish_seen_subcommand_from go jump' -l json -d 'emit JSON for an existing worktree destination'
+complete -c gji -n '__fish_seen_subcommand_from go jump' -l quiet -d 'suppress the context card'
 complete -c gji -n '__fish_seen_subcommand_from go jump' -a '(__gji_worktree_branches)' -d 'worktree branch'
 
 complete -c gji -n '__fish_seen_subcommand_from root' -l print -d 'print the resolved repository root path explicitly'
 
 complete -c gji -n '__fish_seen_subcommand_from status' -l json -d 'print repository and worktree health as JSON'
+complete -c gji -n '__fish_seen_subcommand_from task' -l clear -d 'clear the current worktree task'
+complete -c gji -n '__fish_seen_subcommand_from task' -l json -d 'emit task metadata as JSON'
 
 complete -c gji -n '__fish_seen_subcommand_from sync' -l all -d 'sync every worktree in the repository'
 complete -c gji -n '__fish_seen_subcommand_from sync' -l json -d 'emit JSON on success or error instead of human-readable output'
@@ -430,7 +461,8 @@ complete -c gji -n '__fish_seen_subcommand_from remove rm' -a '(__gji_worktree_b
 
 ${hookLines}
 
-complete -c gji -n '__fish_seen_subcommand_from warp' -s n -l new -d 'create a new worktree in a registered repo'
+complete -c gji -n '__fish_use_subcommand' -l json -d 'emit the repository hub as JSON'
+
 complete -c gji -n '__fish_seen_subcommand_from warp' -l print -d 'print the resolved worktree path without changing directory'
 complete -c gji -n '__fish_seen_subcommand_from warp' -l json -d 'emit JSON on success or error instead of human-readable output'
 
@@ -509,6 +541,7 @@ local -a command_entries worktree_branches
 
 command_entries=(
   ${commandLines}
+  '--json:emit the repository hub as JSON'
 )
 
 if (( CURRENT == 2 )); then
@@ -518,7 +551,13 @@ fi
 
 case "\${words[2]}" in
   new)
-    _arguments '--detached[create a detached worktree without a branch]' '--from-current[base the new branch on the current worktree instead of the main worktree]' '--force[remove and recreate the worktree if the target path already exists]' '--open[open the new worktree in an editor after creation]' '--editor[editor CLI to use with --open (code, cursor, zed, …)]:editor:' '--dry-run[show what would be created without executing any git commands or writing files]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '
+    _arguments '--detached[create a detached worktree without a branch]' '--from-current[base the new branch on the current worktree instead of the main worktree]' '--no-fetch[skip refreshing the remote default branch before creating the new branch]' '--take[move current uncommitted changes into the new worktree]' '--copy[copy current uncommitted changes instead of moving them (requires --take)]' '--task[record the purpose of the new worktree]:description:' '--force[remove and recreate the worktree if the target path already exists]' '--open[open the new worktree in an editor after creation]' '--editor[editor CLI to use with --open (code, cursor, zed, …)]:editor:' '--dry-run[show what would be created without executing any git commands or writing files]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '
+    ;;
+  done)
+    _arguments '--force[remove dirty or unmerged worktrees without prompting]' '--keep-branch[remove the worktree but preserve its branch]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '
+    ;;
+  undo)
+    _arguments '--list[list recoverable operations]' '--json[emit JSON on success or error instead of human-readable output]' '2:id: '
     ;;
   init)
     _arguments '--write[write the integration to the shell config file]' '--json[emit a JSON error in non-interactive mode]' '2:shell:(${shells})'
@@ -552,7 +591,7 @@ case "\${words[2]}" in
     _arguments '--editor[editor CLI to use (code, cursor, zed, windsurf, subl, …)]:editor:' '--select[choose a worktree with the interactive selector]' '--save[save the chosen editor to global config]' '--workspace[generate a .code-workspace file before opening (VS Code / Cursor / Windsurf)]' '2:branch:->worktrees'
     ;;
   go|jump)
-    _arguments '--print[print the resolved worktree path explicitly]' '2:branch:->worktrees'
+    _arguments '--root[navigate to the main repository root]' '--print[print the resolved worktree path explicitly]' '--json[emit JSON for an existing worktree destination]' '2:branch:->worktrees'
     ;;
   root)
     _arguments '--print[print the resolved repository root path explicitly]'
@@ -579,7 +618,7 @@ case "\${words[2]}" in
     _arguments "2:hook:(${hooks})"
     ;;
   warp)
-    _arguments '(-n --new)'{-n,--new}'[create a new worktree in a registered repo]:branch:' '--print[print the resolved worktree path without changing directory]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '
+    _arguments '--print[print the resolved worktree path without changing directory]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '
     ;;
   config)
     if (( CURRENT == 3 )); then

package/dist/slots.d.ts

@@ -0,0 +1,8 @@
+export interface SlotStore {
+    [worktreePath: string]: number;
+}
+export declare function SLOTS_FILE_PATH(home?: string): string;
+export declare function loadSlots(home?: string): Promise<SlotStore>;
+export declare function assignWorktreeSlot(repoRoot: string, worktreePath: string, home?: string): Promise<number>;
+export declare function getWorktreeSlot(worktreePath: string, home?: string): Promise<number | null>;
+export declare function releaseWorktreeSlot(worktreePath: string, home?: string): Promise<void>;

package/dist/slots.js

@@ -0,0 +1,61 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { GLOBAL_CONFIG_DIRECTORY } from "./config.js";
+export function SLOTS_FILE_PATH(home = homedir()) {
+    const configDir = process.env.GJI_CONFIG_DIR;
+    return configDir
+        ? join(resolve(configDir), "slots.json")
+        : join(home, GLOBAL_CONFIG_DIRECTORY, "slots.json");
+}
+export async function loadSlots(home = homedir()) {
+    try {
+        const parsed = JSON.parse(await readFile(SLOTS_FILE_PATH(home), "utf8"));
+        if (!isSlotStore(parsed))
+            return {};
+        return parsed;
+    }
+    catch {
+        return {};
+    }
+}
+export async function assignWorktreeSlot(repoRoot, worktreePath, home = homedir()) {
+    const slots = await loadSlots(home);
+    const existing = slots[worktreePath];
+    if (existing !== undefined)
+        return existing;
+    if (worktreePath !== repoRoot && slots[repoRoot] === undefined)
+        slots[repoRoot] = 0;
+    const used = new Set(Object.values(slots));
+    const slot = worktreePath === repoRoot ? 0 : nextAvailableSlot(used);
+    slots[worktreePath] = slot;
+    await saveSlots(slots, home);
+    return slot;
+}
+export async function getWorktreeSlot(worktreePath, home = homedir()) {
+    const slot = (await loadSlots(home))[worktreePath];
+    return slot === undefined ? null : slot;
+}
+export async function releaseWorktreeSlot(worktreePath, home = homedir()) {
+    const slots = await loadSlots(home);
+    if (!(worktreePath in slots))
+        return;
+    delete slots[worktreePath];
+    await saveSlots(slots, home);
+}
+async function saveSlots(slots, home) {
+    const path = SLOTS_FILE_PATH(home);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(slots, null, 2)}\n`, "utf8");
+}
+function nextAvailableSlot(used) {
+    let slot = 1;
+    while (used.has(slot))
+        slot += 1;
+    return slot;
+}
+function isSlotStore(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        Object.values(value).every((slot) => Number.isInteger(slot) && slot >= 0));
+}

package/dist/status.d.ts

@@ -7,7 +7,9 @@ interface WorktreeStatusRow {
     branch: string | null;
     current: boolean;
     path: string;
+    slot: number | null;
     status: "clean" | "dirty";
+    task: string | null;
     upstream: UpstreamState;
 }
 type UpstreamState = {

package/dist/status.js

@@ -1,6 +1,8 @@
 import { readWorktreeHealth } from "./git.js";
 import { comparePaths } from "./paths.js";
 import { detectRepository, listWorktrees } from "./repo.js";
+import { getWorktreeSlot } from "./slots.js";
+import { readTask } from "./task.js";
 export async function runStatusCommand(options) {
     const repository = await detectRepository(options.cwd);
     const worktrees = sortWorktreesByPath(await listWorktrees(options.cwd));
@@ -36,12 +38,18 @@ export function formatStatusJson(repoRoot, currentRoot, rows) {
     };
 }
 async function buildStatusRow(worktree) {
-    const health = await readWorktreeHealth(worktree.path);
+    const [health, slot, task] = await Promise.all([
+        readWorktreeHealth(worktree.path),
+        getWorktreeSlot(worktree.path),
+        readTask(worktree.path),
+    ]);
     return {
         branch: worktree.branch,
         current: worktree.isCurrent,
         path: worktree.path,
+        slot,
         status: health.status,
+        task: task?.task ?? null,
         upstream: buildUpstreamState(worktree.branch, health),
     };
 }

package/dist/sync-directories.d.ts

@@ -0,0 +1,33 @@
+import { type CloneFailureStore } from "./clone-failure-store.js";
+import type { CloneDirectory } from "./dir-clone.js";
+import type { SyncDirectoryPlan } from "./sync-plan.js";
+export interface ClonedDirectory {
+    bytes?: number;
+    dir: string;
+    ms: number;
+}
+export type SyncDirectoryOutcome = {
+    kind: "cloned";
+    directory: ClonedDirectory;
+} | {
+    kind: "skipped";
+    dir: string;
+    reason: string;
+};
+export interface SyncDirectoryReporter {
+    readonly emitCachedFailureWarnings: boolean;
+    readonly measureCloneSize: boolean;
+    write(message: string): void;
+    cloned(directory: ClonedDirectory): void;
+    skipped?(directory: {
+        dir: string;
+        reason: string;
+    }): void;
+}
+export interface SyncDirectoryExecutionOptions {
+    cloneDirectory: CloneDirectory;
+    failureStore?: CloneFailureStore;
+    repoRoot: string;
+    reporter: SyncDirectoryReporter;
+}
+export declare function executeSyncDirectoryPlan(plan: readonly SyncDirectoryPlan[], options: SyncDirectoryExecutionOptions): Promise<SyncDirectoryOutcome[]>;

package/dist/sync-directories.js

@@ -0,0 +1,97 @@
+import { cloneFailureScope, defaultCloneFailureStore, } from "./clone-failure-store.js";
+import { isCloneDestinationExistsError, isCloneInProgressError, isCloneUnsupportedError, } from "./dir-clone.js";
+import { inspectDestination } from "./safe-destination.js";
+export async function executeSyncDirectoryPlan(plan, options) {
+    const failureStore = options.failureStore ?? defaultCloneFailureStore;
+    const outcomes = [];
+    for (const entry of plan) {
+        if (entry.destinationWarning) {
+            recordSkipped(outcomes, options.reporter, entry.directory, entry.destinationWarning);
+            continue;
+        }
+        const destinationState = await inspectDestination(entry.worktreePath, entry.destination);
+        if (destinationState.kind === "exists") {
+            recordSkipped(outcomes, options.reporter, entry.directory, "destination already exists");
+            continue;
+        }
+        if (destinationState.kind === "unsafe") {
+            const reason = destinationState.reason;
+            recordSkipped(outcomes, options.reporter, entry.directory, reason);
+            continue;
+        }
+        if (entry.warning) {
+            recordSkipped(outcomes, options.reporter, entry.directory, entry.warning);
+            continue;
+        }
+        if (!entry.source) {
+            recordSkipped(outcomes, options.reporter, entry.directory, "source does not exist");
+            continue;
+        }
+        const failureScope = await cloneFailureScope(entry.source, entry.destination);
+        if (await failureStore.isCached(options.repoRoot, entry.directory, failureScope)) {
+            if (options.reporter.emitCachedFailureWarnings ||
+                options.reporter.skipped) {
+                recordSkipped(outcomes, options.reporter, entry.directory, "copy-on-write failure cached");
+            }
+            else {
+                options.reporter.write(`syncDirs: previous copy-on-write failure cached, skipped ${entry.directory}\n`);
+                recordSkipped(outcomes, options.reporter, entry.directory, "copy-on-write failure cached", false);
+            }
+            continue;
+        }
+        const refreshedDestinationState = await inspectDestination(entry.worktreePath, entry.destination);
+        if (refreshedDestinationState.kind !== "missing") {
+            recordSkipped(outcomes, options.reporter, entry.directory, refreshedDestinationState.kind === "unsafe"
+                ? refreshedDestinationState.reason
+                : "destination already exists");
+            continue;
+        }
+        let result;
+        try {
+            const cloneOptions = {
+                destinationRoot: entry.worktreePath,
+                measureBytes: options.reporter.measureCloneSize,
+            };
+            result = await options.cloneDirectory(entry.source, entry.destination, cloneOptions);
+        }
+        catch (error) {
+            if (isCloneDestinationExistsError(error)) {
+                recordSkipped(outcomes, options.reporter, entry.directory, "destination already exists");
+                continue;
+            }
+            if (isCloneInProgressError(error)) {
+                const reason = "copy-on-write clone already in progress";
+                recordSkipped(outcomes, options.reporter, entry.directory, reason);
+                continue;
+            }
+            const reason = toErrorMessage(error);
+            if (isCloneUnsupportedError(error)) {
+                await failureStore.cache(options.repoRoot, entry.directory, reason, failureScope);
+            }
+            recordSkipped(outcomes, options.reporter, entry.directory, reason);
+            continue;
+        }
+        await failureStore.clear(options.repoRoot, entry.directory, failureScope);
+        const clonedDirectory = {
+            bytes: result.bytes,
+            dir: entry.directory,
+            ms: result.ms,
+        };
+        const outcome = { kind: "cloned", directory: clonedDirectory };
+        outcomes.push(outcome);
+        options.reporter.cloned(clonedDirectory);
+    }
+    return outcomes;
+}
+function recordSkipped(outcomes, reporter, dir, reason, notify = true) {
+    outcomes.push({ kind: "skipped", dir, reason });
+    if (notify) {
+        if (reporter.skipped)
+            reporter.skipped({ dir, reason });
+        else
+            reporter.write(`syncDirs: ${reason}, skipped ${dir}\n`);
+    }
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/sync-plan.d.ts

@@ -0,0 +1,16 @@
+export interface SyncDirectoryPlan {
+    directory: string;
+    destination: string;
+    worktreePath: string;
+    destinationWasPresent: boolean;
+    destinationWarning?: string;
+    source?: string;
+    warning?: string;
+}
+export interface SyncDirectoryEstimate {
+    bytes: number;
+    dir: string;
+}
+export declare function prepareSyncDirectoryPlan(repoRoot: string, worktreePath: string, directories: readonly string[]): Promise<SyncDirectoryPlan[]>;
+export declare function estimateSyncDirectoryPlan(plan: readonly SyncDirectoryPlan[]): Promise<SyncDirectoryEstimate[]>;
+export declare function estimateSyncDirectories(repoRoot: string, worktreePath: string, directories: readonly string[]): Promise<SyncDirectoryEstimate[]>;