@papillon6814/copi 0.3.0 → 0.4.1

package/README.md

@@ -26,7 +26,7 @@ copi migrate --resolve [--dry-run]
 copi help
 ```
 
-`setup` requires an interactive terminal. It first asks where copi may look: your whole `HOME` (the default; this can take a minute or more), this project only, or both. Selecting the entire `HOME` is broad: it can inspect supported resources throughout that directory, including Pi profiles and the configured Pi agent directory. Selecting the current project scopes discovery to that project. Copi then asks for explicit authorization before searching; declining performs no search. Search warnings are summarized (for example, resources found outside the selected roots are counted rather than listed one by one), and missing files are skipped silently.
+`setup` requires an interactive terminal. It first asks where copi may look: the Pi agent directories (`~/.pi/agent`, `~/.pi/agent-*`, `~/.pi/agent_*` and `~/.agents`; the default), this project only, or both. Settings and packages declared by those Pi profiles are expanded too, so configured paths elsewhere under `HOME` may be read; setup never walks your whole `HOME`. Symbolic links are not followed, and worktree checkout copies (`.worktrees`, `.claude/worktrees`, `.config/superpowers/worktrees`, `.treehouse`) are skipped. Selecting the current project scopes discovery to that project; when the current directory is `HOME` itself, only the Pi agent directories are offered. Candidates with the same kind, name and content are merged into one row marked `(+N identical copies)`; the kept row prefers a source under `~/.pi` or `~/.agents`. Copi then asks for explicit authorization before searching; declining performs no search. Search warnings are summarized (for example, resources found outside the selected roots are counted rather than listed one by one), and missing files are skipped silently.
 
 Candidates are listed with a source label, size and modification date, and entries whose name matches an already saved resource are marked `already saved`. After you select resources, name conflicts are resolved right away, before any preview: keep one of the same-named selections, rename the display name only (the files, body and destination are not changed), skip the resource (keeping the saved copy), or go back to the list.
 

package/dist/src/discovery.d.ts

@@ -2,6 +2,8 @@ import type { DiscoveryResult } from "./types.ts";
 export interface DiscoveryScopes {
     home: boolean;
     project: boolean;
+    /** Only the Pi agent directories under HOME (`~/.pi/agent`, `~/.pi/agent-*`, `~/.pi/agent_*`, `~/.agents`); ignored when `home` is set. */
+    piDirs?: boolean;
 }
 export interface DiscoveryOptions {
     homeDir: string;
@@ -9,4 +11,21 @@ export interface DiscoveryOptions {
     projectDir: string;
     scopes?: DiscoveryScopes;
 }
-export declare function discoverResources(options: DiscoveryOptions): Promise<DiscoveryResult>;
+export declare function shouldExclude(relativePath: string): boolean;
+/** Git worktrees and similar checkout copies duplicate their main repository, so whole-HOME searches skip them. */
+export declare function isWorktreeCopy(relativePath: string): boolean;
+/**
+ * The Pi agent directories searched by the `piDirs` scope, sorted. Symlinks are never followed: a symlinked
+ * `~/.pi`, profile directory or `~/.agents` is reported in `symlinks` instead (callers warn about it).
+ */
+export declare function piAgentDirectories(homeDir: string): Promise<{
+    directories: string[];
+    symlinks: string[];
+}>;
+/** HOME search progress: `total` top-level directories, `done` finished so far, `current` the one being searched. */
+export interface DiscoveryProgress {
+    done: number;
+    total: number;
+    current?: string;
+}
+export declare function discoverResources(options: DiscoveryOptions, onProgress?: (progress: DiscoveryProgress) => void): Promise<DiscoveryResult>;

package/dist/src/discovery.js

@@ -17,12 +17,50 @@ function isWithin(root, target) {
     const relative = path.relative(root, target);
     return relative === "" || (!path.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path.sep}`));
 }
