@papillon6814/copi 0.1.0 → 0.2.0

package/dist/src/unicode-case-folding.d.ts

@@ -0,0 +1,2 @@
+/** Unicode 17.0.0 DEFAULT FULL case folding, independent of locale. */
+export declare function foldCaseUnicode17(value: string): string;

package/dist/src/unicode-case-folding.js

@@ -0,0 +1,9 @@
+import { unicode17CaseFolding } from "./unicode-case-folding-data.js";
+/** Unicode 17.0.0 DEFAULT FULL case folding, independent of locale. */
+export function foldCaseUnicode17(value) {
+    let result = "";
+    for (const character of value) {
+        result += unicode17CaseFolding.get(character.codePointAt(0)) ?? character;
+    }
+    return result;
+}

package/dist/src/wizard.d.ts

@@ -1,7 +1,13 @@
 import { type PreparedInspection, type PreparedResource } from "./catalog.ts";
 import { type DiscoveryOptions } from "./discovery.ts";
 import type { ApplyFileOption } from "./apply.ts";
-import type { Catalog, ResourceCandidate, SavedItem } from "./types.ts";
+import type { LegacySavedItem, ResourceCandidate, SavedItem, StoredCatalog } from "./types.ts";
+/** Mask display metadata too, and render controls literally rather than executing VT sequences. */
+export declare function safeDisplay(value: string): string;
+/** The editor parses literal paste versus cancel keys; stream EOF/errors/signals stay global. */
+export declare function withEditorInput<T>(operation: () => Promise<T>): Promise<T>;
+/** One process-wide interactive lifecycle shared by manage and its existing wizard routes. */
+export declare function withWizardLifecycle(operation: (signal: AbortSignal) => Promise<void>): Promise<void>;
 export interface SearchRoots {
     homeDir: string;
     agentDir: string;
@@ -21,10 +27,12 @@ export interface CandidateReview {
 }
 export declare function prepareCandidateForReview(candidate: ResourceCandidate): Promise<CandidateReview>;
 export declare function saveReviewedCandidate(libraryDir: string, review: CandidateReview, groupIds: string[], approvedSensitivePaths: string[], confirmed: boolean): Promise<SavedItem | null>;
+/** Resolve all staged conflicts in one name-only catalog save; cancellation writes nothing. */
+export declare function resolveNameConflicts(libraryDir: string): Promise<void>;
 export declare function runSetup(libraryDir: string, roots: SearchRoots): Promise<void>;
 export declare function runGroupManager(libraryDir: string): Promise<void>;
-export declare function printGroups(catalog: Catalog): void;
-export declare function printItems(items: SavedItem[]): void;
+export declare function printGroups(catalog: StoredCatalog): void;
+export declare function printItems(items: Array<LegacySavedItem | SavedItem>): void;
 export declare function formatApplyOptionPreview(filePath: string, resourceName: string, option: ApplyFileOption): string;
 export declare function runApplyDryRun(libraryDir: string, groupValue: string, projectDir: string): Promise<void>;
 export declare function runApplyWizard(libraryDir: string, groupValue: string, projectDir: string): Promise<void>;

package/dist/src/wizard.js

@@ -1,11 +1,88 @@
-import { autocompleteMultiselect, cancel, confirm, intro, isCancel, log, note, outro, select, text } from "@clack/prompts";
+import { autocompleteMultiselect as clackMultiselect, cancel as clackCancel, confirm as clackConfirm, intro as clackIntro, isCancel, log, note as clackNote, outro as clackOutro, select as clackSelect, text as clackText } from "@clack/prompts";
 import { lstat } from "node:fs/promises";
 import path from "node:path";
-import { importPreparedResource, loadCatalog, prepareResource, readPreparedResource, saveCatalog } from "./catalog.js";
+import { assertModernCatalog, importPreparedResource, loadCatalog, prepareResource, readPreparedResource, readSnapshotFiles, saveCatalog, saveNameChanges } from "./catalog.js";
 import { discoverResources } from "./discovery.js";
 import { createGroup, renameGroup, setGroupItems } from "./groups.js";
 import { inspectPreparedResource, maskSensitiveText } from "./inspect.js";
+import { assertNameAvailable, assertNoNameConflicts, findNameConflicts, nameKey } from "./names.js";
 import { executeApply, planApply } from "./apply.js";
+/** Mask display metadata too, and render controls literally rather than executing VT sequences. */
+export function safeDisplay(value) {
+    return maskSensitiveText(value)
+        .replace(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi, "[internal reference]")
+        .replace(/[\x00-\x09\x0b-\x1f\x7f-\x9f\u202a-\u202e\u2066-\u2069]/g, (char) => `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
+let activeSignal;
+let editorOwnsControlInput = false;
+/** The editor parses literal paste versus cancel keys; stream EOF/errors/signals stay global. */
+export async function withEditorInput(operation) {
+    const previous = editorOwnsControlInput;
+    editorOwnsControlInput = true;
+    try {
+        return await operation();
+    }
+    finally {
+        editorOwnsControlInput = previous;
+    }
+}
+function inheritedSignal(signal) {
+    const current = signal ?? activeSignal;
+    return current ? { signal: current } : {};
+}
+const select = (options) => clackSelect({
+    ...options, ...inheritedSignal(options.signal), message: safeDisplay(options.message),
+    options: options.options.map((option) => ({ ...option, label: safeDisplay(option.label ?? "Unavailable entry"), ...(option.hint === undefined ? {} : { hint: safeDisplay(option.hint) }) })),
+});
+const autocompleteMultiselect = (options) => clackMultiselect({
+    ...options, ...inheritedSignal(options.signal), message: safeDisplay(options.message),
+    options: typeof options.options === "function" ? options.options : options.options.map((option) => ({ ...option, label: safeDisplay(option.label ?? "Unavailable entry"), ...(option.hint === undefined ? {} : { hint: safeDisplay(option.hint) }) })),
+});
+const text = (options) => clackText({ ...options, ...inheritedSignal(options.signal), message: safeDisplay(options.message) });
+const confirm = (options) => clackConfirm({ ...options, ...inheritedSignal(options.signal), message: safeDisplay(options.message) });
+const note = (message, title, options) => clackNote(safeDisplay(message ?? ""), safeDisplay(title ?? ""), options);
+const intro = (message, options) => clackIntro(safeDisplay(message ?? ""), options);
+const outro = (message, options) => clackOutro(safeDisplay(message ?? ""), options);
+const cancel = (message, options) => clackCancel(safeDisplay(message ?? ""), options);
+/** One process-wide interactive lifecycle shared by manage and its existing wizard routes. */
+export async function withWizardLifecycle(operation) {
+    if (activeSignal)
+        throw new Error("An interactive wizard is already active.");
+    const controller = new AbortController();
+    const wasRaw = Boolean(process.stdin.isRaw), wasFlowing = process.stdin.readableFlowing === true;
+    const abort = () => controller.abort();
+    const eofKey = (chunk) => {
+        if (!editorOwnsControlInput && (typeof chunk === "string" ? chunk.includes("\u0004") : chunk.includes(4)))
+            abort();
+    };
+    activeSignal = controller.signal;
+    process.stdin.on("end", abort);
+    process.stdin.on("close", abort);
+    process.stdin.on("error", abort);
+    process.stdin.on("data", eofKey);
+    for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"])
+        process.on(signal, abort);
+    try {
+        await operation(controller.signal);
+    }
+    finally {
+        activeSignal = undefined;
+        process.stdin.off("end", abort);
+        process.stdin.off("close", abort);
+        process.stdin.off("error", abort);
+        process.stdin.off("data", eofKey);
+        for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"])
+            process.off(signal, abort);
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(wasRaw);
+        // Adding our data listener starts an inactive reader too; restore its original ownership.
+        if (wasFlowing)
+            process.stdin.resume();
+        else
+            process.stdin.pause();
+        process.stdout.write("\u001b[?25h");
+    }
+}
 const previewMaxBytes = 1_000_000;
 const previewMaxFiles = 12;
 const previewMaxLines = 24;
@@ -22,7 +99,7 @@ export function formatMaskedPreview(relativePath, content) {
     const lines = masked.split(/\r?\n/);
     const snippet = lines.slice(0, previewMaxLines).join("\n").slice(0, 2_000);
     const omitted = lines.length > previewMaxLines ? `\n… ${lines.length - previewMaxLines} more lines` : "";
-    return `${relativePath}:\n${snippet}${omitted}`;
+    return safeDisplay(`${relativePath}:\n${snippet}${omitted}`);
 }
 function formatPreparedFiles(files) {
     return files.slice(0, previewMaxFiles).map((file) => {
@@ -59,17 +136,159 @@ function showWarnings(warnings, title) {
         return;
     note(warnings.map((warning) => `${warning.path ? `${warning.path}: ` : ""}${warning.message}`).join("\n"), title);
 }
+function savedItemHint(catalog, item) {
+    const groups = catalog.groups.filter((group) => group.itemIds.includes(item.id)).map((group) => group.name).join(", ") || "no groups";
+    return `${groups} · ${item.source} · ${item.destination.kind === "project" ? item.destination.path : "saved only"}`;
+}
+async function viewSavedEntry(libraryDir) {
+    const catalog = await loadCatalog(libraryDir);
+    const entry = await select({
+        message: "Select saved resource or group",
+        options: [
+            ...catalog.items.map((item) => ({ value: `item:${item.id}`, label: `[${item.kind}] ${item.name}`, hint: savedItemHint(catalog, item) })),
+            ...catalog.groups.map((group) => ({ value: `group:${group.id}`, label: `[group] ${group.name}`, hint: `${group.itemIds.length} resources` })),
+        ],
+    });
+    if (isCancel(entry))
+        return;
+    const item = catalog.items.find((item) => `item:${item.id}` === entry);
+    if (item) {
+        const files = await readSnapshotFiles(libraryDir, item);
+        note(formatPreparedFiles(files).join("\n\n") || "No previewable files.", `Masked saved preview: ${item.name}`);
+    }
+    else {
+        const group = catalog.groups.find((group) => `group:${group.id}` === entry);
+        if (!group)
+            throw new Error("Selected group is no longer available.");
+        note(group.itemIds.map((id) => {
+            const member = catalog.items.find((item) => item.id === id);
+            return member ? `[${member.kind}] ${member.name} · ${savedItemHint(catalog, member)}` : "Unavailable resource";
+        }).join("\n") || "No saved resources.", group.name);
+    }
+}
+/** Resolve all staged conflicts in one name-only catalog save; cancellation writes nothing. */
+export async function resolveNameConflicts(libraryDir) {
+    const before = await loadCatalog(libraryDir);
+    assertModernCatalog(before);
+    const catalog = structuredClone(before);
+    if (findNameConflicts(catalog).length === 0) {
+        outro("No name conflicts.");
+        return;
+    }
+    while (true) {
+        const conflicts = findNameConflicts(catalog);
+        if (conflicts.length === 0)
+            break;
+        const options = conflicts.flatMap((conflict) => conflict.ids.map((id) => {
+            if (conflict.namespace === "item") {
+                const item = catalog.items.find((entry) => entry.id === id);
+                return { value: `item:${id}`, label: `[${item.kind}] ${item.name}`, hint: savedItemHint(catalog, item) };
+            }
+            const group = catalog.groups.find((entry) => entry.id === id);
+            return { value: `group:${id}`, label: `[group] ${group.name}`, hint: `${group.itemIds.length} resources` };
+        }));
+        const selected = await select({ message: "Select a conflicting name to rename", options });
+        if (isCancel(selected)) {
+            cancel("Name changes were not saved.");
+            return;
+        }
+        const namespace = selected.startsWith("item:") ? "item" : "group";
+        const id = selected.slice(namespace.length + 1);
+        const entries = namespace === "item" ? catalog.items : catalog.groups;
+        const entry = entries.find((entry) => entry.id === id);
+        if (!entry)
+            throw new Error("Selected name is no longer available.");
+        const name = await text({
+            message: `New name for ${entry.name}`,
+            validate: (value) => {
+                try {
+                    assertNameAvailable(catalog, namespace, value ?? "", id);
+                    return undefined;
+                }
+                catch (error) {
+                    return error instanceof Error ? error.message : "Choose a unique non-empty name.";
+                }
+            },
+        });
+        if (isCancel(name)) {
+            cancel("Name changes were not saved.");
+            return;
+        }
+        entry.name = name.trim();
+    }
+    const changes = [];
+    for (const namespace of ["item", "group"]) {
+        const oldEntries = namespace === "item" ? before.items : before.groups;
+        const nextEntries = namespace === "item" ? catalog.items : catalog.groups;
+        for (const entry of nextEntries) {
+            const previous = oldEntries.find((previous) => previous.id === entry.id);
+            if (previous.name !== entry.name)
+                changes.push(`[${namespace}] ${previous.name} → ${entry.name}`);
+        }
+    }
+    note(changes.join("\n"), "Explicit name changes; saved contents and destinations stay unchanged");
+    const save = await confirm({ message: "Save these name changes?", initialValue: false });
+    if (isCancel(save) || !save) {
+        outro("Name changes were not saved.");
+        return;
+    }
+    assertNoNameConflicts(catalog);
+    await saveNameChanges(libraryDir, before, catalog);
+    outro("Name conflicts resolved. Run setup or groups again to make other changes.");
+}
+async function handleNameConflicts(libraryDir) {
+    if (findNameConflicts(await loadCatalog(libraryDir)).length === 0)
+        return false;
+    while (true) {
+        const catalog = await loadCatalog(libraryDir);
+        const conflicts = findNameConflicts(catalog);
+        if (conflicts.length === 0)
+            return true;
+        const modern = catalog.version === 2;
+        note(conflicts.map((conflict) => {
+            const entries = conflict.namespace === "item" ? catalog.items : catalog.groups;
+            return `[${conflict.namespace}] ${conflict.ids.map((id) => entries.find((entry) => entry.id === id).name).join(" / ")}`;
+        }).join("\n"), modern ? "Duplicate names: only listing, masked viewing, and resolution are allowed" : "Legacy catalog v1 is read-only; duplicate names are not changed here");
+        const action = await select({
+            message: "Unresolved names",
+            options: [
+                { value: "view", label: "View saved resources or groups (masked)" },
+                ...(modern ? [{ value: "resolve", label: "Resolve name conflicts" }] : []),
+                { value: "done", label: "Finish without changes" },
+            ],
+        });
+        if (isCancel(action) || action === "done")
+            return true;
+        if (action === "view")
+            await viewSavedEntry(libraryDir);
+        else if (modern)
+            await resolveNameConflicts(libraryDir);
+    }
+}
 function groupOptions(groups) {
     return groups.map((group) => ({ value: group.id, label: group.name, hint: `${group.itemIds.length} saved resources` }));
 }
 async function askForGroupName(message) {
     const value = await text({
         message,
-        validate: (name) => name === undefined || name.trim().length === 0 ? "Enter a non-empty group name." : undefined,
+        validate: (name) => {
+            try {
+                nameKey(name ?? "");
+                return undefined;
+            }
+            catch {
+                return "Enter a non-empty group name.";
+            }
+        },
     });
     return isCancel(value) ? undefined : value.trim();
 }
 export async function runSetup(libraryDir, roots) {
+    if (await handleNameConflicts(libraryDir))
+        return;
+    const initial = await loadCatalog(libraryDir);
+    assertModernCatalog(initial);
+    assertNoNameConflicts(initial);
     intro("copi setup");
     const scopeOptions = [];
     if (roots.homeDir) {
@@ -138,6 +357,7 @@ export async function runSetup(libraryDir, roots) {
         return;
     }
     const catalog = await loadCatalog(libraryDir);
+    assertModernCatalog(catalog);
     if (catalog.groups.length === 0) {
         const name = await askForGroupName("Create the first resource group");
         if (name === undefined) {
@@ -189,7 +409,7 @@ export async function runSetup(libraryDir, roots) {
                 allSuspectedFilesApproved = false;
         }
         if (!allSuspectedFilesApproved) {
-            log.warn(`${review.candidate.name} was not selected for saving because a suspected sensitive file was not approved.`);
+            log.warn(safeDisplay(`${review.candidate.name} was not selected for saving because a suspected sensitive file was not approved.`));
             continue;
         }
         const groupIds = await autocompleteMultiselect({
@@ -209,7 +429,7 @@ export async function runSetup(libraryDir, roots) {
         return;
     }
     const summary = approvedCandidates.map(({ review, groupIds }) => {
-        const names = groupIds.map((id) => catalog.groups.find((group) => group.id === id)?.name ?? id).join(", ");
+        const names = groupIds.map((id) => catalog.groups.find((group) => group.id === id)?.name ?? "Unavailable group").join(", ");
         return `${review.candidate.name} → ${names}`;
     }).join("\n");
     note(summary, "Resources ready to copy");
@@ -221,6 +441,18 @@ export async function runSetup(libraryDir, roots) {
         outro("Nothing was saved.");
         return;
     }
+    // Validate the whole batch before saving groups or any snapshot.
+    const pending = structuredClone(catalog);
+    assertNoNameConflicts(pending);
+    const pendingItemNames = new Set(pending.items.map((item) => nameKey(item.name)));
+    for (const { review } of approvedCandidates) {
+        const candidate = readPreparedResource(review.prepared).candidate;
+        assertNameAvailable(pending, "item", candidate.name);
+        const candidateName = nameKey(candidate.name);
+        if (pendingItemNames.has(candidateName))
+            throw new Error("Duplicate item name; choose a unique display name.");
+        pendingItemNames.add(candidateName);
+    }
     await saveCatalog(libraryDir, catalog);
     for (const { review, groupIds, approvedSensitivePaths } of approvedCandidates) {
         await saveReviewedCandidate(libraryDir, review, groupIds, approvedSensitivePaths, true);
@@ -228,7 +460,10 @@ export async function runSetup(libraryDir, roots) {
     outro(`Saved ${approvedCandidates.length} copied resource(s) in ${libraryDir}.`);
 }
 export async function runGroupManager(libraryDir) {
+    if (await handleNameConflicts(libraryDir))
+        return;
     const catalog = await loadCatalog(libraryDir);
+    assertModernCatalog(catalog);
     if (catalog.groups.length === 0) {
         note("No groups are saved yet.", "Groups");
     }
@@ -254,6 +489,7 @@ export async function runGroupManager(libraryDir) {
         }
         if (action === "done")
             break;
+        assertModernCatalog(catalog);
         if (action === "create") {
             const name = await askForGroupName("New group name");
             if (name === undefined) {
@@ -307,6 +543,7 @@ export async function runGroupManager(libraryDir) {
         outro("Group changes were not saved.");
         return;
     }
+    assertModernCatalog(catalog);
     await saveCatalog(libraryDir, catalog);
     outro("Group changes saved.");
 }
@@ -316,7 +553,7 @@ export function printGroups(catalog) {
         return;
     }
     for (const group of catalog.groups)
-        process.stdout.write(`${group.name} (${group.id}) — ${group.itemIds.length} resource(s)\n`);
+        process.stdout.write(`${safeDisplay(group.name)} — ${group.itemIds.length} resource(s)\n`);
 }
 export function printItems(items) {
     if (items.length === 0) {
@@ -324,18 +561,18 @@ export function printItems(items) {
         return;
     }
     for (const item of items) {
-        process.stdout.write(`${item.name} [${item.kind}] (${item.id}) — ${item.files.length} file(s), ${item.destination.kind === "global-only" ? "saved only" : item.destination.path}\n`);
+        process.stdout.write(`${safeDisplay(item.name)} [${item.kind}] — ${item.files.length} file(s), ${safeDisplay(item.destination.kind === "global-only" ? "saved only" : item.destination.path)}\n`);
     }
 }
 function resolveGroup(catalog, value) {
     const matching = catalog.groups.filter((group) => group.id === value || group.name === value);
     if (matching.length === 0)
-        throw new Error(`Unknown group: ${value}`);
+        throw new Error("Unknown group; select a saved group with copi manage.");
     if (matching.length > 1)
-        throw new Error(`Group name is ambiguous: ${value}; use a group ID.`);
+        throw new Error("Group name is ambiguous; resolve name conflicts with copi manage.");
     const group = matching[0];
     if (!group)
-        throw new Error(`Unknown group: ${value}`);
+        throw new Error("Selected group is unavailable.");
     return group;
 }
 function formatPlan(plan, catalog) {
@@ -344,26 +581,32 @@ function formatPlan(plan, catalog) {
         const mark = file.alternatives.some((option) => option.sensitive) ? " [suspected secret; approval required]" : "";
         const preview = file.preview.kind === "text" ? `\n${file.preview.diff}` : `\n${file.preview.summary}`;
         const alternatives = file.alternatives.length > 1
-            ? `\n  candidates: ${file.alternatives.map((option) => itemNames.get(option.itemId) ?? option.itemId).join(", ")}`
+            ? `\n  candidates: ${file.alternatives.map((option) => itemNames.get(option.itemId) ?? "Unavailable resource").join(", ")}`
             : "";
         return `${file.status}: ${file.path}${mark}${alternatives}${preview}`;
     });
+    const proposal = plan.referenceProposal;
+    const reference = proposal
+        ? [`reference (optional, approval required during apply): ${proposal.status}: ${proposal.path}${proposal.preview.kind === "text" ? `\n${proposal.preview.diff}` : `\n${proposal.preview.summary}`}`]
+        : [];
     const warnings = plan.warnings.map((warning) => `warning${warning.path ? ` ${warning.path}` : ""}: ${warning.message}`);
-    const skipped = plan.skippedItems.map((id) => `save-only resource skipped from apply: ${itemNames.get(id) ?? id}`);
-    return [...lines, ...warnings, ...skipped].join("\n\n") || "No project files need changes.";
+    const skipped = plan.skippedItems.map((id) => `save-only resource skipped from apply: ${itemNames.get(id) ?? "Unavailable resource"}`);
+    return [...lines, ...reference, ...warnings, ...skipped].join("\n\n") || "No project files need changes.";
 }
 export function formatApplyOptionPreview(filePath, resourceName, option) {
     const preview = option.preview.kind === "text" ? option.preview.diff : option.preview.summary;
-    return `${resourceName} → ${filePath}\n${preview}`;
+    return safeDisplay(`${resourceName} → ${filePath}\n${preview}`);
 }
 export async function runApplyDryRun(libraryDir, groupValue, projectDir) {
     const catalog = await loadCatalog(libraryDir);
+    assertModernCatalog(catalog);
     const group = resolveGroup(catalog, groupValue);
     const plan = await planApply(libraryDir, group.id, projectDir);
     note(formatPlan(plan, catalog), `Dry run: ${group.name} → ${projectDir}`);
 }
 export async function runApplyWizard(libraryDir, groupValue, projectDir) {
     const catalog = await loadCatalog(libraryDir);
+    assertModernCatalog(catalog);
     const group = resolveGroup(catalog, groupValue);
     const plan = await planApply(libraryDir, group.id, projectDir);
     if (plan.files.length === 0) {
@@ -383,7 +626,7 @@ export async function runApplyWizard(libraryDir, groupValue, projectDir) {
                 message: `Choose one resource for colliding path ${file.path}`,
                 options: file.alternatives.map((option) => ({
                     value: option.itemId,
-                    label: catalog.items.find((item) => item.id === option.itemId)?.name ?? option.itemId,
+                    label: catalog.items.find((item) => item.id === option.itemId)?.name ?? "Unavailable resource",
                     hint: option.preview.kind === "text" ? "masked text diff available" : option.preview.summary,
                 })),
             });
@@ -396,7 +639,7 @@ export async function runApplyWizard(libraryDir, groupValue, projectDir) {
                 throw new Error(`Selected resource is unavailable for ${file.path}.`);
             collisionDecisions[file.path] = selectedItem;
             sensitive = selectedOption.sensitive;
-            const selectedName = catalog.items.find((item) => item.id === selectedItem)?.name ?? selectedItem;
+            const selectedName = catalog.items.find((item) => item.id === selectedItem)?.name ?? "Unavailable resource";
             note(formatApplyOptionPreview(file.path, selectedName, selectedOption), "Selected colliding resource preview");
         }
         let hasExistingFile = file.status === "different";
@@ -450,6 +693,18 @@ export async function runApplyWizard(libraryDir, groupValue, projectDir) {
         }
     }
     decisions.secretApprovals = [...selectedSecrets];
+    if (plan.referenceProposal) {
+        const proposal = plan.referenceProposal;
+        const addReference = await confirm({
+            message: `${proposal.status === "new" ? "Create" : "Append to"} ${proposal.path} with a reference line for ${proposal.instructionPaths.join(", ")}? Pi does not load these files automatically.`,
+            initialValue: false,
+        });
+        if (isCancel(addReference)) {
+            cancel("Apply cancelled; project files were not changed.");
+            return;
+        }
+        decisions.addReference = addReference;
+    }
     const apply = await confirm({ message: `Apply the selected snapshots to ${projectDir}?`, initialValue: false });
     if (isCancel(apply) || !apply) {
         outro("Project files were not changed.");
@@ -460,5 +715,6 @@ export async function runApplyWizard(libraryDir, groupValue, projectDir) {
         outro("Apply aborted; project files were not changed.");
         return;
     }
-    outro(`Applied ${result.written.length} file(s); kept ${result.kept.length}; saved ${result.backups.length} private backup(s).`);
+    const referenceNote = result.referenceAdded ? ` Added a reference line to ${result.referenceAdded}.` : "";
+    outro(`Applied ${result.written.length} file(s); kept ${result.kept.length}; saved ${result.backups.length} private backup(s).${referenceNote}`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@papillon6814/copi",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Collect and organize reusable Pi coding-agent resources",
   "license": "MIT",
   "type": "module",
@@ -9,8 +9,10 @@
   },
   "files": [
     "dist/src",
+    "dist/native",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "LICENSE.unicode"
   ],
   "engines": {
     "node": ">=22.19.0"
@@ -19,7 +21,7 @@
     "darwin"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json && node scripts/build-native.mjs",
     "test": "npm run build && node --test dist/test/*.test.js",
     "check": "npm run build && npm test && npm pack --dry-run"
   },