@papillon6814/copi 0.7.0 → 0.8.0

package/README.md

@@ -31,7 +31,7 @@ copi help
 
 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.
 
-A group is a named set of saved resources that you later apply together with `copi apply <group> <project>`. If no group exists yet, setup asks you to create the first one. With several resources, setup asks once how to group them: by default all of them go into the same group(s); you can instead choose groups for each resource. Each resource is then reviewed in turn with a masked preview titled with its progress (for example `1/3`) and its source directory. A suspected sensitive file needs its own approval; answering No means that resource is not saved at all. Finally, one confirmation lists everything that will be copied into the library; the original files are never changed. When it is done, setup prints the next step, for example `copi apply <group> <project> --dry-run`.
+A group is a named set of saved resources that you later apply together with `copi apply <group> <project>`. If no group exists yet, setup asks you to create the first one. With several resources, setup asks once how to group them: by default all of them go into the same group(s); you can instead choose groups for each resource. The group list itself ends with **＋ New group…** and **✎ Rename or delete groups…**: create, rename or delete groups right there and return to the list with your selection kept. Deleting a group never deletes resources; saved resources only leave that group, and a group that holds saved resources or resources already assigned in this run asks first (default No). Like everything else in setup, group changes are written only when you answer Yes at the final confirmation. Each resource is then reviewed in turn with a masked preview titled with its progress (for example `1/3`) and its source directory. A suspected sensitive file needs its own approval; answering No means that resource is not saved at all. Finally, one confirmation lists everything that will be copied into the library; the original files are never changed. When it is done, setup prints the next step, for example `copi apply <group> <project> --dry-run`.
 
 `add` is the non-interactive way to register resources, meant for scripts and AI agents (for example, tell your agent to run `copi add .pi/skills/my-skill --group game --json`). It reads only the paths you name and saves each one into the named group, creating the group if needed. The kind is detected (a directory with `SKILL.md` is a skill, `agents/*.md` a subagent, `AGENTS.md`/`CLAUDE.md`/`SYSTEM.md` an instruction) or set with `--kind`. A path is refused, and left for a person to review with `copi setup`, when its inspection finds suspected sensitive content, when it is or (for a skill directory) contains a settings or credential file (`settings.json`, `mcp.json`, `.mcp.json`, `models.json`, `keybindings.json`, SSH keys, `*.pem`, `.netrc` and similar; names compared case-insensitively), when the path or any parent directory is a symbolic link, when it lies under an excluded folder (`auth`, `.env*`, caches, history, sessions, `.git`, `node_modules`) or inside the copi library, when an `instruction`/`subagent` is not a Markdown file, or when its display name is already used (`--name` sets another). Each path gets its own result; if saving fails midway, the remaining paths are reported as errors and a group created by that command is removed again when it stayed empty. JSON output is not passed through display masking, so treat it as data. `--dry-run` reports without saving and `--json` prints machine-readable results; the exit status is 1 if any path was refused. Because secret detection is heuristic, a secret it misses is saved like any other content, without the per-file approval `setup` asks for.
 
@@ -39,7 +39,7 @@ A group is a named set of saved resources that you later apply together with `co
 
 Resource display names and group names are each unique across the library, in separate namespaces. Comparison uses `trim → NFKC → Unicode 17.0.0 default full case folding → NFKC` (not locale-specific); display names and body text are not automatically normalized or rewritten. For example, `Ａ` and `a`, or `Straße` and `STRASSE`, conflict within one namespace. Legacy duplicate catalogs remain readable: use **Resolve name conflicts** to rename them manually. Until resolved, only listing, masked viewing and conflict resolution are allowed; no automatic renaming occurs.
 
-`groups` lists groups in a non-interactive terminal; group changes require a TTY and are saved only after confirmation. `list` is read-only. `apply --dry-run` prints the planned paths, masked text diffs, and warnings without changing the target. A real apply requires a TTY and confirmation.
+`groups` lists groups in a non-interactive terminal; group changes (create, rename, edit membership, delete) require a TTY and are saved only after confirmation. Deleting a group keeps its resources in the library. `list` is read-only. `apply --dry-run` prints the planned paths, masked text diffs, and warnings without changing the target. A real apply requires a TTY and confirmation.
 
 Pi automatically loads only context files (`AGENTS.override.md`, `AGENTS.md`, `AGENTS.MD`, `CLAUDE.md`, `CLAUDE.MD`) and `.pi/SYSTEM.md` / `.pi/APPEND_SYSTEM.md`. When a group applies another instruction (for example `RULES.md`) and no context file at the project root mentions its path, `apply` warns. It offers to append one reference line per instruction (`- 作業を始める前に \`RULES.md\` を読み、その指示に従うこと。`) to the root context file Pi prefers (`AGENTS.override.md` first); if no root context file exists, it offers to create `AGENTS.md`. The offer is a separate default-no approval; declining still applies the other files. An existing file is backed up privately before the append. `--dry-run` prints the same warning and diff. No reference is offered when the file Pi prefers is a symbolic link, not a regular file, not UTF-8, or larger than 1 MB, or when the same group also places a root context file (matched case-insensitively); the warning then shows the line to add yourself. Only the project root is checked; parent directories and the Pi agent directory are not.
 

