@kisev/agentomatic 11.0.0-dev.57.gb877c35a2446 → 11.0.0-dev.59.g0506803c61e5

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.d.ts

@@ -2,32 +2,39 @@ import { type DependencyRunner } from "./self-install.js";
 import { LifecycleError, type Scope } from "./lifecycle.js";
 export declare class ConfigSetupError extends LifecycleError {
 }
-export declare const CONFIG_TARGETS: readonly ["opencode", "tui", "kilo", "mimo"];
+export declare const CONFIG_TARGETS: readonly ["opencode", "kilo", "mimo"];
 export type ConfigTargetName = (typeof CONFIG_TARGETS)[number];
+export type TargetFileKind = "main" | "tui";
 export declare const CONFIG_FRAGMENTS: readonly [{
     readonly name: "core-plugin";
     readonly description: "Register @kisev/agentomatic in the plugin array (OpenCode only)";
     readonly targets: readonly ["opencode"];
+    readonly file: "main";
 }, {
     readonly name: "skills-state-permissions";
     readonly description: "Allow the standard skills XDG state paths without per-run prompts";
     readonly targets: readonly ["opencode", "kilo", "mimo"];
+    readonly file: "main";
 }, {
     readonly name: "lsp-preset";
     readonly description: "Add LSP servers from the shared catalog (OpenCode only)";
     readonly targets: readonly ["opencode"];
+    readonly file: "main";
 }, {
     readonly name: "secrets-guard";
     readonly description: "Deny reads and edits of common secret files";
     readonly targets: readonly ["opencode", "kilo", "mimo"];
+    readonly file: "main";
 }, {
     readonly name: "kilo-display";
     readonly description: "Expand Kilo reasoning, terminal, edit, and tool blocks";
     readonly targets: readonly ["kilo"];
+    readonly file: "main";
 }, {
     readonly name: "tui-schema";
-    readonly description: "Add the tui.json schema and stacked diffs";
-    readonly targets: readonly ["tui"];
+    readonly description: "Unify each agent TUI file: schema, theme, stacked diffs, and leader keybinds";
+    readonly targets: readonly ["opencode", "kilo", "mimo"];
+    readonly file: "tui";
 }];
 export type FragmentName = (typeof CONFIG_FRAGMENTS)[number]["name"];
 export type ConfigSetupSelection = {

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";
@@ -35,40 +37,68 @@ const SECRET_PATHS = [
 ];
 export class ConfigSetupError extends LifecycleError {
 }
-export const CONFIG_TARGETS = ["opencode", "tui", "kilo", "mimo"];
+export const CONFIG_TARGETS = ["opencode", "kilo", "mimo"];
 export const CONFIG_FRAGMENTS = [
     {
         name: "core-plugin",
         description: "Register @kisev/agentomatic in the plugin array (OpenCode only)",
         targets: ["opencode"],
+        file: "main",
     },
     {
         name: "skills-state-permissions",
         description: "Allow the standard skills XDG state paths without per-run prompts",
         targets: ["opencode", "kilo", "mimo"],
+        file: "main",
     },
     {
         name: "lsp-preset",
         description: "Add LSP servers from the shared catalog (OpenCode only)",
         targets: ["opencode"],
+        file: "main",
     },
     {
         name: "secrets-guard",
         description: "Deny reads and edits of common secret files",
         targets: ["opencode", "kilo", "mimo"],
+        file: "main",
     },
     {
         name: "kilo-display",
         description: "Expand Kilo reasoning, terminal, edit, and tool blocks",
         targets: ["kilo"],
+        file: "main",
     },
     {
         name: "tui-schema",
-        description: "Add the tui.json schema and stacked diffs",
-        targets: ["tui"],
+        description: "Unify each agent TUI file: schema, theme, stacked diffs, and leader keybinds",
+        targets: ["opencode", "kilo", "mimo"],
+        file: "tui",
     },
 ];
 const FRAGMENT_NAMES = CONFIG_FRAGMENTS.map((fragment) => fragment.name);
+const UNIFIED_TUI_KEYBINDS = {
+    command_list: "alt+p",
+    app_exit: "ctrl+d,<leader>q,<leader>й",
+    messages_first: "ctrl+g",
+    messages_last: "ctrl+alt+g",
+    editor_open: "<leader>e,<leader>у",
+    theme_list: "<leader>t,<leader>е",
+    sidebar_toggle: "<leader>b,<leader>и",
+    status_view: "<leader>s,<leader>ы",
+    session_export: "<leader>x,<leader>ч",
+    session_new: "<leader>n,<leader>т",
+    session_list: "<leader>l,<leader>д",
+    session_timeline: "<leader>g,<leader>п",
+    session_compact: "<leader>c,<leader>с",
+    model_list: "<leader>m,<leader>ь",
+    agent_list: "<leader>a,<leader>ф",
+    messages_copy: "<leader>y,<leader>н",
+    messages_undo: "<leader>u,<leader>г",
+    messages_redo: "<leader>r,<leader>к",
+    messages_toggle_conceal: "<leader>h,<leader>р",
+    tips_toggle: "<leader>h,<leader>р",
+};
 const LSP_SERVER_COMMANDS = {
     python: ["basedpyright-langserver", "--stdio"],
     typescript: ["typescript-language-server", "--stdio"],
@@ -151,20 +181,39 @@ function fragmentEdits(fragment, target, current) {
             { kind: "set-if-absent", path: ["mcp_tool_display"], value: "expanded" },
         ];
     }
+    const tuiSchemas = {
+        opencode: "https://opencode.ai/tui.json",
+        kilo: undefined,
+        mimo: "https://mimo.xiaomi.com/mimocode/tui.json",
+    };
     return [
-        { kind: "set-if-absent", path: ["$schema"], value: "https://opencode.ai/tui.json" },
+        ...(tuiSchemas[target]
+            ? [{ kind: "set-if-absent", path: ["$schema"], value: tuiSchemas[target] }]
+            : []),
+        { kind: "set-if-absent", path: ["theme"], value: "ayu" },
         { kind: "set-if-absent", path: ["diff_style"], value: "stacked" },
+        ...Object.entries(UNIFIED_TUI_KEYBINDS).map(([key, value]) => ({
+            kind: "set-if-absent",
+            path: ["keybinds", key],
+            value,
+        })),
     ];
 }
 function applicable(fragment, target) {
     const targets = CONFIG_FRAGMENTS.find((item) => item.name === fragment)?.targets ?? [];
     return targets.includes(target);
 }
