@kisev/agentomatic 11.0.2-dev.101.gae2702b7284e → 11.0.2-dev.103.g258eb838ddb7

package/dist/config-setup.d.ts

@@ -6,6 +6,11 @@ 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-disable";
+    readonly description: "Disconnect only the agentomatic plugin, preserving unrelated configuration";
+    readonly targets: readonly ["opencode"];
+    readonly file: "main";
+}, {
     readonly name: "core-plugin";
     readonly description: "Register @kisev/agentomatic in the plugin array (OpenCode only)";
     readonly targets: readonly ["opencode"];
@@ -72,9 +77,15 @@ export declare function recoverConfigSetup(scope: Scope, dryRun: boolean, cwd?:
 }>;
 export declare function normalizeConfigSelection(scope: Scope, value?: Partial<ConfigSetupSelection>): ConfigSetupSelection;
 export declare function defaultConfigSelection(scope: Scope, cwd?: string, home?: string): Promise<ConfigSetupSelection>;
-export declare function previewConfigSetup(selection: ConfigSetupSelection, scope: Scope, cwd?: string, home?: string, provisionDependency?: boolean): Promise<ConfigSetupPlan>;
+export declare function inspectIntegration(scope: Scope, cwd?: string, home?: string): Promise<{
+    path: string;
+    connected: boolean;
+    problem?: string;
+}>;
+export declare function previewConfigSetup(selection: ConfigSetupSelection, scope: Scope, cwd?: string, home?: string, provisionDependency?: boolean, syncSelection?: boolean): Promise<ConfigSetupPlan>;
 export declare function applyConfigSetup(selection: ConfigSetupSelection, scope: Scope, cwd?: string, home?: string, options?: {
     dependencyRunner?: DependencyRunner;
     provisionDependency?: boolean;
     receipt?: string;
+    syncSelection?: boolean;
 }): Promise<ConfigSetupPlan>;

package/dist/config-setup.js

@@ -2,13 +2,12 @@ import { randomUUID } from "node:crypto";
 import { lstat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
-import { archiveMutations } from "./installer.js";
+import { archiveMutations, coreSelectionMutation } from "./installer.js";
 import { requirePackageVersion } from "./package-metadata.js";
 import { ensureDependency, planDependency } from "./self-install.js";
 import { applyTransaction, archiveRoot, deploymentRoot, LifecycleError, lifecycleRoot, inspectTransaction, readRegular, recoverTransaction, sha256, withLifecycleLock, } from "./lifecycle.js";
 import { applyJsoncEdits, parseJsonc } from "./jsonc.js";
-import { corePluginEdits, permissionEdits } from "./opencode-config.js";
-const PACKAGE_NAME = "@kisev/agentomatic";
+import { corePluginEdits, corePluginRemovalEdits, permissionEdits, } from "./opencode-config.js";
 const XDG_STATE_GLOB = "~/.local/state/agent-skills/**";
 const OPENCODE_SKILLS_GLOB = "~/.config/opencode/skills/**";
 const AGENTS_SKILLS_GLOB = "~/.agents/skills/**";
@@ -38,6 +37,12 @@ export class ConfigSetupError extends LifecycleError {
 }
 export const CONFIG_TARGETS = ["opencode", "kilo", "mimo"];
 export const CONFIG_FRAGMENTS = [
+    {
+        name: "core-disable",
+        description: "Disconnect only the agentomatic plugin, preserving unrelated configuration",
+        targets: ["opencode"],
+        file: "main",
+    },
     {
         name: "core-plugin",
         description: "Register @kisev/agentomatic in the plugin array (OpenCode only)",
@@ -86,16 +91,43 @@ async function configSnapshot(built) {
 }
 async function requireNoRecovery(stateRoot) {
     if (await readRegular(join(stateRoot, "transaction-journal.json")))
-        throw new ConfigSetupError("recovery_required", "An interrupted transaction requires config recover --dry-run, then confirmed config recover before a fresh preview");
+        throw new ConfigSetupError("recovery_required", "An interrupted transaction requires maintenance recover --dry-run, then confirmed maintenance recover before a fresh preview");
 }
 export async function recoverConfigSetup(scope, dryRun, cwd = process.cwd(), home = homedir(), expectedDigest) {
     const root = deploymentRoot(scope, cwd, home);
     const state = lifecycleRoot(scope, cwd, home);
-    const built = await build({ targets: [...CONFIG_TARGETS], fragments: [...FRAGMENT_NAMES] }, scope, cwd, home);
-    const allowed = [...built.allowedRoots, archiveRoot(scope, cwd, home)];
-    const paths = await inspectTransaction(root, state, allowed);
     const journalPath = join(state, "transaction-journal.json");
     const journal = await readRegular(journalPath);
+    const scopeRoot = resolve(scope === "global" ? home : cwd);
+    let recoveryRoot = root;
+    if (journal) {
+        let candidate;
+        try {
+            candidate = JSON.parse(journal.toString("utf8"));
+        }
+        catch {
+            throw new ConfigSetupError("invalid_journal", "Transaction journal is not valid JSON");
+        }
+        if (candidate.root === scopeRoot && scopeRoot !== root) {
+            const prefix = scope === "global" ? ".config/opencode/" : ".opencode/";
+            if (!Array.isArray(candidate.operations) ||
+                candidate.operations.some((operation) => !operation.root && !operation.path?.startsWith(prefix)))
+                throw new ConfigSetupError("invalid_journal", "Cleanup journal contains paths outside the deployment");
+            recoveryRoot = scopeRoot;
+        }
+    }
+    const allowed = [
+        root,
+        archiveRoot(scope, cwd, home),
+        ...(scope === "project"
+            ? [resolve(cwd)]
+            : [
+                join(home, ".config", "opencode"),
+                join(home, ".config", "kilo"),
+                join(home, ".config", "mimocode"),
+            ]),
+    ];
+    const paths = await inspectTransaction(recoveryRoot, state, allowed);
     const digest = journal ? sha256(journal) : null;
     if (dryRun || !paths.length)
         return { paths, recovered: false, digest };
@@ -103,7 +135,7 @@ export async function recoverConfigSetup(scope, dryRun, cwd = process.cwd(), hom
         const current = await readRegular(journalPath);
         if (!current || !expectedDigest || sha256(current) !== expectedDigest)
             throw new ConfigSetupError("stale_receipt", "Recovery journal changed; preview recovery again");
-        return recoverTransaction(root, state, allowed);
+        return recoverTransaction(recoveryRoot, state, allowed);
     });
     return { paths, recovered, digest };
 }
@@ -168,6 +200,8 @@ function fragmentEdits(fragment, target, current) {
     if (fragment === "core-plugin") {
         return corePluginEdits(value);
     }
+    if (fragment === "core-disable")
+        return corePluginRemovalEdits(value);
     if (fragment === "skills-state-permissions") {
         const statePaths = target === "opencode"
             ? [XDG_STATE_GLOB, OPENCODE_SKILLS_GLOB, AGENTS_SKILLS_GLOB]
@@ -269,6 +303,8 @@ export function normalizeConfigSelection(scope, value = {}) {
     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 ?? [];
+    if (requestedFragments.includes("core-plugin") && requestedFragments.includes("core-disable"))
+        throw new ConfigSetupError("invalid_selection", "Choose either core-plugin or core-disable");
     const fragments = FRAGMENT_NAMES.filter((fragment) => requestedFragments.includes(fragment));
     if (fragments.length !== requestedFragments.length)
         throw new ConfigSetupError("invalid_selection", "Unknown config fragment selection");
@@ -289,9 +325,26 @@ export async function defaultConfigSelection(scope, cwd = process.cwd(), home =
     }
     return normalizeConfigSelection(scope, {
         targets: [...new Set(targets)],
-        fragments: [...FRAGMENT_NAMES],
+        fragments: FRAGMENT_NAMES.filter((name) => name !== "core-disable"),
     });
 }
+export async function inspectIntegration(scope, cwd = process.cwd(), home = homedir()) {
+    const file = await resolveTargetFile("opencode", scope, cwd, home);
+    const raw = await readRegular(file.absolute);
+    if (!raw)
+        return { path: file.absolute, connected: false };
+    try {
+        const current = parseJsonc(raw.toString("utf8"));
+        return { path: file.absolute, connected: corePluginRemovalEdits(current).length > 0 };
+    }
+    catch (error) {
+        return {
+            path: file.absolute,
+            connected: false,
+            problem: error instanceof Error ? error.message : "Invalid configuration",
+        };
+    }
+}
 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);
@@ -376,7 +429,7 @@ async function resolveTargetFile(target, scope, cwd, home, kind = "main") {
         exists: false,
     };
 }
-async function build(selection, scope, cwd = process.cwd(), home = homedir()) {
+async function build(selection, scope, cwd = process.cwd(), home = homedir(), syncSelection = true) {
     const root = deploymentRoot(scope, cwd, home);
     const operations = [];
     const mutations = [];
@@ -492,6 +545,23 @@ async function build(selection, scope, cwd = process.cwd(), home = homedir()) {
             ? "TUI files are global-only"
             : "no selected target supports this fragment",
     }));
+    const core = selection.fragments.find((fragment) => fragment === "core-plugin" || fragment === "core-disable");
+    if (syncSelection &&
+        core &&
+        selection.targets.includes("opencode") &&
+        !operations.some((operation) => operation.fragment === core && operation.operation === "conflict")) {
+        const mutation = await coreSelectionMutation(root, core === "core-plugin");
+        if (mutation) {
+            mutations.push(mutation);
+            operations.push({
+                target: "opencode",
+                path: join(root, mutation.path),
+                fragment: core,
+                operation: "update",
+                reason: "Save connection choice for repeat install and repair",
+            });
+        }
+    }
     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) ||
@@ -519,11 +589,11 @@ async function build(selection, scope, cwd = process.cwd(), home = homedir()) {
         allowedRoots: [...allowedRoots],
     };
 }
-export async function previewConfigSetup(selection, scope, cwd = process.cwd(), home = homedir(), provisionDependency = true) {
+export async function previewConfigSetup(selection, scope, cwd = process.cwd(), home = homedir(), provisionDependency = true, syncSelection = true) {
     const stateRoot = lifecycleRoot(scope, cwd, home);
     try {
         await requireNoRecovery(stateRoot);
-        const built = await build(selection, scope, cwd, home);
+        const built = await build(selection, scope, cwd, home, syncSelection);
         if (provisionDependency &&
             selection.fragments.includes("core-plugin") &&
             selection.targets.includes("opencode"))
@@ -535,6 +605,7 @@ export async function previewConfigSetup(selection, scope, cwd = process.cwd(),
             resolve(cwd),
             resolve(home),
             provisionDependency,
+            syncSelection,
         ]);
         for (const [id, prior] of configReceipts)
             if (prior.key === key || prior.expires < Date.now())
@@ -560,7 +631,8 @@ export async function applyConfigSetup(selection, scope, cwd = process.cwd(), ho
     try {
         return await withLifecycleLock(stateRoot, async () => {
             await requireNoRecovery(stateRoot);
-            const built = await build(selection, scope, cwd, home);
+            const syncSelection = options.syncSelection !== false;
+            const built = await build(selection, scope, cwd, home, syncSelection);
             const provisionDependency = options.provisionDependency !== false;
             if (provisionDependency &&
                 selection.fragments.includes("core-plugin") &&
@@ -572,6 +644,7 @@ export async function applyConfigSetup(selection, scope, cwd = process.cwd(), ho
                 resolve(cwd),
                 resolve(home),
                 provisionDependency,
+                syncSelection,
             ]);
             const id = options.receipt ?? [...configReceipts].find(([, entry]) => entry.key === key)?.[0];
             const receipt = id ? configReceipts.get(id) : undefined;

package/dist/doctor.js

@@ -447,7 +447,9 @@ export async function collectDoctorFacts(scope, cwd = process.cwd(), home = home
         collisions: inventory?.collisions.length ?? 0,
         drift: inventory?.drift.length ?? 0,
         user_owned: inventory?.user_owned.length ?? 0,
-    }, ["Review collisions and run agent reconcile only after explicit confirmation."]));
+    }, [
+        "Resolve ownership conflicts and restore modified bytes; preview maintenance repair for missing selected files.",
+    ]));
     const config = await localConfig(scope, project, homeRoot);
     if (config.incomplete)
         partial.push("config.local");

package/dist/installer.d.ts

@@ -1,3 +1,4 @@
+import { type AgentProfileRequest } from "./agent-profiles.js";
 import { LifecycleError, type FileMutation, type Scope, type TransactionOptions } from "./lifecycle.js";
 import { CATALOG } from "./catalog.js";
 import { type FixedAgentRole } from "./agent-profiles.js";
@@ -30,6 +31,7 @@ export type Plan = {
         applied?: "changed" | "unchanged" | "skipped";
     };
     requires_restart: boolean;
+    digest: string;
 };
 export type ArchiveCandidate = {
     path: string;
@@ -44,12 +46,15 @@ export type ArchiveCandidate = {
 export declare const SELECTABLE_PLUGINS: SelectablePlugin[];
 export declare const SKILL_COMMANDS: string[];
 export declare function defaultSelection(): InstallerSelection;
+export declare function installedSelection(scope: Scope, cwd?: string, home?: string): Promise<InstallerSelection | null>;
+export declare function coreSelectionMutation(root: string, enabled: boolean): Promise<FileMutation | undefined>;
 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, 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 preview(action: Action, scope: Scope, cwd?: string, home?: string, selection?: Partial<InstallerSelection>, provisionDependency?: boolean, profileChanges?: AgentProfileRequest[]): Promise<Plan>;
 export declare function apply(action: Action, scope: Scope, cwd?: string, home?: string, options?: TransactionOptions & {
     dependencyRunner?: DependencyRunner;
-}, selection?: Partial<InstallerSelection>, provisionDependency?: boolean): Promise<Plan>;
+    expectedDigest?: string;
+}, selection?: Partial<InstallerSelection>, provisionDependency?: boolean, profileChanges?: AgentProfileRequest[]): Promise<Plan>;
 export declare function result(plan: Plan, applied: boolean): string;

package/dist/installer.js

@@ -4,7 +4,7 @@ import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { buildAgentProfilePlan, listAgentProfiles, validateBuiltAgentProfilePlan, } from "./agent-profiles.js";
-import { applyTransaction, archiveRoot, deploymentRoot, destination, LifecycleError, lifecycleRoot, migrateLegacyDeploymentNamespace, migrateLegacyNamespaces, readRegular, recoverTransaction, sha256, stable, withLifecycleLock, } from "./lifecycle.js";
+import { applyTransaction, archiveRoot, deploymentRoot, destination, LifecycleError, lifecycleRoot, migrateLegacyDeploymentNamespace, migrateLegacyNamespaces, readRegular, sha256, stable, withLifecycleLock, } from "./lifecycle.js";
 import { CATALOG } from "./catalog.js";
 import { FIXED_AGENT_ROLES } from "./agent-profiles.js";
 import { readPackageVersion } from "./package-metadata.js";
@@ -33,6 +33,29 @@ export function defaultSelection() {
         core_activation: true,
     };
 }