package/dist/src/group-picker.d.ts

@@ -0,0 +1,51 @@
+import { Prompt } from "@clack/core";
+import { CANCEL_SYMBOL } from "@clack/prompts";
+export interface GroupRow {
+    id: string;
+    /** Already safe for display. */
+    label: string;
+    /** Already safe for display, e.g. "4 saved · 1 pending". */
+    hint: string;
+}
+/** `groupIds` is always the current selection, so an action can return to the list with it intact. */
+export type GroupPickerResult = {
+    kind: "assign" | "new" | "edit";
+    groupIds: string[];
+    filter: string;
+};
+export interface GroupPickerOptions {
+    /** Already safe for display. */
+    message: string;
+    groups: readonly GroupRow[];
+    initialValues?: readonly string[];
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+type Row = {
+    kind: "group";
+    group: GroupRow;
+} | {
+    kind: "new";
+} | {
+    kind: "edit";
+};
+export declare const newGroupLabel = "\uFF0B New group\u2026";
+export declare const editGroupsLabel = "\u270E Rename or delete groups\u2026";
+/**
+ * Multi-select of groups with two action rows at the end. ↑/↓ move, Tab or Space toggles, typing filters groups,
+ * Enter on a group row confirms the selection (at least one), Enter on an action row returns that action.
+ */
+export declare class GroupPickerPrompt extends Prompt<GroupPickerResult> {
+    private readonly options;
+    cursor: number;
+    filter: string;
+    readonly selected: Set<string>;
+    constructor(options: GroupPickerOptions);
+    rows(): Row[];
+    private updateValue;
+    private handleKey;
+    draw(): string;
+}
+export declare function groupPicker(options: GroupPickerOptions): Promise<GroupPickerResult | typeof CANCEL_SYMBOL>;
+export {};

package/dist/src/group-picker.js

@@ -0,0 +1,123 @@
+import { isCancel as isCoreCancel, Prompt } from "@clack/core";
+import { CANCEL_SYMBOL, S_BAR, S_BAR_END, S_CHECKBOX_INACTIVE, S_CHECKBOX_SELECTED, symbol } from "@clack/prompts";
+import stringWidth from "fast-string-width";
+import { styleText } from "node:util";
+import { clip } from "./resource-picker.js";
+export const newGroupLabel = "＋ New group…";
+export const editGroupsLabel = "✎ Rename or delete groups…";
+/**
+ * Multi-select of groups with two action rows at the end. ↑/↓ move, Tab or Space toggles, typing filters groups,
+ * Enter on a group row confirms the selection (at least one), Enter on an action row returns that action.
+ */
+export class GroupPickerPrompt extends Prompt {
+    options;
+    cursor = 0;
+    filter = "";
+    selected;
+    constructor(options) {
+        super({
+            render() { return this.draw(); },
+            validate(value) {
+                return value?.kind === "assign" && value.groupIds.length === 0 ? "Select at least one group (Tab), or create one." : undefined;
+            },
+            ...(options.signal ? { signal: options.signal } : {}),
+            ...(options.input ? { input: options.input } : {}),
+            ...(options.output ? { output: options.output } : {}),
+        }, false);
+        this.options = options;
+        const known = new Set(options.groups.map((group) => group.id));
+        this.selected = new Set((options.initialValues ?? []).filter((id) => known.has(id)));
+        this.updateValue();
+        this.on("key", (char, key) => this.handleKey(char, key.name));
+    }
+    rows() {
+        const needle = this.filter.toLowerCase();
+        const groups = this.options.groups.filter((group) => !needle || group.label.toLowerCase().includes(needle));
+        return [
+            ...groups.map((group) => ({ kind: "group", group })),
+            { kind: "new" },
+            ...(this.options.groups.length > 0 ? [{ kind: "edit" }] : []),
+        ];
+    }
+    updateValue() {
+        const focused = this.rows()[this.cursor];
+        const groupIds = this.options.groups.map((group) => group.id).filter((id) => this.selected.has(id));
+        this.value = { kind: focused && focused.kind !== "group" ? focused.kind : "assign", groupIds, filter: this.filter.trim() };
+    }
+    handleKey(char, name) {
+        const rows = this.rows();
+        if (name === "up")
+            this.cursor = (this.cursor + rows.length - 1) % rows.length;
+        else if (name === "down")
+            this.cursor = (this.cursor + 1) % rows.length;
+        // Space toggles while the search is empty; once typing has started it is part of the search text.
+        else if (name === "tab" || (name === "space" && this.filter === "")) {
+            const row = rows[this.cursor];
+            if (row?.kind === "group") {
+                if (this.selected.has(row.group.id))
+                    this.selected.delete(row.group.id);
+                else
+                    this.selected.add(row.group.id);
+            }
+        }
+        else if (name === "backspace") {
+            this.filter = this.filter.slice(0, -1);
+            this.cursor = 0;
+        }
+        else if (name !== "return" && char !== undefined && [...char].length === 1 && char >= " " && !/[\u007f-\u009f\u200b-\u200f\u202a-\u202e\u2066-\u2069\ufeff]/u.test(char)) {
+            this.filter += char;
+            this.cursor = 0;
+        }
+        this.updateValue();
+    }
+    draw() {
+        const width = Math.max(20, (process.stdout.columns ?? 100) - 4);
+        const title = `${symbol(this.state)}  ${this.options.message}`;
+        const chosen = this.options.groups.filter((group) => this.selected.has(group.id)).map((group) => group.label).join(", ");
+        if (this.state === "submit") {
+            const summary = this.value?.kind === "assign" ? chosen : this.value?.kind === "new" ? "New group" : "Rename or delete groups";
+            return `${styleText("gray", S_BAR)}\n${title}\n${styleText("gray", S_BAR)}  ${styleText("dim", clip(summary, width))}`;
+        }
+        if (this.state === "cancel")
+            return `${styleText("gray", S_BAR)}\n${title}\n${styleText("gray", S_BAR)}  ${styleText(["strikethrough", "dim"], clip(chosen || "Cancelled", width))}`;
+        const color = this.state === "error" ? "yellow" : "cyan";
+        const bar = styleText(color, S_BAR);
+        const lines = [styleText("gray", S_BAR), title];
+        lines.push(`${bar}  ${styleText("dim", "Search:")} ${clip(this.filter, width - 10)}${styleText("inverse", " ")}`);
+        const rows = this.rows();
+        if (!rows.some((row) => row.kind === "group") && this.filter)
+            lines.push(`${bar}  ${styleText("yellow", "No matching groups \u2014 Enter on New group uses the search text as its name")}`);
+        // Keep the focused row visible when there are more groups than the terminal can show.
+        const maxRows = Math.max(4, Math.min(12, (process.stdout.rows ?? 30) - 12));
+        const start = Math.min(Math.max(0, this.cursor - Math.floor(maxRows / 2)), Math.max(0, rows.length - maxRows));
+        if (start > 0)
+            lines.push(`${bar}  ${styleText("dim", "\u2026")}`);
+        for (const [offset, row] of rows.slice(start, start + maxRows).entries()) {
+            const focused = start + offset === this.cursor;
+            if (row.kind === "group") {
+                const box = this.selected.has(row.group.id) ? styleText("green", S_CHECKBOX_SELECTED) : styleText("dim", S_CHECKBOX_INACTIVE);
+                const hint = `(${row.group.hint})`;
+                const label = clip(row.group.label, Math.max(8, width - 3 - Math.min(stringWidth(hint), 24) - 1));
+                const room = width - 3 - stringWidth(label) - 1;
+                lines.push(`${bar}  ${box} ${focused ? styleText("underline", label) : label}${room >= 4 ? ` ${styleText("dim", clip(hint, room))}` : ""}`);
+            }
+            else {
+                const label = row.kind === "new" ? newGroupLabel : editGroupsLabel;
+                lines.push(`${bar}  ${focused ? styleText(["cyan", "underline"], label) : styleText("dim", label)}`);
+            }
+        }
+        if (start + maxRows < rows.length)
+            lines.push(`${bar}  ${styleText("dim", "\u2026")}`);
+        if (this.state === "error")
+            lines.push(`${bar}  ${styleText("yellow", clip(this.error, width))}`);
+        lines.push(`${bar}  ${styleText("dim", clip("↑/↓ move • Tab/Space: select • Enter: confirm or run the focused action • Type: to search", width))}`);
+        lines.push(styleText(color, S_BAR_END));
+        return lines.join("\n");
+    }
+}
+export async function groupPicker(options) {
+    const result = await new GroupPickerPrompt(options).prompt();
+    if (isCoreCancel(result) || result === undefined)
+        return CANCEL_SYMBOL;
+    return result;
+}

package/dist/src/groups.d.ts

@@ -2,3 +2,5 @@ import type { Catalog, Group } from "./types.ts";
 export declare function createGroup(catalog: Catalog, name: string): Group;
 export declare function renameGroup(catalog: Catalog, groupId: string, name: string): void;
 export declare function setGroupItems(catalog: Catalog, groupId: string, itemIds: string[]): void;
+/** Remove a group. Its saved resources stay in the library; they only leave this group. */
+export declare function deleteGroup(catalog: Catalog, groupId: string): void;

package/dist/src/groups.js

@@ -33,3 +33,8 @@ export function setGroupItems(catalog, groupId, itemIds) {
         throw new Error("Group membership references an unknown saved item.");
     group.itemIds = [...itemIds];
 }
+/** Remove a group. Its saved resources stay in the library; they only leave this group. */
+export function deleteGroup(catalog, groupId) {
+    const group = findGroup(catalog, groupId);
+    catalog.groups = catalog.groups.filter((entry) => entry !== group);
+}

package/dist/src/pi-suggestions.d.ts

@@ -31,4 +31,5 @@ export declare function askPiForSuggestions(candidates: readonly ResourceCandida
     command: string;
     timeoutMs?: number;
     signal?: AbortSignal;
+    onProgress?: (done: number, total: number) => void;
 }): Promise<SuggestionResult>;