+function fragmentFileKind(fragment) {
+    return CONFIG_FRAGMENTS.find((item) => item.name === fragment)?.file ?? "main";
+}
 export function normalizeConfigSelection(scope, value = {}) {
     const requestedTargets = value.targets ?? ["opencode"];
     const targets = CONFIG_TARGETS.filter((target) => requestedTargets.includes(target));
-    if (targets.length !== requestedTargets.length)
+    if (targets.length !== requestedTargets.length) {
+        if (requestedTargets.includes("tui"))
+            throw new ConfigSetupError("invalid_selection", "The tui target moved into opencode, kilo, and mimo as the tui-schema fragment");
         throw new ConfigSetupError("invalid_selection", "Unknown config target selection");
+    }
     if (scope === "project" && (targets.length !== 1 || targets[0] !== "opencode"))
         throw new ConfigSetupError("invalid_selection", "Project scope supports only the opencode target");
     const requestedFragments = value.fragments ?? [];
@@ -177,8 +226,6 @@ export async function defaultConfigSelection(scope, cwd = process.cwd(), home =
     const exists = async (path) => Boolean(await readRegular(path).catch(() => undefined));
     const targets = ["opencode"];
     if (scope === "global") {
-        if (await exists(join(home, ".config", "opencode", "tui.json")))
-            targets.push("tui");
         if (await exists(join(home, ".config", "kilo", "kilo.json")))
             targets.push("kilo");
         if (await exists(join(home, ".config", "kilo", "kilo.jsonc")))
@@ -193,9 +240,41 @@ export async function defaultConfigSelection(scope, cwd = process.cwd(), home =
         fragments: [...FRAGMENT_NAMES],
     });
 }
-async function resolveTargetFile(target, scope, cwd, home) {
+async function resolveTargetFile(target, scope, cwd, home, kind = "main") {
     const existing = async (root, path) => Boolean(await readRegular(join(root, path)).catch(() => undefined));
     const globalRoot = deploymentRoot("global", cwd, home);
+    if (kind === "tui") {
+        if (target === "kilo") {
+            const kiloRoot = join(home, ".config", "kilo");
+            for (const path of ["tui.jsonc", "tui.json"])
+                if (await existing(kiloRoot, path))
+                    return { target, root: kiloRoot, path, absolute: join(kiloRoot, path), exists: true };
+            return {
+                target,
+                root: kiloRoot,
+                path: "tui.jsonc",
+                absolute: join(kiloRoot, "tui.jsonc"),
+                exists: false,
+            };
+        }
+        if (target === "mimo") {
+            const mimoRoot = join(home, ".config", "mimocode");
+            return {
+                target,
+                root: mimoRoot,
+                path: "tui.json",
+                absolute: join(mimoRoot, "tui.json"),
+                exists: await existing(mimoRoot, "tui.json"),
+            };
+        }
+        return {
+            target,
+            root: globalRoot,
+            path: "tui.json",
+            absolute: join(globalRoot, "tui.json"),
+            exists: await existing(globalRoot, "tui.json"),
+        };
+    }
     if (target === "opencode") {
         if (scope === "global") {
             for (const path of ["opencode.json", "opencode.jsonc"])
@@ -226,14 +305,6 @@ async function resolveTargetFile(target, scope, cwd, home) {
             exists: false,
         };
     }
-    if (target === "tui")
-        return {
-            target,
-            root: globalRoot,
-            path: "tui.json",
-            absolute: join(globalRoot, "tui.json"),
-            exists: await existing(globalRoot, "tui.json"),
-        };
     if (target === "kilo") {
         const root = join(home, ".config", "kilo");
         for (const path of ["kilo.jsonc", "kilo.json"])
@@ -260,86 +331,101 @@ async function build(selection, scope, cwd = process.cwd(), home = homedir()) {
     const allowedRoots = new Set([root]);
     const files = [];
     for (const target of CONFIG_TARGETS.filter((name) => selection.targets.includes(name))) {
-        let file;
-        let current;
-        try {
-            file = await resolveTargetFile(target, scope, cwd, home);
-            current = file.exists ? await readRegular(file.absolute) : undefined;
-        }
-        catch (error) {
-            const reason = error instanceof LifecycleError ? error.message : "target is unreadable";
-            for (const fragment of selection.fragments.filter((item) => applicable(item, target)))
-                operations.push({ target, path: "unknown", fragment, operation: "conflict", reason });
-            continue;
-        }
-        if (file.exists && current === undefined) {
-            for (const fragment of selection.fragments.filter((item) => applicable(item, target)))
-                operations.push({
-                    target,
-                    path: file.absolute,
-                    fragment,
-                    operation: "conflict",
-                    reason: "target is unreadable",
-                });
-            continue;
-        }
-        files.push(file);
-        allowedRoots.add(file.root);
-        let text = current ? current.toString("utf8") : "{}\n";
-        let changed = false;
-        for (const fragment of selection.fragments) {
-            if (!applicable(fragment, target))
-                continue;
-            let parsed = undefined;
+        const kinds = ["main"];
+        const wantsTui = selection.fragments.some((fragment) => applicable(fragment, target) && fragmentFileKind(fragment) === "tui");
+        if (wantsTui && scope === "global")
+            kinds.push("tui");
+        for (const kind of kinds) {
+            let file;
+            let current;
             try {
-                parsed = parseJsonc(text);
+                file = await resolveTargetFile(target, scope, cwd, home, kind);
+                current = file.exists ? await readRegular(file.absolute) : undefined;
             }
-            catch {
-                parsed = undefined;
+            catch (error) {
+                const reason = error instanceof LifecycleError ? error.message : "target is unreadable";
+                for (const fragment of selection.fragments.filter((item) => applicable(item, target) && fragmentFileKind(item) === kind))
+                    operations.push({ target, path: "unknown", fragment, operation: "conflict", reason });
+                continue;
             }
-            try {
-                const applied = applyJsoncEdits(text, fragmentEdits(fragment, target, parsed));
-                if (applied.changed) {
-                    text = applied.text;
-                    changed = true;
+            if (file.exists && current === undefined) {
+                for (const fragment of selection.fragments.filter((item) => applicable(item, target) && fragmentFileKind(item) === kind))
                     operations.push({
                         target,
                         path: file.absolute,
                         fragment,
-                        operation: file.exists ? "update" : "create",
+                        operation: "conflict",
+                        reason: "target is unreadable",
                     });
+                continue;
+            }
+            files.push(file);
+            allowedRoots.add(file.root);
+            let text = current ? current.toString("utf8") : "{}\n";
+            let changed = false;
+            for (const fragment of selection.fragments) {
+                if (!applicable(fragment, target) || fragmentFileKind(fragment) !== kind)
+                    continue;
+                let parsed = undefined;
+                try {
+                    parsed = parseJsonc(text);
                 }
-                else {
-                    operations.push({ target, path: file.absolute, fragment, operation: "unchanged" });
+                catch {
+                    parsed = undefined;
+                }
+                try {
+                    const applied = applyJsoncEdits(text, fragmentEdits(fragment, target, parsed));
+                    if (applied.changed) {
+                        text = applied.text;
+                        changed = true;
+                        operations.push({
+                            target,
+                            path: file.absolute,
+                            fragment,
+                            operation: file.exists ? "update" : "create",
+                        });
+                    }
+                    else {
+                        operations.push({ target, path: file.absolute, fragment, operation: "unchanged" });
+                    }
+                }
+                catch (error) {
+                    operations.push({
+                        target,
+                        path: file.absolute,
+                        fragment,
+                        operation: "conflict",
+                        reason: error instanceof LifecycleError || error instanceof Error
+                            ? error.message
+                            : String(error),
+                    });
                 }
             }
-            catch (error) {
-                operations.push({
-                    target,
-                    path: file.absolute,
-                    fragment,
-                    operation: "conflict",
-                    reason: error instanceof LifecycleError || error instanceof Error
-                        ? error.message
-                        : String(error),
+            if (changed) {
+                const content = Buffer.from(text.endsWith("\n") ? text : `${text}\n`);
+                mutations.push({
+                    ...(file.root === root ? {} : { root: file.root }),
+                    path: file.path,
+                    operation: "write",
+                    content,
+                    mode: 0o644,
+                    expected: current ? { sha256: sha256(current) } : { absent: true },
                 });
             }
         }
-        if (changed) {
-            const content = Buffer.from(text.endsWith("\n") ? text : `${text}\n`);
-            mutations.push({
-                ...(file.root === root ? {} : { root: file.root }),
-                path: file.path,
-                operation: "write",
-                content,
-                mode: 0o644,
-                expected: current ? { sha256: sha256(current) } : { absent: true },
-            });
-        }
     }
     const skipped = selection.fragments
-        .filter((fragment) => !selection.targets.some((target) => applicable(fragment, target)))
-        .map((fragment) => ({ fragment, reason: "no selected target supports this fragment" }));
+        .filter((fragment) => {
+        if (fragmentFileKind(fragment) === "tui" && scope === "project")
+            return true;
+        return !selection.targets.some((target) => applicable(fragment, target));
+    })
+        .map((fragment) => ({
+        fragment,
+        reason: fragmentFileKind(fragment) === "tui" && scope === "project"
+            ? "TUI files are global-only"
+            : "no selected target supports this fragment",
+    }));
     const sorted = operations.sort((left, right) => CONFIG_TARGETS.indexOf(left.target) - CONFIG_TARGETS.indexOf(right.target) ||
         FRAGMENT_NAMES.indexOf(left.fragment) -
             FRAGMENT_NAMES.indexOf(right.fragment) ||
@@ -414,7 +500,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.59.g0506803c61e5",
   "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.59.g0506803c61e5",
+    "@kisev/safe-fs": "1.0.0-dev.59.g0506803c61e5"
   },
   "devDependencies": {
     "@opencode-ai/plugin": "1.18.29",