+export async function installedSelection(scope, cwd = process.cwd(), home = homedir()) {
+    const { manifest } = await currentManifest(deploymentRoot(scope, cwd, home));
+    return manifest
+        ? normalizeSelection({
+            commands: manifest.commands,
+            agents: manifest.agents,
+            plugins: manifest.plugins,
+            core_activation: manifest.core_activation,
+        })
+        : null;
+}
+export async function coreSelectionMutation(root, enabled) {
+    const owned = await currentManifest(root);
+    if (!owned.manifest || !owned.raw || owned.manifest.core_activation === enabled)
+        return undefined;
+    return {
+        path: MANIFEST_NAME,
+        operation: "write",
+        content: Buffer.from(`${stable({ ...owned.manifest, core_activation: enabled })}\n`),
+        mode: 0o600,
+        expected: { sha256: sha256(owned.raw) },
+    };
+}
 export function normalizeSelection(value = {}) {
     const allCommands = new Set(SKILL_COMMANDS);
     const commands = [...new Set(value.commands ?? defaultSelection().commands)].sort();
@@ -325,7 +348,7 @@ function asLegacy(manifest) {
         ? manifest
         : undefined;
 }
-async function build(action, scope, cwd = process.cwd(), home = homedir(), requestedSelection, provisionDependency = true) {
+async function build(action, scope, cwd = process.cwd(), home = homedir(), requestedSelection, provisionDependency = true, profileChanges = []) {
     const root = deploymentRoot(scope, cwd, home);
     const owned = await currentManifest(root);
     const selection = normalizeSelection(requestedSelection ??
@@ -346,7 +369,7 @@ async function build(action, scope, cwd = process.cwd(), home = homedir(), reque
             manifestSha256: sha256(owned.raw),
         }
         : undefined;
-    const profiles = await buildAgentProfilePlan({ action }, scope, cwd, home, legacyRecord, selection.agents);
+    const profiles = await buildAgentProfilePlan({ action, changes: profileChanges }, scope, cwd, home, legacyRecord, selection.agents);
     const dependency = action === "install" && provisionDependency && selection.core_activation
         ? planDependency(scope, cwd, home)
         : undefined;
@@ -628,24 +651,23 @@ async function build(action, scope, cwd = process.cwd(), home = homedir(), reque
                 item.path.startsWith("plugins/")),
     };
     return {
-        plan: { ...base },
+        plan: {
+            ...base,
+            digest: sha256(stable({ base, mutations, manifest: owned.raw, profiles: profiles.plan.digest })),
+        },
         mutations,
         expectedManifest: manifestContent,
         profiles,
     };
 }
-export async function preview(action, scope, cwd = process.cwd(), home = homedir(), selection, provisionDependency = true) {
-    // Infrastructure normalization like stale-lock reclamation: idempotent,
-    // preserves every legacy byte, and never touches user configuration.
-    await migrateLegacyNamespaces(home);
+export async function preview(action, scope, cwd = process.cwd(), home = homedir(), selection, provisionDependency = true, profileChanges = []) {
+    // Preview never migrates namespaces, creates locks, or recovers transactions.
     const stateRoot = lifecycleRoot(scope, cwd, home);
-    const root = deploymentRoot(scope, cwd, home);
     try {
-        return await withLifecycleLock(stateRoot, async () => {
-            if (await recoverTransaction(root, stateRoot, [archiveRoot(scope, cwd, home)]))
-                throw new InstallerError("recovered_transaction", "Recovered an interrupted transaction; request a fresh plan");
-            return (await build(action, scope, cwd, home, selection, provisionDependency)).plan;
-        });
+        if (await readRegular(join(stateRoot, "transaction-journal.json")))
+            throw new InstallerError("recovery_required", "Run maintenance recover before a fresh preview");
+        return (await build(action, scope, cwd, home, selection, provisionDependency, profileChanges))
+            .plan;
     }
     catch (error) {
         if (error instanceof InstallerError)
@@ -655,7 +677,7 @@ export async function preview(action, scope, cwd = process.cwd(), home = homedir
         throw error;
     }
 }
-export async function apply(action, scope, cwd = process.cwd(), home = homedir(), options = {}, selection, provisionDependency = true) {
+export async function apply(action, scope, cwd = process.cwd(), home = homedir(), options = {}, selection, provisionDependency = true, profileChanges = []) {
     const { dependencyRunner, ...transactionOptions } = options;
     const stateRoot = lifecycleRoot(scope, cwd, home);
     const root = deploymentRoot(scope, cwd, home);
@@ -663,9 +685,11 @@ export async function apply(action, scope, cwd = process.cwd(), home = homedir()
     try {
         return await withLifecycleLock(stateRoot, async () => {
             await migrateLegacyDeploymentNamespace(root);
-            if (await recoverTransaction(root, stateRoot, [archiveRoot(scope, cwd, home)]))
-                throw new InstallerError("recovered_transaction", "Recovered an interrupted transaction; request a fresh plan");
-            const built = await build(action, scope, cwd, home, selection, provisionDependency);
+            if (await readRegular(join(stateRoot, "transaction-journal.json")))
+                throw new InstallerError("recovery_required", "Run maintenance recover before a fresh preview");
+            const built = await build(action, scope, cwd, home, selection, provisionDependency, profileChanges);
+            if (options.expectedDigest && built.plan.digest !== options.expectedDigest)
+                throw new InstallerError("stale_plan", "Installation changed; request a fresh preview");
             if (built.plan.operations.some((item) => item.operation === "conflict" &&
                 (item.reason === "unmanaged_file" ||
                     item.reason === "v1.0.0_agent_ownership_mismatch" ||
@@ -689,7 +713,7 @@ export async function apply(action, scope, cwd = process.cwd(), home = homedir()
                             inventory.drift.length ||
                             inventory.profiles
                                 .filter((item) => item.ownership !== "user-owned")
-                                .some((item) => item.state !== "current"))) {
+                                .some((item) => item.state !== "current" && item.state !== "not-installed"))) {
                         throw new InstallerError("final_validation_failed", "Final installed agent inventory is invalid");
                     }
                 },

package/dist/opencode-config.d.ts

@@ -6,4 +6,5 @@ export type PermissionRule = {
 };
 export declare function permissionEdits(config: Record<string, unknown>, additions: PermissionRule[]): JsoncEdit[];
 export declare function matchesWildcard(pattern: string, value: string): boolean;
+export declare function corePluginRemovalEdits(config: Record<string, unknown>): JsoncEdit[];
 export declare function corePluginEdits(config: Record<string, unknown>): JsoncEdit[];

package/dist/opencode-config.js

@@ -122,6 +122,18 @@ function ourEntry(entry) {
         return OUR_PACKAGE.test(entry);
     return object(entry) && typeof entry.package === "string" && OUR_PACKAGE.test(entry.package);
 }
+export function corePluginRemovalEdits(config) {
+    return ["plugin", "plugins"].flatMap((key) => {
+        if (!(key in config))
+            return [];
+        plugins(config[key], key === "plugin");
+        const entries = config[key];
+        const remaining = entries.filter((entry) => !ourEntry(Array.isArray(entry) ? entry[0] : entry));
+        return remaining.length === entries.length
+            ? []
+            : [{ kind: "set-value", path: [key], value: remaining }];
+    });
+}
 export function corePluginEdits(config) {
     const edits = [
         { kind: "set-if-absent", path: ["$schema"], value: "https://opencode.ai/config.json" },

package/dist/reconcile.d.ts

@@ -27,13 +27,16 @@ export type ReconcilePlan = {
         sha256?: string;
     }>;
     confirmable: boolean;
+    digest: string;
 };
 export type ReconcileResult = {
     status: "ok";
     applied: true;
     plan: ReconcilePlan;
 };
-export type ReconcileOptions = TransactionOptions;
+export type ReconcileOptions = TransactionOptions & {
+    expectedDigest?: string;
+};
 export declare class ReconcileError extends LifecycleError {
 }
 export declare function previewReconcile(scope: Scope, cwd?: string, home?: string): Promise<ReconcilePlan>;

package/dist/reconcile.js

@@ -3,7 +3,7 @@ import { lstat, readdir, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
-import { applyTransaction, archiveRoot, assertSafePath, destination, LifecycleError, lifecycleRoot, recoverTransaction, sha256, stable, withLifecycleLock, } from "./lifecycle.js";
+import { applyTransaction, assertSafePath, destination, LifecycleError, lifecycleRoot, readRegular, sha256, stable, withLifecycleLock, } from "./lifecycle.js";
 import { archiveMutations } from "./installer.js";
 const PACKAGE_NAME = "@kisev/agentomatic";
 const GENERIC_MANIFEST = ".agentomatic-manifest.json";
@@ -35,9 +35,6 @@ function loadInventory() {
 function scopeRoot(scope, cwd, home) {
     return scope === "global" ? resolve(home) : resolve(cwd);
 }
-function reconcileAllowedRoots(scope, cwd, home) {
-    return [archiveRoot(scope, cwd, home)];
-}
 function relativePath(root, target) {
     const value = relative(resolve(root), resolve(target));
     if (!value || value.startsWith(`..${sep}`) || value === "..")
@@ -398,22 +395,19 @@ async function build(scope, cwd = process.cwd(), home = homedir()) {
         groups["modified-managed"].length === 0 &&
         groups.conflict.length === 0;
     return {
-        plan: { ...base, confirmable },
+        plan: { ...base, confirmable, digest: sha256(stable({ base, mutations })) },
         mutations,
     };
 }
 export async function previewReconcile(scope, cwd = process.cwd(), home = homedir()) {
     const stateRoot = lifecycleRoot(scope, cwd, home);
-    const root = scopeRoot(scope, cwd, home);
     try {
-        return await withLifecycleLock(stateRoot, async () => {
-            if (await recoverTransaction(root, stateRoot, reconcileAllowedRoots(scope, cwd, home)))
-                throw new ReconcileError("recovered_transaction", "Recovered an interrupted transaction; request a fresh plan");
-            const built = await build(scope, cwd, home);
-            const blocked = built.plan.modified_managed.length > 0 || built.plan.conflicts.length > 0;
-            const actionable = built.plan.operations.length > 0;
-            return { ...built.plan, confirmable: !blocked && actionable };
-        });
+        if (await readRegular(join(stateRoot, "transaction-journal.json")))
+            throw new ReconcileError("recovery_required", "Run maintenance recover before a fresh preview");
+        const built = await build(scope, cwd, home);
+        const blocked = built.plan.modified_managed.length > 0 || built.plan.conflicts.length > 0;
+        const actionable = built.plan.operations.length > 0;
+        return { ...built.plan, confirmable: !blocked && actionable };
     }
     catch (error) {
         if (error instanceof ReconcileError)
@@ -432,9 +426,11 @@ export async function applyReconcile(scope, cwd = process.cwd(), home = homedir(
     const root = scopeRoot(scope, cwd, home);
     try {
         return await withLifecycleLock(stateRoot, async () => {
-            if (await recoverTransaction(root, stateRoot, reconcileAllowedRoots(scope, cwd, home)))
-                throw new ReconcileError("recovered_transaction", "Recovered an interrupted transaction; request a fresh plan");
+            if (await readRegular(join(stateRoot, "transaction-journal.json")))
+                throw new ReconcileError("recovery_required", "Run maintenance recover before a fresh preview");
             const built = await build(scope, cwd, home);
+            if (options.expectedDigest && options.expectedDigest !== built.plan.digest)
+                throw new ReconcileError("stale_plan", "Cleanup sources changed; request a fresh preview");
             if (built.plan.conflicts.length || built.plan.modified_managed.length)
                 throw new ReconcileError("conflict", "Reconcile contains unsafe ownership conflicts");
             await applyTransaction(root, stateRoot, built.mutations, {

package/dist/self-install.d.ts

@@ -24,3 +24,10 @@ export declare function planDependency(scope: "project" | "global", cwd?: string
 export declare function ensureDependency(plan: DependencyPlan, runner?: DependencyRunner): Promise<DependencyPlan & {
     applied: "changed" | "unchanged" | "skipped";
 }>;
+export type DependencyRemovalPlan = {
+    dir: string | null;
+    names: string[];
+    sources: Record<string, string | null>;
+};
+export declare function previewDependencyRemoval(scope: "project" | "global", cwd?: string, home?: string): Promise<DependencyRemovalPlan>;
+export declare function removeDependency(plan: DependencyRemovalPlan, runner?: DependencyRunner): Promise<void>;

package/dist/self-install.js

@@ -3,7 +3,8 @@ import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { promisify } from "node:util";
-import { LifecycleError, writeAtomic } from "@kisev/safe-fs";
+import { LifecycleError, writeAtomic, readRegular } from "@kisev/safe-fs";
+import { sha256 } from "./lifecycle.js";
 import { requirePackageVersion } from "./package-metadata.js";
 const execFileAsync = promisify(execFile);
 export const SELF_PACKAGE_NAME = "@kisev/agentomatic";
@@ -127,3 +128,53 @@ export async function ensureDependency(plan, runner = execFileAsync) {
     }
     return { ...plan, applied: "changed", ...(removedLegacy ? { removed_legacy: true } : {}) };
 }
+export async function previewDependencyRemoval(scope, cwd = process.cwd(), home = homedir()) {
+    const dir = owningProjectDir(scope, cwd, home);
+    if (!dir)
+        return { dir, names: [], sources: {} };
+    const sources = {};
+    for (const name of ["package.json", "package-lock.json"]) {
+        const raw = await readRegular(join(dir, name));
+        sources[name] = raw ? sha256(raw) : null;
+    }
+    const raw = await readRegular(join(dir, "package.json"));
+    if (!raw)
+        return { dir, names: [], sources };
+    let parsed;
+    try {
+        parsed = JSON.parse(raw.toString("utf8"));
+    }
+    catch {
+        throw new SelfInstallError("invalid_configuration", "Cannot inspect dependency removal: invalid package.json");
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        throw new SelfInstallError("invalid_configuration", "Cannot inspect dependency removal: package.json must be an object");
+    const names = [SELF_PACKAGE_NAME, LEGACY_SELF_PACKAGE_NAME].filter((name) => ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"].some((key) => {
+        const section = parsed[key];
+        return section && typeof section === "object" && name in section;
+    }));
+    return { dir, names, sources };
+}
+export async function removeDependency(plan, runner = execFileAsync) {
+    if (!plan.dir || !plan.names.length)
+        return;
+    for (const [name, expected] of Object.entries(plan.sources)) {
+        const raw = await readRegular(join(plan.dir, name));
+        if ((raw ? sha256(raw) : null) !== expected)
+            throw new SelfInstallError("stale_plan", "npm files changed; preview uninstall again");
+    }
+    try {
+        await runner("npm", ["rm", ...plan.names, "--no-audit", "--no-fund"], {
+            cwd: plan.dir,
+            timeout: NPM_INSTALL_TIMEOUT_MS,
+        });
+        const raw = await readRegular(join(plan.dir, "package.json"));
+        const parsed = raw ? JSON.parse(raw.toString("utf8")) : undefined;
+        if (!parsed ||
+            plan.names.some((name) => ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"].some((key) => parsed[key] && name in parsed[key])))
+            throw new Error("npm did not remove the selected dependencies");
+    }
+    catch {
+        throw new SelfInstallError("npm_dependency_failed", "npm removal failed after local stages; inspect package.json and retry uninstall --remove-dependency");
+    }
+}

package/dist/terminal-wizard.d.ts

@@ -2,4 +2,4 @@ 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>;
+export declare function confirmQuestion(label: string, stdin?: Readable, stderr?: Writable, initialValue?: boolean): Promise<boolean | null>;

package/dist/terminal-wizard.js

@@ -55,9 +55,9 @@ export async function promptText(label, stdin = process.stdin, stderr = process.
     const trimmed = value.trim();
     return trimmed.length ? trimmed : null;
 }
-export async function confirmQuestion(label, stdin = process.stdin, stderr = process.stderr) {
+export async function confirmQuestion(label, stdin = process.stdin, stderr = process.stderr, initialValue = true) {
     interactiveStreams(stdin, stderr);
-    const value = await clack.confirm({ message: label, input: stdin, output: stderr });
+    const value = await clack.confirm({ message: label, input: stdin, output: stderr, initialValue });
     if (clack.isCancel(value))
         return null;
     return value;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kisev/agentomatic",
-  "version": "11.0.2-dev.101.gae2702b7284e",
+  "version": "11.0.2-dev.103.g258eb838ddb7",
   "description": "OpenCode integration and opt-in installer for portable Agent Skills.",
   "homepage": "https://github.com/kisev/skills#readme",
   "bugs": {
@@ -40,13 +40,13 @@
   },
   "scripts": {
     "build": "node scripts/clean-dist.mjs && tsc --project tsconfig.json && node dist/generate-assets.js",
-    "test": "node --test test/agent-profiles.test.mjs test/config-setup.test.mjs test/legacy-migration.test.mjs test/doctor.test.mjs test/package.test.mjs test/rtk.test.mjs test/self-install.test.mjs test/stage19.test.mjs test/surface-coverage.test.mjs test/opencode-compatibility.test.mjs",
+    "test": "node --test test/agent-profiles.test.mjs test/command-cli.test.mjs test/config-setup.test.mjs test/legacy-migration.test.mjs test/doctor.test.mjs test/package.test.mjs test/rtk.test.mjs test/self-install.test.mjs test/stage19.test.mjs test/surface-coverage.test.mjs test/opencode-compatibility.test.mjs",
     "smoke": "node test/smoke.mjs",
     "pack:check": "node test/pack-allowlist.mjs"
   },
   "dependencies": {
     "@clack/prompts": "^1.8.1",
-    "@kisev/safe-fs": "1.0.0-dev.101.gae2702b7284e",
+    "@kisev/safe-fs": "1.0.0-dev.103.g258eb838ddb7",
     "commander": "15.0.0",
     "zod": "4.1.8"
   },