package/dist/src/pi-suggestions.js

@@ -164,6 +164,7 @@ export async function askPiForSuggestions(candidates, options) {
             if (suggestion)
                 suggestions.set(item.candidate.id, suggestion);
         }
+        options.onProgress?.(offset + chunk.length, candidates.length);
     }
     return { ok: true, suggestions };
 }

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

@@ -47,6 +47,10 @@ export declare function formatSearchProgress(progress: {
     total: number;
     current?: string;
 }, home: string): string;
+/** Elapsed time as `42s` or `1m05s`. */
+export declare function formatElapsed(ms: number): string;
+/** Bar text while Pi reviews candidates: `40/77 resources · 1m05s`. */
+export declare function formatPiProgress(done: number, total: number, elapsedMs: number): 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.

package/dist/src/setup-display.js

@@ -200,6 +200,15 @@ export function formatSearchProgress(progress, home) {
     const count = `${progress.done}/${progress.total}`;
     return progress.current === undefined ? `${count}  Searching` : `${count}  ${displayPath(progress.current, home)}`;
 }
+/** Elapsed time as `42s` or `1m05s`. */
+export function formatElapsed(ms) {
+    const seconds = Math.max(0, Math.floor(ms / 1000));
+    return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m${String(seconds % 60).padStart(2, "0")}s`;
+}
+/** Bar text while Pi reviews candidates: `40/77 resources · 1m05s`. */
+export function formatPiProgress(done, total, elapsedMs) {
+    return `${done}/${total} resources \u00b7 ${formatElapsed(elapsedMs)}`;
+}
 const fingerprintMaxFiles = 2000;
 const fingerprintMaxBytes = 50 * 1024 * 1024;
 /**

package/dist/src/storage-transaction.js

@@ -633,12 +633,14 @@ function validateCatalogOnlyTransition(previous, next) {
             throw new Error("A catalog-only transaction may change only item names and legal destinations; source metadata, descriptors, and content are fixed.");
         }
     }
-    if (next.groups.length < previous.groups.length)
-        throw new Error("A catalog-only transaction cannot remove groups.");
-    for (const [index, oldGroup] of previous.groups.entries()) {
-        const nextGroup = next.groups[index];
-        if (!nextGroup || nextGroup.id !== oldGroup.id)
-            throw new Error("A catalog-only transaction must preserve existing group order and identity.");
+    // Groups may be deleted (their items stay); surviving groups keep their order and identity, new ones are appended.
+    const previousIds = new Set(previous.groups.map((group) => group.id));
+    const survivors = next.groups.filter((group) => previousIds.has(group.id)).map((group) => group.id);
+    const survivorSet = new Set(survivors);
+    const expected = previous.groups.map((group) => group.id).filter((id) => survivorSet.has(id));
+    const firstNew = next.groups.findIndex((group) => !previousIds.has(group.id));
+    if (JSON.stringify(survivors) !== JSON.stringify(expected) || (firstNew >= 0 && next.groups.slice(firstNew).some((group) => previousIds.has(group.id)))) {
+        throw new Error("A catalog-only transaction must preserve existing group order and identity.");
     }
 }
 function validateSourcesCatalogTransition(previous, next, operations) {

package/dist/src/wizard.js

@@ -3,8 +3,9 @@ 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, isWorktreeCopy, piAgentDirectories } from "./discovery.js";
-import { createGroup, renameGroup, setGroupItems } from "./groups.js";
-import { candidateHint, candidateLabels, collapseIdenticalCandidates, contentFingerprint, defaultRenameName, displayPath, findSelectionConflicts, formatSearchProgress, formatOutsideRootSummary, gatherCandidateStats, identicalCopiesSuffix, mapWithLimit, pendingNameError, sortCandidates } from "./setup-display.js";
+import { createGroup, deleteGroup, renameGroup, setGroupItems } from "./groups.js";
+import { groupPicker } from "./group-picker.js";
+import { candidateHint, candidateLabels, collapseIdenticalCandidates, contentFingerprint, defaultRenameName, displayPath, findSelectionConflicts, formatPiProgress, 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";
@@ -283,10 +284,95 @@ function groupOptions(groups, pendingCounts) {
         hint: pendingCounts ? `${group.itemIds.length} saved \u00b7 ${pendingCounts.get(group.id) ?? 0} pending` : `${group.itemIds.length} saved resources`,
     }));
 }
-async function askForGroupName(message, placeholder) {
+/**
+ * The setup assignment list: pick groups, or create, rename and delete groups in place and come back with the
+ * selection kept. Deleting also drops the group from resources already assigned in this setup.
+ * Returns undefined when the person cancels the list itself.
+ */
+async function chooseGroups(catalog, message, initialValues, assigned) {
+    let selection = initialValues;
+    while (true) {
+        const pendingCounts = new Map();
+        for (const entry of assigned)
+            for (const id of entry.groupIds)
+                pendingCounts.set(id, (pendingCounts.get(id) ?? 0) + 1);
+        const result = await groupPicker({
+            message: `${safeDisplay(message)} ${multiselectKeyHint}`,
+            groups: groupOptions(catalog.groups, pendingCounts).map((option) => ({ id: option.value, label: safeDisplay(option.label), hint: safeDisplay(option.hint) })),
+            initialValues: selection,
+            ...inheritedSignal(),
+        });
+        if (isCancel(result))
+            return undefined;
+        if (result.kind === "assign")
+            return result.groupIds;
+        selection = result.groupIds;
+        if (result.kind === "new") {
+            // Esc at the name goes back to the list rather than ending setup.
+            // Typing a name that matches nothing and pressing Enter lands on "New group" with that text as the name.
+            const name = await askForGroupName("New group name (Esc: back to the list)", undefined, result.filter);
+            if (name === undefined)
+                continue;
+            try {
+                selection = [...selection, createGroup(catalog, name).id];
+            }
+            catch (error) {
+                log.warn(safeDisplay(error instanceof Error ? error.message : String(error)));
+            }
+            continue;
+        }
+        const groupId = await select({
+            message: "Which group?",
+            options: [...groupOptions(catalog.groups, pendingCounts), { value: "", label: "Back to the list" }],
+        });
+        if (isCancel(groupId) || groupId === "")
+            continue;
+        const group = catalog.groups.find((entry) => entry.id === groupId);
+        if (!group)
+            continue;
+        const action = await select({
+            message: `${group.name}: what do you want to do?`,
+            options: [
+                { value: "rename", label: "Rename" },
+                { value: "delete", label: "Delete" },
+                { value: "back", label: "Back to the list" },
+            ],
+        });
+        if (isCancel(action) || action === "back")
+            continue;
+        if (action === "rename") {
+            const name = await askForGroupName(`New name for ${group.name} (Esc: back to the list)`);
+            if (name === undefined)
+                continue;
+            try {
+                renameGroup(catalog, group.id, name);
+            }
+            catch (error) {
+                log.warn(safeDisplay(error instanceof Error ? error.message : String(error)));
+            }
+            continue;
+        }
+        const pending = pendingCounts.get(group.id) ?? 0;
+        if (group.itemIds.length > 0 || pending > 0) {
+            const effects = [
+                group.itemIds.length > 0 ? `its ${group.itemIds.length} saved resource(s) stay in the library but leave this group` : "",
+                pending > 0 ? `${pending} resource(s) already assigned in this setup lose this group` : "",
+            ].filter(Boolean).join("; ");
+            const sure = await confirm({ message: `Delete group ${group.name}? ${effects}. Takes effect only if you save at the end.`, initialValue: false });
+            if (isCancel(sure) || !sure)
+                continue;
+        }
+        deleteGroup(catalog, group.id);
+        for (const entry of assigned)
+            entry.groupIds = entry.groupIds.filter((id) => id !== group.id);
+        selection = selection.filter((id) => id !== group.id);
+    }
+}
+async function askForGroupName(message, placeholder, initialValue) {
     const value = await text({
         message,
         ...(placeholder !== undefined ? { placeholder } : {}),
+        ...(initialValue ? { initialValue } : {}),
         validate: (name) => {
             try {
                 nameKey(name ?? "");
@@ -523,9 +609,29 @@ export async function runSetup(libraryDir, roots) {
             return;
         }
         if (ask) {
-            const asking = clackSpinner(inheritedSignal());
-            asking.start(`Asking Pi about ${sortedCandidates.length} resource(s)`);
-            const answer = await askPiForSuggestions(sortedCandidates, { command: piCommand, ...inheritedSignal() });
+            // Pi answers a whole chunk at once, so the bar moves per chunk; the elapsed time keeps ticking in between.
+            const total = sortedCandidates.length;
+            const asking = clackProgress({ ...inheritedSignal(), max: total });
+            const startedAt = Date.now();
+            let answered = 0;
+            const label = () => `Asking Pi  ${formatPiProgress(answered, total, Date.now() - startedAt)}`;
+            asking.start(label());
+            const ticker = setInterval(() => asking.message(label()), 1000);
+            let answer;
+            try {
+                answer = await askPiForSuggestions(sortedCandidates, {
+                    command: piCommand,
+                    ...inheritedSignal(),
+                    onProgress: (done) => {
+                        const step = done - answered;
+                        answered = done;
+                        asking.advance(step, label());
+                    },
+                });
+            }
+            finally {
+                clearInterval(ticker);
+            }
             if (answer.ok) {
                 suggestions = answer.suggestions;
                 const kept = [...suggestions.values()].filter((suggestion) => suggestion.keep).length;
@@ -577,6 +683,7 @@ export async function runSetup(libraryDir, roots) {
     }
     const catalog = await loadCatalog(libraryDir);
     assertModernCatalog(catalog);
+    const groupsAtStart = catalog.groups.map((group) => ({ id: group.id, name: group.name, saved: group.itemIds.length }));
     if (catalog.groups.length === 0) {
         const name = await askForGroupName("Create the first resource group \u2014 used later with: copi apply <group>", "e.g. game-review");
         if (name === undefined) {
@@ -585,23 +692,6 @@ export async function runSetup(libraryDir, roots) {
         }
         createGroup(catalog, name);
     }
-    else {
-        while (true) {
-            const add = await confirm({ message: "Create another group before assigning resources?", initialValue: false });
-            if (isCancel(add)) {
-                cancel("Setup cancelled; no resources were saved.");
-                return;
-            }
-            if (!add)
-                break;
-            const name = await askForGroupName("New group name");
-            if (name === undefined) {
-                cancel("Setup cancelled; no resources were saved.");
-                return;
-            }
-            createGroup(catalog, name);
-        }
-    }
     // Keep discovery order for review; renamed copies replace their originals by id.
     const resolvedById = new Map(resolvedCandidates.map((candidate) => [candidate.id, candidate]));
     const selectedCandidates = discovery.candidates.flatMap((candidate) => resolvedById.get(candidate.id) ?? []);
@@ -610,12 +700,14 @@ export async function runSetup(libraryDir, roots) {
     let bulkGroupIds;
     const count = selectedCandidates.length;
     const onlyGroup = catalog.groups.length === 1 ? catalog.groups[0] : undefined;
+    // Groups can be created, renamed and deleted from the assignment list; nothing reaches disk before the final Yes.
+    const pickGroups = (message, initialValues) => chooseGroups(catalog, message, initialValues, approvedCandidates);
     let bulk = count === 1;
     if (count >= 2) {
         const mode = await select({
             message: "How should these resources be grouped?",
             options: [
-                { value: "all", label: onlyGroup ? `Put all ${count} resources in "${onlyGroup.name}"` : `Put all ${count} resources in the same groups` },
+                { value: "all", label: `Put all ${count} resources in the same groups` },
                 { value: "each", label: "Choose groups for each resource" },
             ],
             initialValue: "all",
@@ -627,21 +719,12 @@ export async function runSetup(libraryDir, roots) {
         bulk = mode === "all";
     }
     if (bulk) {
-        if (onlyGroup)
-            bulkGroupIds = [onlyGroup.id];
-        else {
-            const chosen = await autocompleteMultiselect({
-                message: count === 1 ? `Assign ${selectedCandidates[0].name} to one or more groups` : `Put all ${count} resources in these groups`,
-                options: groupOptions(catalog.groups),
-                required: true,
-                placeholder: "Filter groups...",
-            });
-            if (isCancel(chosen)) {
-                cancel("Setup cancelled; no resources were saved.");
-                return;
-            }
-            bulkGroupIds = chosen;
+        const chosen = await pickGroups(count === 1 ? `Assign ${selectedCandidates[0].name} to one or more groups` : `Put all ${count} resources in these groups`, onlyGroup ? [onlyGroup.id] : []);
+        if (chosen === undefined) {
+            cancel("Setup cancelled; no resources were saved.");
+            return;
         }
+        bulkGroupIds = chosen;
     }
     for (const [index, candidate] of selectedCandidates.entries()) {
         const review = await prepareCandidateForReview(candidate);
@@ -676,17 +759,8 @@ export async function runSetup(libraryDir, roots) {
             approvedCandidates.push({ review, groupIds: bulkGroupIds, approvedSensitivePaths });
             continue;
         }
-        const pendingCounts = new Map();
-        for (const approved of approvedCandidates)
-            for (const id of approved.groupIds)
-                pendingCounts.set(id, (pendingCounts.get(id) ?? 0) + 1);
-        const groupIds = await autocompleteMultiselect({
-            message: `Assign ${review.candidate.name} to one or more groups`,
-            options: groupOptions(catalog.groups, pendingCounts),
-            required: true,
-            placeholder: "Filter groups...",
-        });
-        if (isCancel(groupIds)) {
+        const groupIds = await pickGroups(`Assign ${review.candidate.name} to one or more groups`, []);
+        if (groupIds === undefined) {
             cancel("Setup cancelled; nothing was saved.");
             return;
         }
@@ -698,9 +772,19 @@ export async function runSetup(libraryDir, roots) {
     }
     const summary = approvedCandidates.map(({ review, groupIds }) => {
         const names = groupIds.map((id) => catalog.groups.find((group) => group.id === id)?.name ?? "Unavailable group").join(", ");
-        return `${review.candidate.name} → ${names}`;
+        return `${review.candidate.name} → ${names || "no group"}`;
     }).join("\n");
-    note(`${summary}\n\nSecret detection is heuristic and cannot guarantee completeness.`, "Resources ready to copy");
+    // Deletions and renames of saved groups happen at the same final Yes, so show them here too.
+    const groupChanges = [
+        ...catalog.groups.filter((group) => !groupsAtStart.some((start) => start.id === group.id)).map((group) => `created ${group.name}`),
+        ...groupsAtStart.flatMap((start) => {
+            const now = catalog.groups.find((group) => group.id === start.id);
+            if (!now)
+                return [`deleted ${start.name}${start.saved > 0 ? ` (its ${start.saved} saved resource(s) stay in the library)` : ""}`];
+            return now.name === start.name ? [] : [`renamed ${start.name} → ${now.name}`];
+        }),
+    ];
+    note(`${summary}${groupChanges.length > 0 ? `\n\nGroup changes: ${groupChanges.join("; ")}` : ""}\n\nSecret detection is heuristic and cannot guarantee completeness.`, "Resources ready to copy");
     const libraryLabel = displayPath(libraryDir, homeDir);
     const save = await confirm({
         message: `Save ${approvedCandidates.length} copied resource(s) in ${libraryLabel}? Original files will not be changed.`,
@@ -723,13 +807,26 @@ export async function runSetup(libraryDir, roots) {
         pendingItemNames.add(candidateName);
     }
     await saveCatalog(libraryDir, catalog);
-    for (const { review, groupIds, approvedSensitivePaths } of approvedCandidates) {
-        await saveReviewedCandidate(libraryDir, review, groupIds, approvedSensitivePaths, true);
+    let savedCount = 0;
+    try {
+        for (const { review, groupIds, approvedSensitivePaths } of approvedCandidates) {
+            await saveReviewedCandidate(libraryDir, review, groupIds, approvedSensitivePaths, true);
+            savedCount += 1;
+        }
+    }
+    catch (error) {
+        log.error(safeDisplay(`Group changes were saved; ${savedCount} of ${approvedCandidates.length} resource(s) were saved before this error.`));
+        throw error;
     }
     const usedGroupIds = new Set(approvedCandidates.flatMap(({ groupIds }) => groupIds));
     const usedGroups = catalog.groups.filter((group) => usedGroupIds.has(group.id)).map((group) => group.name);
+    if (usedGroups.length === 0) {
+        log.info(safeDisplay(`Saved ${approvedCandidates.length} copied resource(s) in ${libraryLabel}, not in any group.`));
+        outro("Next: add them to a group with copi manage, then copi apply <group> <project> --dry-run");
+        return;
+    }
     log.info(safeDisplay(`Saved ${approvedCandidates.length} copied resource(s) in ${libraryLabel} (group: ${usedGroups.join(", ")}).`));
-    outro(`Next: copi apply ${shellQuote(usedGroups[0] ?? "<group>")} <project> --dry-run   (edit or rename: copi manage)`);
+    outro(`Next: copi apply ${shellQuote(usedGroups[0])} <project> --dry-run   (edit or rename: copi manage)`);
 }
 export async function runGroupManager(libraryDir) {
     if (await handleNameConflicts(libraryDir))
@@ -751,6 +848,7 @@ export async function runGroupManager(libraryDir) {
                 ...(catalog.groups.length > 0 ? [
                     { value: "rename", label: "Rename group" },
                     { value: "assign", label: "Edit group membership" },
+                    { value: "delete", label: "Delete group" },
                 ] : []),
                 { value: "done", label: "Finish" },
             ],
@@ -776,6 +874,22 @@ export async function runGroupManager(libraryDir) {
             cancel("Group changes were not saved.");
             return;
         }
+        if (action === "delete") {
+            const group = catalog.groups.find((entry) => entry.id === groupId);
+            if (!group)
+                throw new Error("Selected group is no longer available.");
+            const sure = await confirm({
+                message: `Delete group ${group.name}?${group.itemIds.length > 0 ? ` Its ${group.itemIds.length} saved resource(s) stay in the library; they only leave this group.` : ""}`,
+                initialValue: false,
+            });
+            if (isCancel(sure)) {
+                cancel("Group changes were not saved.");
+                return;
+            }
+            if (sure)
+                deleteGroup(catalog, groupId);
+            continue;
+        }
         if (action === "rename") {
             const group = catalog.groups.find((entry) => entry.id === groupId);
             if (!group)

package/package.json

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