-function shouldExclude(relativePath) {
+export function shouldExclude(relativePath) {
     return relativePath.split(path.sep).some((part) => {
         const lower = part.toLowerCase();
         return excludedNames.has(lower) || lower === "auth.json" || lower === "mcp-auth.json" || lower === "oauth.json" || lower.startsWith(".env");
     });
 }
+/** Git worktrees and similar checkout copies duplicate their main repository, so whole-HOME searches skip them. */
+export function isWorktreeCopy(relativePath) {
+    const parts = relativePath.split(path.sep);
+    return parts.some((part, index) => part === ".worktrees" || part === ".treehouse"
+        || (part === "worktrees" && (parts[index - 1] === ".claude" || (parts[index - 1] === "superpowers" && parts[index - 2] === ".config"))));
+}
+const piProfilePattern = /^agent([-_].+)?$/;
+/**
+ * The Pi agent directories searched by the `piDirs` scope, sorted. Symlinks are never followed: a symlinked
+ * `~/.pi`, profile directory or `~/.agents` is reported in `symlinks` instead (callers warn about it).
+ */
+export async function piAgentDirectories(homeDir) {
+    const directories = [];
+    const symlinks = [];
+    const kind = (p) => lstat(p).then((stat) => stat.isSymbolicLink() ? "link" : stat.isDirectory() ? "dir" : "other").catch(() => "missing");
+    const piDir = path.join(homeDir, ".pi");
+    const piKind = await kind(piDir);
+    if (piKind === "link")
+        symlinks.push(piDir);
+    if (piKind === "dir") {
+        for (const entry of await readdir(piDir, { withFileTypes: true }).catch(() => [])) {
+            if (!piProfilePattern.test(entry.name))
+                continue;
+            if (entry.isSymbolicLink())
+                symlinks.push(path.join(piDir, entry.name));
+            else if (entry.isDirectory())
+                directories.push(path.join(piDir, entry.name));
+        }
+    }
+    const shared = path.join(homeDir, ".agents");
+    const sharedKind = await kind(shared);
+    if (sharedKind === "link")
+        symlinks.push(shared);
+    if (sharedKind === "dir")
+        directories.push(shared);
+    const byPath = (left, right) => left.localeCompare(right);
+    return { directories: directories.sort(byPath), symlinks: symlinks.sort(byPath) };
+}
 function displayRelative(root, target) {
     return path.relative(root, target) || path.basename(target);
 }
@@ -121,19 +159,20 @@ async function canonicalDirectory(directory) {
 async function exists(target) {
     return lstat(target).then(() => true, (error) => error.code !== "ENOENT");
 }
-export async function discoverResources(options) {
+export async function discoverResources(options, onProgress) {
     const scopes = options.scopes ?? inferSearchScopes(options);
-    if (!scopes.home && !scopes.project)
+    const piOnly = Boolean(scopes.piDirs) && !scopes.home;
+    if (!scopes.home && !scopes.project && !piOnly)
         return { candidates: [], warnings: [], excludedPaths: [] };
     const warnings = [];
     const excludedPaths = new Set();
     const candidates = [];
     const candidateKeys = new Set();
-    const home = scopes.home ? await canonicalDirectory(options.homeDir) : undefined;
-    const agent = scopes.home ? await canonicalDirectory(options.agentDir) : undefined;
+    const home = scopes.home || piOnly ? await canonicalDirectory(options.homeDir) : undefined;
+    const agent = scopes.home || piOnly ? await canonicalDirectory(options.agentDir) : undefined;
     const project = scopes.project ? await canonicalDirectory(options.projectDir) : undefined;
     const packageAgentDir = agent;
-    if (scopes.home && !home)
+    if ((scopes.home || piOnly) && !home)
         addWarning(warnings, "unavailable-root", options.homeDir, "The explicitly selected home directory is unavailable.");
     if (scopes.home && !agent)
         addWarning(warnings, "unavailable-root", options.agentDir, "The explicitly selected Pi agent directory is unavailable.");
@@ -178,11 +217,11 @@ export async function discoverResources(options) {
             destination,
         });
     };
-    const walk = async (root, startPath, onFile) => {
+    const walk = async (root, startPath, onFile, progress) => {
         const canonicalRoot = await canonicalDirectory(root);
         if (!canonicalRoot)
             return;
-        const visit = async (directory) => {
+        const visit = async (directory, topLevel = false) => {
             let entries;
             try {
                 entries = await readdir(directory, { withFileTypes: true });
@@ -192,9 +231,19 @@ export async function discoverResources(options) {
                 addWarning(warnings, code === "EACCES" ? "permission-denied" : "scan-error", directory, code === "EACCES" ? "Permission denied while searching this directory." : "Unable to search this directory.");
                 return;
             }
+            const tracked = topLevel && progress
+                ? entries.filter((entry) => entry.isDirectory() && !entry.isSymbolicLink() && !shouldExclude(path.relative(canonicalRoot, path.join(directory, entry.name))))
+                : [];
+            let done = 0;
+            if (topLevel && progress)
+                progress({ done, total: tracked.length });
             for (const entry of entries) {
                 const child = path.join(directory, entry.name);
                 const relative = path.relative(canonicalRoot, child);
+                if (entry.isDirectory() && isWorktreeCopy(relative)) {
+                    excludedPaths.add(child);
+                    continue;
+                }
                 if (shouldExclude(relative)) {
                     excludedPaths.add(child);
                     if (relative.split(path.sep).some((part) => part.toLowerCase() === "auth")) {
@@ -207,8 +256,14 @@ export async function discoverResources(options) {
                     addWarning(warnings, target && isWithin(canonicalRoot, target) ? "symlink-skipped" : "external-symlink", child, "Symbolic links are not followed during resource discovery.");
                     continue;
                 }
-                if (entry.isDirectory())
+                if (entry.isDirectory()) {
+                    const isTracked = tracked.includes(entry);
+                    if (isTracked)
+                        progress({ done, total: tracked.length, current: child });
                     await visit(child);
+                    if (isTracked)
+                        progress({ done: ++done, total: tracked.length });
+                }
                 else if (entry.isFile())
                     await onFile(child);
             }
@@ -234,7 +289,7 @@ export async function discoverResources(options) {
         if (stat.isFile())
             await onFile(canonicalStart);
         else if (stat.isDirectory())
-            await visit(canonicalStart);
+            await visit(canonicalStart, true);
     };
     const addSkillRoot = async (root, startPath, scope, source, destinationRoot) => {
         await walk(root, startPath, async (file) => {
@@ -490,7 +545,7 @@ export async function discoverResources(options) {
     const homeProjects = new Set();
     const homeProfiles = new Set();
     if (home) {
-        await walk(home, home, async (file) => {
+        const classifyHomeFile = async (file) => {
             const relativeParts = path.relative(home, file).split(path.sep);
             const base = path.basename(file);
             const piIndex = relativeParts.indexOf(".pi");
@@ -569,7 +624,21 @@ export async function discoverResources(options) {
                     homeProjects.add(projectRoot);
                 await addCandidate("instruction", home, file, base, "project", "project-instructions", { kind: "project", path: base });
             }
-        });
+        };
+        if (scopes.home) {
+            await walk(home, home, classifyHomeFile, onProgress);
+        }
+        else {
+            const { directories: starts, symlinks } = await piAgentDirectories(home);
+            for (const link of symlinks)
+                addWarning(warnings, "symlink-skipped", link, "Symbolic links are not followed during resource discovery.");
+            onProgress?.({ done: 0, total: starts.length });
+            for (const [index, start] of starts.entries()) {
+                onProgress?.({ done: index, total: starts.length, current: start });
+                await walk(home, start, classifyHomeFile);
+                onProgress?.({ done: index + 1, total: starts.length });
+            }
+        }
         for (const profileRoot of homeProfiles) {
             await scanSettings(path.join(profileRoot, "settings.json"), "user", [profileRoot, home], profileRoot);
         }

package/dist/src/setup-display.d.ts

@@ -41,3 +41,27 @@ export declare function findSelectionConflicts(list: readonly ResourceCandidate[
 export declare function defaultRenameName(c: ResourceCandidate, group?: readonly ResourceCandidate[]): string;
 /** Validation message for a new display name, or undefined when it is non-empty and its `nameKey` is not taken. */
 export declare function pendingNameError(name: string | undefined, taken: ReadonlySet<string>): string | undefined;
+/** Bar message for the HOME search: `14/36  ~/Library`, or just the count between directories. */
+export declare function formatSearchProgress(progress: {
+    done: number;
+    total: number;
+    current?: string;
+}, home: string): string;
+/**
+ * SHA-256 over what saving would copy: for a file its mode and bytes, for a directory every regular file's
+ * relative path, mode and bytes (sorted, same exclusions as discovery), each field length-prefixed.
+ * `undefined` (never merged) when unreadable, too large, or containing a symlink, which saving refuses.
+ */
+export declare function contentFingerprint(c: ResourceCandidate): Promise<string | undefined>;
+/**
+ * Collapse candidates with the same kind, display name (nameKey) and content fingerprint into one row.
+ * The kept row prefers a source under `~/.pi` or `~/.agents`, then the shortest path; input order is preserved.
+ * `copies` maps a kept candidate id to how many identical candidates it stands for (besides itself).
+ */
+export declare function collapseIdenticalCandidates(list: readonly ResourceCandidate[], fingerprints: ReadonlyMap<string, string | undefined>, home: string): {
+    kept: ResourceCandidate[];
+    copies: Map<string, number>;
+};
+export declare function identicalCopiesSuffix(count: number | undefined): string;
+/** Map with at most `limit` operations in flight, preserving input order. */
+export declare function mapWithLimit<T, R>(items: readonly T[], limit: number, operation: (item: T) => Promise<R>): Promise<R[]>;

package/dist/src/setup-display.js

@@ -1,5 +1,7 @@
-import { lstat, readdir } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { lstat, readFile, readdir } from "node:fs/promises";
 import path from "node:path";
+import { shouldExclude } from "./discovery.js";
 import { nameKey } from "./names.js";
 /** Replace a leading home directory with `~` (only on a path-segment boundary). */
 export function displayPath(p, home) {
@@ -193,3 +195,112 @@ export function pendingNameError(name, taken) {
     }
     return taken.has(key) ? "That name is already used by a saved or selected resource; choose another." : undefined;
 }
+/** Bar message for the HOME search: `14/36  ~/Library`, or just the count between directories. */
+export function formatSearchProgress(progress, home) {
+    const count = `${progress.done}/${progress.total}`;
+    return progress.current === undefined ? `${count}  Searching` : `${count}  ${displayPath(progress.current, home)}`;
+}
+const fingerprintMaxFiles = 2000;
+const fingerprintMaxBytes = 50 * 1024 * 1024;
+/**
+ * SHA-256 over what saving would copy: for a file its mode and bytes, for a directory every regular file's
+ * relative path, mode and bytes (sorted, same exclusions as discovery), each field length-prefixed.
+ * `undefined` (never merged) when unreadable, too large, or containing a symlink, which saving refuses.
+ */
+export async function contentFingerprint(c) {
+    try {
+        const field = (hash, value) => {
+            const bytes = typeof value === "string" ? Buffer.from(value) : value;
+            hash.update(`${bytes.length}:`).update(bytes);
+        };
+        const stat = await lstat(c.sourcePath);
+        if (stat.isFile()) {
+            if (stat.size > fingerprintMaxBytes)
+                return undefined;
+            const hash = createHash("sha256");
+            field(hash, (stat.mode & 0o777).toString(8));
+            field(hash, await readFile(c.sourcePath));
+            return hash.digest("hex");
+        }
+        if (!stat.isDirectory())
+            return undefined;
+        const files = [];
+        let bytes = 0;
+        const visit = async (dir) => {
+            for (const entry of await readdir(dir, { withFileTypes: true })) {
+                const child = path.join(dir, entry.name);
+                const relative = path.relative(c.sourcePath, child);
+                if (shouldExclude(relative))
+                    continue;
+                if (entry.isSymbolicLink())
+                    return false;
+                if (entry.isDirectory()) {
+                    if (!(await visit(child)))
+                        return false;
+                }
+                else if (entry.isFile()) {
+                    files.push(relative);
+                    bytes += (await lstat(child)).size;
+                    if (files.length > fingerprintMaxFiles || bytes > fingerprintMaxBytes)
+                        return false;
+                }
+            }
+            return true;
+        };
+        if (!(await visit(c.sourcePath)))
+            return undefined;
+        const hash = createHash("sha256");
+        for (const relative of files.sort()) {
+            const file = path.join(c.sourcePath, relative);
+            field(hash, relative);
+            field(hash, ((await lstat(file)).mode & 0o777).toString(8));
+            field(hash, await readFile(file));
+        }
+        return hash.digest("hex");
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Collapse candidates with the same kind, display name (nameKey) and content fingerprint into one row.
+ * The kept row prefers a source under `~/.pi` or `~/.agents`, then the shortest path; input order is preserved.
+ * `copies` maps a kept candidate id to how many identical candidates it stands for (besides itself).
+ */
+export function collapseIdenticalCandidates(list, fingerprints, home) {
+    const preferred = (c) => [".pi", ".agents"].some((dir) => c.sourcePath.startsWith(path.join(home, dir) + path.sep)) ? 0 : 1;
+    const better = (a, b) => preferred(a) - preferred(b) || a.sourcePath.length - b.sourcePath.length || a.sourcePath.localeCompare(b.sourcePath);
+    const groups = new Map();
+    for (const c of list) {
+        const fingerprint = fingerprints.get(c.id);
+        const key = fingerprint === undefined ? `unique\0${c.id}` : JSON.stringify([c.kind, c.name, c.scope, c.destination, fingerprint]);
+        groups.set(key, [...(groups.get(key) ?? []), c]);
+    }
+    const representative = new Map();
+    const copies = new Map();
+    for (const group of groups.values()) {
+        const best = [...group].sort(better)[0];
+        for (const c of group)
+            representative.set(c.id, best);
+        if (group.length > 1)
+            copies.set(best.id, group.length - 1);
+    }
+    const kept = list.filter((c) => representative.get(c.id).id === c.id);
+    return { kept, copies };
+}
+export function identicalCopiesSuffix(count) {
+    return count ? ` (+${count} identical ${count === 1 ? "copy" : "copies"})` : "";
+}
+/** Map with at most `limit` operations in flight, preserving input order. */
+export async function mapWithLimit(items, limit, operation) {
+    const results = new Array(items.length);
+    let next = 0;
+    const worker = async () => {
+        while (next < items.length) {
+            const index = next++;
+            results[index] = await operation(items[index]);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+    return results;
+}

package/dist/src/wizard.d.ts

@@ -17,6 +17,7 @@ export interface SearchRoots {
 export interface SearchScopes {
     home: boolean;
     project: boolean;
+    piDirs?: boolean;
 }
 export declare function buildSearchOptions(roots: SearchRoots, scopes: SearchScopes): DiscoveryOptions | undefined;
 export declare function formatMaskedPreview(relativePath: string, content: string): string;

package/dist/src/wizard.js

@@ -1,10 +1,10 @@
-import { autocompleteMultiselect as clackMultiselect, cancel as clackCancel, confirm as clackConfirm, intro as clackIntro, isCancel, log, note as clackNote, outro as clackOutro, select as clackSelect, spinner as clackSpinner, text as clackText } from "@clack/prompts";
+import { autocompleteMultiselect as clackMultiselect, cancel as clackCancel, confirm as clackConfirm, intro as clackIntro, isCancel, log, note as clackNote, outro as clackOutro, progress as clackProgress, select as clackSelect, spinner as clackSpinner, text as clackText } from "@clack/prompts";
 import { lstat } from "node:fs/promises";
 import path from "node:path";
 import { assertModernCatalog, importPreparedResource, loadCatalog, prepareResource, readPreparedResource, readSnapshotFiles, saveCatalog, saveNameChanges } from "./catalog.js";
-import { discoverResources } from "./discovery.js";
+import { discoverResources, isWorktreeCopy, piAgentDirectories } from "./discovery.js";
 import { createGroup, renameGroup, setGroupItems } from "./groups.js";
-import { candidateHint, candidateLabels, defaultRenameName, displayPath, findSelectionConflicts, formatOutsideRootSummary, gatherCandidateStats, pendingNameError, sortCandidates } from "./setup-display.js";
+import { candidateHint, candidateLabels, collapseIdenticalCandidates, contentFingerprint, defaultRenameName, displayPath, findSelectionConflicts, formatSearchProgress, formatOutsideRootSummary, gatherCandidateStats, identicalCopiesSuffix, mapWithLimit, pendingNameError, sortCandidates } from "./setup-display.js";
 import { inspectPreparedResource, maskSensitiveText } from "./inspect.js";
 import { assertNameAvailable, assertNoNameConflicts, findNameConflicts, nameKey } from "./names.js";
 import { executeApply, planApply } from "./apply.js";
@@ -90,11 +90,11 @@ const previewMaxBytes = 1_000_000;
 const previewMaxFiles = 12;
 const previewMaxLines = 24;
 export function buildSearchOptions(roots, scopes) {
-    if (!scopes.home && !scopes.project)
+    if (!scopes.home && !scopes.project && !scopes.piDirs)
         return undefined;
     return {
         ...roots,
-        scopes: { home: scopes.home, project: scopes.project },
+        scopes: { home: scopes.home, project: scopes.project, ...(scopes.piDirs ? { piDirs: true } : {}) },
     };
 }
 export function formatMaskedPreview(relativePath, content) {
@@ -404,18 +404,26 @@ export async function runSetup(libraryDir, roots) {
     assertModernCatalog(initial);
     assertNoNameConflicts(initial);
     intro("copi setup");
+    note([
+        "Copi keeps private copies of your Pi resources",
+        `(skills, subagents, instructions, settings) in ${displayPath(libraryDir, roots.homeDir)}`,
+        "and applies them to projects by group.",
+        "setup: find \u2192 review masked previews \u2192 save to groups.",
+        "Later: copi apply <group> <project>.",
+        "Your original files are never changed.",
+    ].join("\n"), "What copi does");
     const homeDir = roots.homeDir;
     const projectLabel = displayPath(roots.projectDir, homeDir);
     const homeBase = homeDir.length > 1 && homeDir.endsWith(path.sep) ? homeDir.slice(0, -1) : homeDir;
     const projectIsHome = Boolean(homeDir) && roots.projectDir === homeBase;
-    const projectInsideHome = Boolean(homeDir) && !projectIsHome && roots.projectDir.startsWith(homeBase + path.sep);
     const locationOptions = [];
+    // Searching a project that is HOME itself would mean searching all of HOME, which setup no longer offers.
     if (homeDir)
-        locationOptions.push({ value: "home", label: "HOME and Pi agent directory \u2014 ~ (can take a minute or more)" });
+        locationOptions.push({ value: "pi", label: "Pi agent directories only \u2014 ~/.pi/agent, ~/.pi/agent-*, ~/.agents (fast)" });
     if (!projectIsHome)
         locationOptions.push({ value: "project", label: `This project only \u2014 ${projectLabel} (fast)` });
-    if (homeDir && !projectIsHome && !projectInsideHome)
-        locationOptions.push({ value: "both", label: "Both" });
+    if (homeDir && !projectIsHome)
+        locationOptions.push({ value: "both", label: "Both \u2014 Pi agent directories and this project" });
     locationOptions.push({ value: "cancel", label: "Cancel" });
     const choice = await select({
         message: "Choose the locations copi may inspect",
@@ -426,13 +434,15 @@ export async function runSetup(libraryDir, roots) {
         cancel("Setup cancelled.");
         return;
     }
-    const scopes = { home: choice === "home" || choice === "both", project: choice === "project" || choice === "both" };
+    const searchesPiDirs = choice === "pi" || choice === "both";
+    const scopes = { home: false, project: choice === "project" || choice === "both", ...(searchesPiDirs ? { piDirs: true } : {}) };
+    const piDirectories = searchesPiDirs ? (await piAgentDirectories(homeDir)).directories : [];
     const searchOptions = buildSearchOptions(roots, scopes); // every non-cancel choice enables at least one scope
     note([
-        `HOME: ${scopes.home ? displayPath(roots.homeDir, homeDir) : "not selected"}`,
-        `Pi agent directory: ${scopes.home ? displayPath(roots.agentDir, homeDir) : "not selected"}`,
+        `Pi agent directories: ${searchesPiDirs ? (piDirectories.map((dir) => displayPath(dir, homeDir)).join(", ") || "none found") : "not selected"}`,
         `Project: ${scopes.project ? projectLabel : "not selected"}`,
-        "Always excluded: entire directories named auth (authentication-specific code may be missing), auth.json, mcp-auth.json, oauth.json, .env* paths, history, cache/caches, .cache, .npm, node_modules, and .git.",
+        "Always excluded: entire directories named auth (authentication-specific code may be missing), auth.json, mcp-auth.json, oauth.json, .env* paths, history, cache/caches, .cache, .npm, node_modules, and .git. Folder searches also skip worktree copies (.worktrees, .claude/worktrees, .config/superpowers/worktrees, .treehouse).",
+        ...(searchesPiDirs ? ["Settings and packages declared by these Pi profiles may point elsewhere under HOME; those configured paths are read too."] : []),
         "Secret detection is heuristic and cannot guarantee completeness. Preview text is masked by default.",
     ].join("\n"), "Search scope and exclusions");
     const authorized = await confirm({
@@ -443,25 +453,51 @@ export async function runSetup(libraryDir, roots) {
         outro("Search not authorized; no resources were inspected or saved.");
         return;
     }
-    const progress = clackSpinner(inheritedSignal());
-    progress.start("Searching selected locations (searching all of HOME can take a minute or more)");
+    // A spinner covers the quick phases; once HOME's top-level directories are known, a bar fills one step per directory.
+    let indicator = clackSpinner(inheritedSignal());
+    indicator.start("Searching selected locations");
+    let bar;
+    let barDone = 0;
+    const onProgress = (event) => {
+        if (!bar) {
+            if (event.total === 0)
+                return;
+            indicator.clear();
+            bar = clackProgress({ ...inheritedSignal(), max: event.total });
+            indicator = bar;
+            bar.start(safeDisplay(formatSearchProgress(event, homeDir)));
+            return;
+        }
+        const step = event.done - barDone;
+        barDone = event.done;
+        bar.advance(step, safeDisplay(formatSearchProgress(event, homeDir)));
+    };
     let discovery;
     try {
-        discovery = await discoverResources(searchOptions);
+        discovery = await discoverResources(searchOptions, onProgress);
     }
     catch (error) {
-        progress.error("Search failed");
+        indicator.error("Search failed");
         throw error;
     }
-    progress.stop(`Search complete: ${discovery.candidates.length} supported resource(s) found`);
+    indicator.stop(`Search complete: ${discovery.candidates.length} supported resource(s) found`);
     showSearchWarnings(discovery.warnings, roots.homeDir);
-    if (discovery.excludedPaths.length > 0)
-        note(discovery.excludedPaths.map((excluded) => displayPath(excluded, homeDir)).join("\n"), "Excluded paths");
+    const worktreeCopies = discovery.excludedPaths.filter((excluded) => isWorktreeCopy(path.relative(homeDir || path.sep, excluded)));
+    const otherExcluded = discovery.excludedPaths.filter((excluded) => !worktreeCopies.includes(excluded));
+    if (worktreeCopies.length > 0)
+        log.info(safeDisplay(`Skipped ${worktreeCopies.length} worktree copy folder(s).`));
+    if (otherExcluded.length > 0)
+        note(otherExcluded.map((excluded) => displayPath(excluded, homeDir)).join("\n"), "Excluded paths");
     if (discovery.candidates.length === 0) {
         outro("No supported resources were found.");
         return;
     }
-    const sortedCandidates = sortCandidates(discovery.candidates);
+    const allSorted = sortCandidates(discovery.candidates);
+    const fingerprints = new Map(await mapWithLimit(allSorted, 16, async (candidate) => [candidate.id, await contentFingerprint(candidate)]));
+    const { kept: sortedCandidates, copies: identicalCopies } = collapseIdenticalCandidates(allSorted, fingerprints, homeDir);
+    const merged = allSorted.length - sortedCandidates.length;
+    if (merged > 0)
+        log.info(safeDisplay(`Merged ${merged} identical copies; ${sortedCandidates.length} distinct resource(s) to choose from.`));
     const candidateStats = await gatherCandidateStats(sortedCandidates);
     const savedNames = new Set(initial.items.map((item) => nameKey(item.name)));
     const candidateLabelMap = candidateLabels(sortedCandidates, homeDir, (candidate) => savedNames.has(nameKey(candidate.name)), process.stdout.columns);
@@ -471,7 +507,7 @@ export async function runSetup(libraryDir, roots) {
         const selectedIds = await autocompleteMultiselect({
             message: "Select resources to review and save as copied snapshots",
             options: sortedCandidates.map((candidate) => {
-                const label = candidateLabelMap.get(candidate.id);
+                const label = candidateLabelMap.get(candidate.id) + identicalCopiesSuffix(identicalCopies.get(candidate.id));
                 return { value: candidate.id, label, hint: candidateHint(candidate, candidateStats.get(candidate.id) ?? {}, homeDir, process.stdout.columns, label.length) };
             }),
             required: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@papillon6814/copi",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Collect and organize reusable Pi coding-agent resources",
   "license": "MIT",
   "type": "module",