@kisev/agentomatic 11.0.0-dev.57.gb877c35a2446 → 11.0.0-dev.58.gc136a777fcbb

package/dist/cli.js

@@ -8,7 +8,7 @@ import { apply, defaultSelection, InstallerError, normalizeSelection, preview, S
 import { LifecycleError } from "./lifecycle.js";
 import { skillsInstallerSpec } from "./package-metadata.js";
 import { applyReconcile, previewReconcile } from "./reconcile.js";
-import { promptText, selectOption, selectOptions } from "./terminal-wizard.js";
+import { confirmQuestion, promptText, selectOption, selectOptions } from "./terminal-wizard.js";
 function parseOptions(values) {
     const options = {
         scope: "project",
@@ -41,6 +41,16 @@ function parseOptions(values) {
                 throw new InstallerError("invalid_input", "--yes may be supplied once");
             options.yes = true;
         }
+        else if (value === "--core") {
+            if (options.core === true || options.core === false)
+                throw new InstallerError("invalid_input", "Use only one core integration option");
+            options.core = true;
+        }
+        else if (value === "--no-core") {
+            if (options.core === true || options.core === false)
+                throw new InstallerError("invalid_input", "Use only one core integration option");
+            options.core = false;
+        }
         else if (value === "--provider") {
             options.provider = values[++index];
             if (!options.provider)
@@ -162,6 +172,7 @@ function rootHelp() {
             ["--skill-commands <list|none>", "Select adapters for installed portable skills."],
             ["--agents <list|none>", "Select fixed agents."],
             ["--plugins <list|none>", "Select optional plugin wrappers; rtk is the default."],
+            ["--core / --no-core", "Toggle plugin entry wiring and npm dependency provisioning."],
             ["--targets <list|none>", "Select config targets for the config command."],
             ["--fragments <list|none>", "Select config fragments for the config command."],
         ]),
@@ -268,13 +279,16 @@ function contextualHelp(arguments_) {
             ["--skill-commands <list|none>", "Select installed-skill adapters."],
             ["--agents <list|none>", "Select fixed agents."],
             ["--plugins <list|none>", "Select optional plugin wrappers; rtk is preselected."],
+            ["--core", "Wire the plugin entry and pin the npm dependency in one run."],
+            ["--no-core", "Skip plugin entry wiring and npm dependency provisioning."],
             ["--json", "Emit stable machine-readable output."],
             ["--help", "Show this command help and exit."],
         ], [
-            "Without selection flags, a TTY opens command, agent, and plugin selectors.",
+            "Without selection flags, a TTY opens command, agent, plugin, and core selectors.",
             "Use Up/Down to move, Space to toggle, A/N for all/none, and Enter to confirm.",
             "Outside a TTY, provide command selection, --agents, and --plugins.",
-            "Writes occur only after confirmation; install never edits opencode.json.",
+            "Confirmed core integration wires the core-plugin fragment in the same run;",
+            "asset writes never touch opencode.json directly.",
             "Portable skills are installed separately; restart OpenCode after asset changes.",
         ], [
             shellCommand(["install", "--global", "--dry-run"]),
@@ -566,10 +580,14 @@ async function interactiveInstallerSelection() {
     const commands = await group("Skill command adapters", SKILL_COMMANDS, SKILL_COMMANDS);
     const agents = await group("Fixed agents", defaults.agents, defaults.agents);
     const plugins = await group("Selectable plugins", SELECTABLE_PLUGINS, defaults.plugins);
+    const core = await selectOption("Core integration: wire the plugin entry and pin the npm dependency?", ["Yes", "No"], process.stdin, process.stderr);
+    if (core === null)
+        throw new InstallerError("cancelled", "Wizard cancelled");
     return normalizeSelection({
         commands,
         agents: agents,
         plugins: plugins,
+        core_activation: core === 0,
     });
 }
 function installerSelection(options) {
@@ -577,6 +595,7 @@ function installerSelection(options) {
         commands: options.commands,
         agents: options.agents,
         plugins: options.plugins,
+        ...(options.core === undefined ? {} : { core_activation: options.core }),
     });
 }
 function configSelectionFromOptions(options) {
@@ -641,8 +660,8 @@ function requireApplyMode(options) {
         throw new InstallerError("invalid_input", "Applying outside a terminal requires --yes; use --dry-run to preview");
 }
 async function confirmSummary() {
-    const choice = await selectOption("Apply these changes?", ["Yes", "No"]);
-    if (choice !== 0)
+    const choice = await confirmQuestion("Apply these changes?");
+    if (choice !== true)
         throw new InstallerError("cancelled", "Cancelled before apply");
 }
 function applyHint(command) {
@@ -961,12 +980,36 @@ async function run(arguments_) {
                 ? installerSelection(options)
                 : await interactiveInstallerSelection()
             : undefined;
+        const coreSelection = action === "install" && selection?.core_activation
+            ? normalizeConfigSelection(options.scope, {
+                targets: ["opencode"],
+                fragments: ["core-plugin"],
+            })
+            : undefined;
+        const applyCoreIntegration = async () => {
+            if (!coreSelection)
+                return null;
+            try {
+                return await applyConfigSetup(coreSelection, options.scope);
+            }
+            catch (error) {
+                const known = error instanceof LifecycleError
+                    ? error
+                    : new InstallerError("internal_error", error instanceof Error ? error.message : String(error));
+                process.stderr.write(`Assets applied, but core integration failed [${known.code}]: ${terminalSafe(known.message)}\nRetry with: ${shellCommand(["config", ...scopeArguments(options.scope), "--targets", "opencode", "--fragments", "core-plugin"])}\n`);
+                process.exitCode = 2;
+                return null;
+            }
+        };
         requireApplyMode(options);
         if (options.dryRun) {
             const plan = await preview(action, options.scope, process.cwd(), undefined, selection, !options.noDependency);
+            const corePlan = coreSelection
+                ? await previewConfigSetup(coreSelection, options.scope)
+                : undefined;
             if (options.json)
-                process.stdout.write(`${JSON.stringify({ status: "ok", applied: false, requires_restart: plan.requires_restart, plan }, null, 2)}\n`);
-            else
+                process.stdout.write(`${JSON.stringify({ status: "ok", applied: false, requires_restart: plan.requires_restart, plan, ...(corePlan ? { core_integration: corePlan } : {}) }, null, 2)}\n`);
+            else {
                 process.stdout.write(renderPlan(plan, {
                     applied: false,
                     applyHint: applyHint([
@@ -976,6 +1019,9 @@ async function run(arguments_) {
                         ...(options.noDependency ? ["--no-dependency"] : []),
                     ]),
                 }));
+                if (corePlan)
+                    process.stdout.write(renderConfigSetup(corePlan, { applied: false }));
+            }
         }
         else {
             if (!options.yes) {
@@ -984,17 +1030,20 @@ async function run(arguments_) {
                 await confirmSummary();
             }
             const plan = await apply(action, options.scope, process.cwd(), undefined, {}, selection, !options.noDependency);
+            const corePlan = await applyCoreIntegration();
             if (options.json)
-                process.stdout.write(`${JSON.stringify({ status: "ok", applied: true, requires_restart: plan.requires_restart, plan }, null, 2)}\n`);
+                process.stdout.write(`${JSON.stringify({ status: "ok", applied: true, requires_restart: plan.requires_restart, plan, ...(corePlan ? { core_integration: corePlan } : {}) }, null, 2)}\n`);
             else
                 process.stdout.write(renderPlan(plan, {
                     applied: true,
-                    ...(action === "install"
+                    ...(action === "install" && !corePlan
                         ? {
                             hint: `Connect the package into user configs: ${shellCommand(["config", ...scopeArguments(options.scope), "--dry-run"])}`,
                         }
                         : {}),
                 }));
+            if (corePlan && !options.json)
+                process.stdout.write(renderConfigSetup(corePlan, { applied: true }));
         }
         return;
     }

package/dist/config-setup.js

@@ -1,7 +1,9 @@
 import { readFileSync } from "node:fs";
+import { lstat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { archiveMutations } from "./installer.js";
 import { requirePackageVersion } from "./package-metadata.js";
 import { ensureDependency, planDependency } from "./self-install.js";
 import { applyTransaction, deploymentRoot, LifecycleError, lifecycleRoot, readRegular, recoverTransaction, sha256, withLifecycleLock, } from "./lifecycle.js";
@@ -414,7 +416,27 @@ export async function applyConfigSetup(selection, scope, cwd = process.cwd(), ho
                 }
                 throw new ConfigSetupError("invalid_state", "Config setup plan has no applicable changes");
             }
-            await applyTransaction(root, stateRoot, built.mutations, {
+            const backups = [];
+            for (const mutation of built.mutations) {
+                if (mutation.operation !== "write")
+                    continue;
+                const target = join(mutation.root ?? root, mutation.path);
+                const current = await readRegular(target).catch(() => undefined);
+                if (!current || current.equals(mutation.content))
+                    continue;
+                backups.push({
+                    path: target,
+                    record: {
+                        sha256: sha256(current),
+                        mode: (await lstat(target)).mode & 0o777,
+                    },
+                    content: current,
+                    reason: "pre-apply config backup",
+                    kind: "config-backup",
+                });
+            }
+            const backupMutations = await archiveMutations(backups, scope, cwd, home, requirePackageVersion(), new Date().toISOString());
+            await applyTransaction(root, stateRoot, [...built.mutations, ...backupMutations], {
                 validateFinal: async () => {
                     for (const mutation of built.mutations) {
                         if (mutation.operation !== "write")

package/dist/doctor.js

@@ -505,6 +505,31 @@ export async function collectDoctorFacts(scope, cwd = process.cwd(), home = home
             status: dependency.status,
         }, ["Run config with the core-plugin fragment to provision the persistent npm dependency."]));
     }
+    const archiveIndexPath = join(archiveRoot(scope, project, homeRoot), "index.json");
+    const archiveIndexRaw = await regular(archiveIndexPath);
+    let backupEntries = [];
+    if (archiveIndexRaw) {
+        try {
+            const parsed = JSON.parse(archiveIndexRaw.raw.toString("utf8"));
+            if (Array.isArray(parsed.entries))
+                backupEntries = parsed.entries.filter((item) => Boolean(item &&
+                    typeof item === "object" &&
+                    item.kind === "config-backup"));
+        }
+        catch {
+            partial.push("config.backups");
+        }
+    }
+    const latestBackup = backupEntries
+        .map((item) => String(item.timestamp ?? ""))
+        .sort()
+        .at(-1);
+    checks.push(check("config.backups", archiveIndexRaw ? "pass" : "incomplete", "User configuration snapshots are tracked in the archive", {
+        archive_index: archiveIndexPath,
+        config_backups: backupEntries.length,
+        latest_backup_at: latestBackup ?? "never",
+        latest_paths: backupEntries.slice(-3).map((item) => String(item.original_path ?? "")),
+    }, ["Configuration edits archive the previous content before every apply."]));
     const rtkWrapper = await regular(join(deployment, "plugins", "rtk.js"));
     const rtkDeployed = rtkWrapper.status === "present";
     let rtkStats = undefined;

package/dist/installer.d.ts

@@ -31,17 +31,15 @@ export type Plan = {
     };
     requires_restart: boolean;
 };
-type ManifestFile = {
-    sha256: string;
-    mode: number;
-    kind: "command" | "agent" | "plugin" | "state";
-};
 export type ArchiveCandidate = {
     path: string;
-    record: ManifestFile;
+    record: {
+        sha256: string;
+        mode: number;
+    };
     content: Buffer;
     reason: string;
-    kind: "command" | "agent" | "plugin" | "state";
+    kind: "command" | "agent" | "plugin" | "state" | "config-backup";
 };
 export declare const SELECTABLE_PLUGINS: SelectablePlugin[];
 export declare const SKILL_COMMANDS: string[];
@@ -49,7 +47,7 @@ export declare function defaultSelection(): InstallerSelection;
 export declare function normalizeSelection(value?: Partial<InstallerSelection>): InstallerSelection;
 export declare class InstallerError extends LifecycleError {
 }
-export declare function archiveMutations(candidates: readonly ArchiveCandidate[], scope: Scope, cwd: string, home: string, sourceVersion: string): Promise<FileMutation[]>;
+export declare function archiveMutations(candidates: readonly ArchiveCandidate[], scope: Scope, cwd: string, home: string, sourceVersion: string, timestamp?: string): Promise<FileMutation[]>;
 export declare function preview(action: Action, scope: Scope, cwd?: string, home?: string, selection?: Partial<InstallerSelection>, provisionDependency?: boolean): Promise<Plan>;
 export declare function apply(action: Action, scope: Scope, cwd?: string, home?: string, options?: TransactionOptions & {
     dependencyRunner?: DependencyRunner;

package/dist/installer.js

@@ -184,7 +184,7 @@ async function currentManifest(root) {
     }
     return {};
 }
-export async function archiveMutations(candidates, scope, cwd, home, sourceVersion) {
+export async function archiveMutations(candidates, scope, cwd, home, sourceVersion, timestamp = new Date(0).toISOString()) {
     if (!candidates.length)
         return [];
     const root = archiveRoot(scope, cwd, home);
@@ -226,7 +226,7 @@ export async function archiveMutations(candidates, scope, cwd, home, sourceVersi
     const known = new Set(entries.map((entry) => `${String(entry.original_path)}:${String(entry.digest)}`));
     const mutations = [];
     const queuedObjects = new Set();
-    const now = new Date(0).toISOString();
+    const now = timestamp;
     for (const candidate of candidates) {
         const digestValue = sha256(candidate.content);
         const key = `${candidate.path}:${digestValue}`;

package/dist/reconcile.js

@@ -223,7 +223,7 @@ async function build(scope, cwd = process.cwd(), home = homedir()) {
                     : "state";
             archiveCandidates.push({
                 path: relativePath(root, target),
-                record: { sha256: record.sha256, mode: 0o644, kind },
+                record: { sha256: record.sha256, mode: 0o644 },
                 content: value.content,
                 reason: "retired inventory asset",
                 kind,

package/dist/terminal-wizard.d.ts

@@ -1,3 +1,5 @@
-export declare function selectOption(label: string, options: readonly string[], stdin?: NodeJS.ReadStream, stderr?: NodeJS.WriteStream, initial?: number): Promise<number | null>;
-export declare function selectOptions(label: string, options: readonly string[], initialSelected?: readonly string[], stdin?: NodeJS.ReadStream, stderr?: NodeJS.WriteStream): Promise<string[] | null>;
-export declare function promptText(label: string, stdin?: NodeJS.ReadStream, stderr?: NodeJS.WriteStream): Promise<string | null>;
+import type { Readable, Writable } from "node:stream";
+export declare function selectOption(label: string, options: readonly string[], stdin?: Readable, stderr?: Writable, initial?: number): Promise<number | null>;
+export declare function selectOptions(label: string, options: readonly string[], initialSelected?: readonly string[], stdin?: Readable, stderr?: Writable): Promise<string[] | null>;
+export declare function promptText(label: string, stdin?: Readable, stderr?: Writable): Promise<string | null>;
+export declare function confirmQuestion(label: string, stdin?: Readable, stderr?: Writable): Promise<boolean | null>;

package/dist/terminal-wizard.js

@@ -1,36 +1,11 @@
+import * as clack from "@clack/prompts";
 import { InstallerError } from "./installer.js";
-function parseKey(buffer) {
-    const seq = buffer.toString();
-    if (seq === "\r" || seq === "\n")
-        return { name: "return", sequence: seq };
-    if (seq === " ")
-        return { name: "space", sequence: seq };
-    if (seq === "a" || seq === "A")
-        return { name: "all", sequence: seq };
-    if (seq === "n" || seq === "N")
-        return { name: "none", sequence: seq };
-    if (seq === "\x03")
-        return { name: "ctrl+c", sequence: seq };
-    if (seq === "\x04")
-        return { name: "ctrl+d", sequence: seq };
-    if (seq === "\x1b" || seq === "\x1b\x1b" || seq === "\x1b\x1b\x1b")
-        return { name: "escape", sequence: seq };
-    if (seq === "\x1b[A" || seq === "\x1bOA" || seq === "\x1b[OA")
-        return { name: "up", sequence: seq };
-    if (seq === "\x1b[B" || seq === "\x1bOB" || seq === "\x1b[OB")
-        return { name: "down", sequence: seq };
-    if (seq === "\x1b[C" || seq === "\x1bOC" || seq === "\x1b[OC")
-        return { name: "right", sequence: seq };
-    if (seq === "\x1b[D" || seq === "\x1bOD" || seq === "\x1b[OD")
-        return { name: "left", sequence: seq };
-    return { name: "unknown", sequence: seq };
+function interactiveStreams(stdin, stderr) {
+    if (!isTTY(stdin) || !isTTY(stderr))
+        throw new InstallerError("terminal_required", "This operation requires an interactive terminal");
 }
-function nextSequence(remaining) {
-    if (remaining.startsWith("\x1b[O"))
-        return remaining.slice(0, 4);
-    if (remaining.startsWith("\x1b[") || remaining.startsWith("\x1bO"))
-        return remaining.slice(0, 3);
-    return remaining[0];
+function isTTY(stream) {
+    return Boolean(stream.isTTY);
 }
 function validateOptions(options) {
     if (options.length === 0)
@@ -38,200 +13,52 @@ function validateOptions(options) {
     if (new Set(options).size !== options.length)
         throw new InstallerError("invalid_input", "Interactive selector options must be unique");
 }
-function clearLines(stderr, count) {
-    for (let i = 0; i < count; i++) {
-        stderr.write("\x1b[A\x1b[K");
-    }
-}
 export async function selectOption(label, options, stdin = process.stdin, stderr = process.stderr, initial = 0) {
-    if (!stdin.isTTY || !stderr.isTTY) {
-        throw new InstallerError("terminal_required", "This operation requires an interactive terminal");
-    }
+    interactiveStreams(stdin, stderr);
     validateOptions(options);
-    let selected = Math.max(0, Math.min(initial, options.length - 1));
-    const lineCount = options.length + 2;
-    function render() {
-        stderr.write(`? ${label}\n`);
-        stderr.write("  Up/Down move | Enter select | Esc cancel\n");
-        for (let i = 0; i < options.length; i++) {
-            const cursor = i === selected ? "> " : "  ";
-            stderr.write(`${cursor}${options[i]}\n`);
-        }
-    }
-    render();
-    return new Promise((resolve) => {
-        stdin.setRawMode(true);
-        stdin.resume();
-        function cleanup() {
-            stdin.setRawMode(false);
-            stdin.pause();
-            stdin.removeListener("data", onData);
-        }
-        function onData(data) {
-            let remaining = data.toString();
-            while (remaining) {
-                const sequence = nextSequence(remaining);
-                remaining = remaining.slice(sequence.length);
-                const key = parseKey(Buffer.from(sequence));
-                if (key.name === "ctrl+c" || key.name === "ctrl+d" || key.name === "escape") {
-                    cleanup();
-                    clearLines(stderr, lineCount);
-                    resolve(null);
-                    return;
-                }
-                if (key.name === "return") {
-                    cleanup();
-                    clearLines(stderr, lineCount);
-                    resolve(selected);
-                    return;
-                }
-                if (key.name === "up") {
-                    clearLines(stderr, lineCount);
-                    selected = (selected - 1 + options.length) % options.length;
-                    render();
-                }
-                else if (key.name === "down") {
-                    clearLines(stderr, lineCount);
-                    selected = (selected + 1) % options.length;
-                    render();
-                }
-            }
-        }
-        stdin.on("data", onData);
+    const value = await clack.select({
+        message: label,
+        options: options.map((option, index) => ({ value: index, label: option })),
+        initialValue: Math.max(0, Math.min(initial, options.length - 1)),
+        input: stdin,
+        output: stderr,
     });
+    if (clack.isCancel(value))
+        return null;
+    return value;
 }
 export async function selectOptions(label, options, initialSelected = [], stdin = process.stdin, stderr = process.stderr) {
-    if (!stdin.isTTY || !stderr.isTTY) {
-        throw new InstallerError("terminal_required", "This operation requires an interactive terminal");
-    }
+    interactiveStreams(stdin, stderr);
     validateOptions(options);
     const allowed = new Set(options);
     for (const value of initialSelected) {
         if (!allowed.has(value))
             throw new InstallerError("invalid_input", `Unknown initial selector option: ${value}`);
     }
-    const selected = new Set(initialSelected);
-    let active = 0;
-    const lineCount = options.length + 3;
-    function render() {
-        stderr.write(`? ${label}\n`);
-        stderr.write("  Up/Down move | Space toggle | A all | N none | Enter confirm | Esc cancel\n");
-        for (let index = 0; index < options.length; index += 1) {
-            const cursor = index === active ? "> " : "  ";
-            const marker = selected.has(options[index]) ? "[x]" : "[ ]";
-            stderr.write(`${cursor}${marker} ${options[index]}\n`);
-        }
-        stderr.write(`  Selected ${selected.size}/${options.length}\n`);
-    }
-    render();
-    return new Promise((resolve) => {
-        stdin.setRawMode(true);
-        stdin.resume();
-        function cleanup() {
-            stdin.setRawMode(false);
-            stdin.pause();
-            stdin.removeListener("data", onData);
-        }
-        function finish(value) {
-            cleanup();
-            clearLines(stderr, lineCount);
-            resolve(value);
-        }
-        function redraw(update) {
-            clearLines(stderr, lineCount);
-            update();
-            render();
-        }
-        function onData(data) {
-            let remaining = data.toString();
-            while (remaining) {
-                const sequence = nextSequence(remaining);
-                remaining = remaining.slice(sequence.length);
-                const key = parseKey(Buffer.from(sequence));
-                if (key.name === "ctrl+c" || key.name === "ctrl+d" || key.name === "escape") {
-                    finish(null);
-                    return;
-                }
-                if (key.name === "return") {
-                    finish(options.filter((option) => selected.has(option)));
-                    return;
-                }
-                if (key.name === "up") {
-                    redraw(() => {
-                        active = (active - 1 + options.length) % options.length;
-                    });
-                }
-                else if (key.name === "down") {
-                    redraw(() => {
-                        active = (active + 1) % options.length;
-                    });
-                }
-                else if (key.name === "space") {
-                    redraw(() => {
-                        const option = options[active];
-                        if (selected.has(option))
-                            selected.delete(option);
-                        else
-                            selected.add(option);
-                    });
-                }
-                else if (key.name === "all") {
-                    redraw(() => {
-                        for (const option of options)
-                            selected.add(option);
-                    });
-                }
-                else if (key.name === "none") {
-                    redraw(() => selected.clear());
-                }
-            }
-        }
-        stdin.on("data", onData);
+    const value = await clack.multiselect({
+        message: label,
+        options: options.map((option) => ({ value: option, label: option })),
+        initialValues: [...initialSelected],
+        required: false,
+        input: stdin,
+        output: stderr,
     });
+    if (clack.isCancel(value))
+        return null;
+    return value;
 }
 export async function promptText(label, stdin = process.stdin, stderr = process.stderr) {
-    if (!stdin.isTTY || !stderr.isTTY) {
-        throw new InstallerError("terminal_required", "This operation requires an interactive terminal");
-    }
-    stderr.write(`? ${label}\n`);
-    stderr.write("  Type a value | Enter confirm | Esc cancel\n");
-    stderr.write("> ");
-    return new Promise((resolve) => {
-        let buffer = "";
-        stdin.setRawMode(true);
-        stdin.resume();
-        function cleanup() {
-            stdin.setRawMode(false);
-            stdin.pause();
-            stdin.removeListener("data", onData);
-        }
-        function onData(data) {
-            for (const seq of data.toString()) {
-                if (seq === "\r" || seq === "\n") {
-                    cleanup();
-                    stderr.write("\n");
-                    resolve(buffer.trim() || null);
-                    return;
-                }
-                if (seq === "\x03" || seq === "\x04" || seq === "\x1b") {
-                    cleanup();
-                    stderr.write("\n");
-                    resolve(null);
-                    return;
-                }
-                if (seq === "\x7f" || seq === "\b") {
-                    if (buffer.length > 0) {
-                        buffer = buffer.slice(0, -1);
-                        stderr.write("\x1b[D \x1b[D");
-                    }
-                    continue;
-                }
-                if (seq >= " ") {
-                    buffer += seq;
-                    stderr.write(seq);
-                }
-            }
-        }
-        stdin.on("data", onData);
-    });
+    interactiveStreams(stdin, stderr);
+    const value = await clack.text({ message: label, input: stdin, output: stderr });
+    if (clack.isCancel(value))
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : null;
+}
+export async function confirmQuestion(label, stdin = process.stdin, stderr = process.stderr) {
+    interactiveStreams(stdin, stderr);
+    const value = await clack.confirm({ message: label, input: stdin, output: stderr });
+    if (clack.isCancel(value))
+        return null;
+    return value;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kisev/agentomatic",
-  "version": "11.0.0-dev.57.gb877c35a2446",
+  "version": "11.0.0-dev.58.gc136a777fcbb",
   "description": "OpenCode integration and opt-in installer for portable Agent Skills.",
   "homepage": "https://github.com/kisev/skills#readme",
   "bugs": {
@@ -49,8 +49,9 @@
     "pack:check": "node test/pack-allowlist.mjs"
   },
   "dependencies": {
-    "@kisev/memomatic": "1.0.0-dev.57.gb877c35a2446",
-    "@kisev/safe-fs": "1.0.0-dev.57.gb877c35a2446"
+    "@clack/prompts": "^1.8.1",
+    "@kisev/memomatic": "1.0.0-dev.58.gc136a777fcbb",
+    "@kisev/safe-fs": "1.0.0-dev.58.gc136a777fcbb"
   },
   "devDependencies": {
     "@opencode-ai/plugin": "1.18.29",