@kisev/agentomatic 11.0.2 → 12.0.0-dev.113.g1bd7385234c6

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";
@@ -15,8 +15,11 @@ const LEGACY_MANIFEST_NAME = ".skills-opencode-manifest.json";
 const LEGACY_PACKAGE_NAME = "@kisev/skills-opencode";
 const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const assetsRoot = resolve(packageRoot, "dist", "assets");
+function migrationInventory() {
+    return JSON.parse(readFileSync(resolve(assetsRoot, "migration-inventory.json"), "utf8"));
+}
 function retiredAssetPaths() {
-    const inventory = JSON.parse(readFileSync(resolve(assetsRoot, "migration-inventory.json"), "utf8"));
+    const inventory = migrationInventory();
     return new Set([
         ...Object.keys(inventory.retired_command_hashes ?? {}),
         ...Object.keys(inventory.retired_plugin_hashes ?? {}),
@@ -33,6 +36,49 @@ export function defaultSelection() {
         core_activation: true,
     };
 }
+const RENAME_CHAIN_LIMIT = 8;
+function migrateSavedCommand(renamed, name) {
+    let current = name;
+    for (let depth = 0; depth < RENAME_CHAIN_LIMIT; depth += 1) {
+        const replacement = renamed[current];
+        if (replacement === undefined)
+            return current;
+        current = replacement;
+    }
+    return current;
+}
+export function savedSelection(manifest) {
+    const renamed = migrationInventory().renamed ?? {};
+    const requested = (manifest.commands ?? defaultSelection().commands).map((name) => migrateSavedCommand(renamed, name));
+    const commands = requested.filter((name) => SKILL_COMMANDS.includes(name));
+    const agents = (manifest.agents ?? FIXED_AGENT_ROLES).filter((role) => FIXED_AGENT_ROLES.includes(role));
+    const plugins = (manifest.plugins ?? ["rtk"]).filter((plugin) => SELECTABLE_PLUGINS.includes(plugin));
+    if (requested.join("\0") !== commands.join("\0"))
+        process.stderr.write(`Saved selection migrated to the current catalog: ${requested.join(", ")} -> ${commands.join(", ") || "none"}\n`);
+    return { commands, agents, plugins };
+}
+export async function installedSelection(scope, cwd = process.cwd(), home = homedir(), overrides = {}) {
+    const { manifest } = await currentManifest(deploymentRoot(scope, cwd, home));
+    return manifest
+        ? normalizeSelection({
+            ...savedSelection(manifest),
+            core_activation: manifest.core_activation,
+            ...overrides,
+        })
+        : 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,15 +371,13 @@ 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 ??
         (owned.manifest
             ? {
-                commands: owned.manifest.commands,
-                agents: owned.manifest.agents,
-                plugins: owned.manifest.plugins,
+                ...savedSelection(owned.manifest),
                 core_activation: owned.manifest.core_activation,
             }
             : undefined));
@@ -346,7 +390,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 +672,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 +698,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 +706,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 +734,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/jsonc.d.ts

@@ -30,7 +30,23 @@ export type JsoncPath = Array<string | number>;
 export type JsoncEdit = {
     kind: "append-unique";
     path: JsoncPath;
-    value: string;
+    value: unknown;
+} | {
+    kind: "insert-before";
+    path: JsoncPath;
+    before: unknown;
+    value: unknown;
+} | {
+    kind: "set-value";
+    path: JsoncPath;
+    value: unknown;
+} | {
+    kind: "rename-key";
+    path: JsoncPath;
+    to: string;
+} | {
+    kind: "remove-key";
+    path: JsoncPath;
 } | {
     kind: "replace-array-value";
     path: JsoncPath;
@@ -45,7 +61,7 @@ export type JsoncEdit = {
     path: JsoncPath;
     entries: Record<string, string>;
 };
-export type JsoncEditResult = "created" | "present" | "appended" | "replaced" | "widened";
+export type JsoncEditResult = "created" | "present" | "appended" | "inserted" | "replaced" | "widened";
 export declare function nodeToValue(node: Node): unknown;
 export declare function parseJsonc(text: string): unknown;
 export declare function applyJsoncEdits(text: string, edits: readonly JsoncEdit[]): {

package/dist/jsonc.js

@@ -143,6 +143,9 @@ function parseObject(parser) {
             parser.cursor += 1;
             trailingComma = true;
         }
+        else if (next && !(next.type === "punct" && next.raw === "}")) {
+            throw new JsoncError("invalid_jsonc", `Expected comma at offset ${next.start}`);
+        }
     }
     if (!closed)
         throw new JsoncError("invalid_jsonc", `Unterminated object at offset ${open.start}`);
@@ -180,6 +183,9 @@ function parseArray(parser) {
             parser.cursor += 1;
             trailingComma = true;
         }
+        else if (next && !(next.type === "punct" && next.raw === "]")) {
+            throw new JsoncError("invalid_jsonc", `Expected comma at offset ${next.start}`);
+        }
     }
     if (!closed)
         throw new JsoncError("invalid_jsonc", `Unterminated array at offset ${open.start}`);
@@ -200,7 +206,12 @@ export function nodeToValue(node) {
         return node.items.map(nodeToValue);
     const value = {};
     for (const key of node.propOrder)
-        value[key] = nodeToValue(node.props.get(key));
+        Object.defineProperty(value, key, {
+            value: nodeToValue(node.props.get(key)),
+            writable: true,
+            configurable: true,
+            enumerable: true,
+        });
     return value;
 }
 function parseDocument(text) {
@@ -278,16 +289,83 @@ function requireObjectPath(text, root, path) {
     return { text: currentText, node };
 }
 function applyEdit(text, root, edit) {
+    if (edit.kind === "rename-key" || edit.kind === "remove-key") {
+        const key = edit.path.at(-1);
+        const parent = resolve(root, edit.path.slice(0, -1));
+        if (typeof key !== "string" || !parent || parent.kind !== "object")
+            throw new JsoncError("conflict", "Key edit requires an object parent");
+        const target = parent.props.get(key);
+        if (!target)
+            return { text, result: "present" };
+        const index = parent.propOrder.indexOf(key);
+        const previous = index ? parent.props.get(parent.propOrder[index - 1]) : undefined;
+        const tokens = tokenize(text).filter((token) => token.start >= (previous?.end ?? parent.start + 1) && token.end <= target.start);
+        const keyToken = tokens.find((token) => token.type === "string");
+        if (!keyToken)
+            throw new JsoncError("conflict", "Object key token is unavailable");
+        if (edit.kind === "rename-key") {
+            if (parent.props.has(edit.to))
+                throw new JsoncError("conflict", `Destination key already exists: ${edit.to}`);
+            return {
+                text: text.slice(0, keyToken.start) + JSON.stringify(edit.to) + text.slice(keyToken.end),
+                result: "replaced",
+            };
+        }
+        const following = tokenize(text).find((token) => token.start >= target.end && token.type !== "ws" && token.type !== "comment");
+        const start = following?.raw === "," || !previous ? keyToken.start : previous.end;
+        const end = following?.raw === "," ? following.end : target.end;
+        const comments = tokenize(text.slice(start, end))
+            .filter((token) => token.type === "comment")
+            .map((token) => `${token.raw}\n`)
+            .join("");
+        return { text: text.slice(0, start) + comments + text.slice(end), result: "replaced" };
+    }
+    if (edit.kind === "set-value") {
+        const target = resolve(root, edit.path);
+        if (!target)
+            return applyEdit(text, root, { ...edit, kind: "set-if-absent" });
+        if (JSON.stringify(nodeToValue(target)) === JSON.stringify(edit.value))
+            return { text, result: "present" };
+        const comments = tokenize(text.slice(target.start, target.end))
+            .filter((token) => token.type === "comment")
+            .map((token) => `${token.raw}\n${lineIndent(text, target.start)}`)
+            .join("");
+        return {
+            text: text.slice(0, target.start) +
+                comments +
+                serialize(edit.value, lineIndent(text, target.start)) +
+                text.slice(target.end),
+            result: "replaced",
+        };
+    }
     if (edit.kind === "append-unique") {
         const target = resolve(root, edit.path);
         if (!target || target.kind !== "array")
             throw new JsoncError("conflict", "append-unique target is missing or not an array");
-        if (target.items.map(nodeToValue).includes(edit.value))
+        if (target.items
+            .map(nodeToValue)
+            .some((value) => JSON.stringify(value) === JSON.stringify(edit.value)))
             return { text, result: "present" };
         const insertion = target.empty ? JSON.stringify(edit.value) : `, ${JSON.stringify(edit.value)}`;
         const at = target.empty ? target.start + 1 : target.items.at(-1).end;
         return { text: text.slice(0, at) + insertion + text.slice(at), result: "appended" };
     }
+    if (edit.kind === "insert-before") {
+        const target = resolve(root, edit.path);
+        if (!target || target.kind !== "array")
+            throw new JsoncError("conflict", "insert-before target is missing or not an array");
+        const items = target.items.map(nodeToValue);
+        if (items.some((value) => JSON.stringify(value) === JSON.stringify(edit.value)))
+            return { text, result: "present" };
+        const anchor = items.findIndex((value) => JSON.stringify(value) === JSON.stringify(edit.before));
+        if (anchor === -1)
+            throw new JsoncError("conflict", "insert-before anchor item is missing from the array");
+        const node = target.items[anchor];
+        return {
+            text: text.slice(0, node.start) + `${JSON.stringify(edit.value)}, ` + text.slice(node.start),
+            result: "inserted",
+        };
+    }
     if (edit.kind === "replace-array-value") {
         const target = resolve(root, edit.path);
         if (!target || target.kind !== "array")
@@ -369,12 +447,38 @@ function at(value, path) {
         : undefined, value);
 }
 function verifyEdit(before, after, edit) {
+    if (edit.kind === "set-value") {
+        if (JSON.stringify(at(after, edit.path)) !== JSON.stringify(edit.value))
+            throw new JsoncError("merge_validation_failed", "set-value postcondition failed");
+        return;
+    }
+    if (edit.kind === "rename-key" || edit.kind === "remove-key") {
+        if (at(after, edit.path) !== undefined)
+            throw new JsoncError("merge_validation_failed", "Old key remains after key edit");
+        if (edit.kind === "rename-key" &&
+            JSON.stringify(at(before, edit.path)) !==
+                JSON.stringify(at(after, [...edit.path.slice(0, -1), edit.to])))
+            throw new JsoncError("merge_validation_failed", "Renamed key lost its value");
+        return;
+    }
     if (edit.kind === "append-unique") {
         const target = at(after, edit.path);
-        if (!Array.isArray(target) || !target.includes(edit.value))
+        if (!Array.isArray(target) ||
+            !target.some((value) => JSON.stringify(value) === JSON.stringify(edit.value)))
             throw new JsoncError("merge_validation_failed", "append-unique postcondition failed");
         return;
     }
+    if (edit.kind === "insert-before") {
+        const target = at(after, edit.path);
+        if (!Array.isArray(target))
+            throw new JsoncError("merge_validation_failed", "insert-before postcondition failed");
+        const serialized = target.map((value) => JSON.stringify(value));
+        const value = serialized.indexOf(JSON.stringify(edit.value));
+        const anchor = serialized.indexOf(JSON.stringify(edit.before));
+        if (value === -1 || anchor === -1 || value > anchor)
+            throw new JsoncError("merge_validation_failed", "insert-before postcondition failed");
+        return;
+    }
     if (edit.kind === "replace-array-value") {
         const beforeTarget = at(before, edit.path);
         const afterTarget = at(after, edit.path);
@@ -419,12 +523,12 @@ function verifyEdit(before, after, edit) {
         throw new JsoncError("merge_validation_failed", "widened map lost the original scalar value");
 }
 export function applyJsoncEdits(text, edits) {
-    const before = parseJsonc(text);
+    parseJsonc(text);
     let current = text;
     const results = [];
     for (const edit of edits) {
         const applied = applyEdit(current, parseDocument(current), edit);
-        verifyEdit(before, parseJsonc(applied.text), edit);
+        verifyEdit(parseJsonc(current), parseJsonc(applied.text), edit);
         results.push(applied.result);
         current = applied.text;
     }

package/dist/opencode-config.d.ts

@@ -0,0 +1,11 @@
+import { type JsoncEdit } from "./jsonc.js";
+export type PermissionRule = {
+    action: string;
+    resource: string;
+    effect: "allow" | "ask" | "deny";
+};
+export declare function permissionEdits(config: Record<string, unknown>, additions: PermissionRule[]): JsoncEdit[];
+export declare function matchesWildcard(pattern: string, value: string): boolean;
+export declare function patternsOverlap(left: string, right: 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

@@ -0,0 +1,237 @@
+import { JsoncError } from "./jsonc.js";
+import { requirePackageVersion } from "./package-metadata.js";
+const effects = new Set(["allow", "ask", "deny"]);
+const aliases = {
+    bash: "shell",
+    task: "subagent",
+    write: "edit",
+    patch: "edit",
+};
+function object(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function legacyPermissions(value) {
+    if (typeof value === "string" && effects.has(value))
+        return [{ action: "*", resource: "*", effect: value }];
+    if (!object(value))
+        throw new JsoncError("conflict", "Legacy permission must be an effect or a tool map");
+    return Object.entries(value).flatMap(([name, entry]) => {
+        if (name === "lsp" || name === "doom_loop")
+            throw new JsoncError("conflict", `Permission action has no V2 equivalent: ${name}`);
+        const action = aliases[name] ?? name;
+        const resources = typeof entry === "string" ? { "*": entry } : entry;
+        if (!object(resources))
+            throw new JsoncError("conflict", `Invalid permission map: ${name}`);
+        return Object.entries(resources).map(([resource, effect]) => {
+            if (typeof effect !== "string" || !effects.has(effect))
+                throw new JsoncError("conflict", `Invalid permission effect: ${name}`);
+            return { action, resource, effect: effect };
+        });
+    });
+}
+export function permissionEdits(config, additions) {
+    const edits = [];
+    let rules = [];
+    if ("permissions" in config) {
+        if (!Array.isArray(config.permissions) ||
+            !config.permissions.every((rule) => object(rule) &&
+                typeof rule.action === "string" &&
+                typeof rule.resource === "string" &&
+                typeof rule.effect === "string" &&
+                effects.has(rule.effect)))
+            throw new JsoncError("conflict", "V2 permissions must be an ordered array of action/resource/effect rules");
+        rules = config.permissions;
+    }
+    let tools = [];
+    if ("tools" in config) {
+        if (!object(config.tools) ||
+            !Object.values(config.tools).every((value) => typeof value === "boolean"))
+            throw new JsoncError("conflict", "Legacy tools must be a boolean map");
+        tools = Object.entries(config.tools).map(([name, enabled]) => ({
+            action: aliases[name] ?? name,
+            resource: "*",
+            effect: enabled ? "allow" : "deny",
+        }));
+    }
+    const legacyKeys = ["tools", "permission"].filter((key) => key in config);
+    if (legacyKeys.length) {
+        // V2 normalizes tools first, legacy permission next, and native rules last.
+        rules = [
+            ...tools,
+            ...("permission" in config ? legacyPermissions(config.permission) : []),
+            ...rules,
+        ];
+        const renamed = "permissions" in config ? undefined : legacyKeys[0];
+        for (const key of legacyKeys)
+            edits.push(key === renamed
+                ? { kind: "rename-key", path: [key], to: "permissions" }
+                : { kind: "remove-key", path: [key] });
+        edits.push({ kind: "set-value", path: ["permissions"], value: rules });
+    }
+    else if (!("permissions" in config))
+        edits.push({ kind: "set-if-absent", path: ["permissions"], value: [] });
+    // Rules that existed before this preset run. V2 resolves by the last
+    // matching rule, so a new allow that can overlap a pre-existing deny is
+    // inserted before that deny instead of being appended after it: the user's
+    // prohibition keeps priority for every resource it matches. An allow that
+    // overlaps a deny added earlier in the same batch is a deliberate exception
+    // to that deny (the OpenCode "specific rule follows the broad rule" order)
+    // and is appended, and denies are always appended because a later deny can
+    // only strengthen the result. Batch membership is tracked by object
+    // identity: insertions shift array positions, so a length boundary would
+    // misclassify shifted pre-existing rules as batch additions.
+    const preexisting = rules;
+    const batchRules = new Set();
+    for (const rule of additions) {
+        const exact = rules.reduce((last, existing, index) => existing.action === rule.action && existing.resource === rule.resource ? index : last, -1);
+        if (exact >= 0) {
+            if (rules[exact].effect !== rule.effect ||
+                rules
+                    .slice(exact + 1)
+                    .some((later) => matchesWildcard(later.action, rule.action) &&
+                    matchesWildcard(later.resource, rule.resource) &&
+                    later.effect !== rule.effect))
+                throw new JsoncError("conflict", `Existing permission conflicts with preset: ${rule.action} ${rule.resource}`);
+            continue;
+        }
+        const overlapsDeny = (candidate) => candidate.effect === "deny" && rulesOverlap(candidate, rule);
+        const anchor = rule.effect === "allow" && ![...batchRules].some((added) => overlapsDeny(added))
+            ? preexisting.find((existing) => overlapsDeny(existing))
+            : undefined;
+        if (anchor !== undefined) {
+            edits.push({ kind: "insert-before", path: ["permissions"], before: anchor, value: rule });
+            const position = rules.indexOf(anchor);
+            rules = [...rules.slice(0, position), rule, ...rules.slice(position)];
+        }
+        else {
+            edits.push({ kind: "append-unique", path: ["permissions"], value: rule });
+            rules = [...rules, rule];
+        }
+        batchRules.add(rule);
+    }
+    return edits;
+}
+export function matchesWildcard(pattern, value) {
+    return new RegExp(`^${pattern
+        .replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+        .replace(/\\\*/g, ".*")
+        .replace(/\\\?/g, ".")}$`).test(value);
+}
+function patternUnits(pattern) {
+    return [...pattern].map((character) => character === "*"
+        ? { kind: "star" }
+        : character === "?"
+            ? { kind: "any" }
+            : { kind: "char", char: character });
+}
+export function patternsOverlap(left, right) {
+    const a = patternUnits(left);
+    const b = patternUnits(right);
+    const memo = new Map();
+    const overlap = (i, j) => {
+        if (i === a.length && j === b.length)
+            return true;
+        // A trailing wildcard run can still match the empty string, so exhaustion
+        // is compatible only with an all-star remainder on the other side.
+        if (i === a.length)
+            return b.slice(j).every((unit) => unit.kind === "star");
+        if (j === b.length)
+            return a.slice(i).every((unit) => unit.kind === "star");
+        const key = `${i}:${j}`;
+        const cached = memo.get(key);
+        if (cached !== undefined)
+            return cached;
+        const unit = a[i];
+        const other = b[j];
+        let result;
+        if (unit.kind === "star" || other.kind === "star")
+            // A star consumes nothing from the other pattern or absorbs one unit of it.
+            result = overlap(i + 1, j) || overlap(i, j + 1);
+        else if (unit.kind === "any" || other.kind === "any")
+            result = overlap(i + 1, j + 1);
+        else
+            result = unit.char === other.char && overlap(i + 1, j + 1);
+        memo.set(key, result);
+        return result;
+    };
+    return overlap(0, 0);
+}
+function rulesOverlap(existing, candidate) {
+    return (patternsOverlap(existing.action, candidate.action) &&
+        patternsOverlap(existing.resource, candidate.resource));
+}
+function plugins(value, legacy) {
+    if (!Array.isArray(value))
+        throw new JsoncError("conflict", "Plugin configuration must be an array");
+    return value.map((entry) => {
+        if (typeof entry === "string")
+            return entry === "@kisev/skills-opencode" ? "@kisev/agentomatic" : entry;
+        if (legacy &&
+            Array.isArray(entry) &&
+            entry.length === 2 &&
+            typeof entry[0] === "string" &&
+            object(entry[1]))
+            return {
+                package: entry[0] === "@kisev/skills-opencode" ? "@kisev/agentomatic" : entry[0],
+                options: entry[1],
+            };
+        if (object(entry) && typeof entry.package === "string")
+            return {
+                ...entry,
+                package: entry.package === "@kisev/skills-opencode" ? "@kisev/agentomatic" : entry.package,
+            };
+        throw new JsoncError("conflict", "Invalid plugin entry; use a package string or V2 package/options object");
+    });
+}
+const OUR_PACKAGE = /^@kisev\/(?:agentomatic|skills-opencode)(?:@|$)/;
+function ourEntry(entry) {
+    if (typeof entry === "string")
+        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" },
+    ];
+    // V2 resolves a bare package name through the registry "latest" dist-tag, which
+    // can differ from the installed build; pin the exact running version instead.
+    const pinned = `@kisev/agentomatic@${requirePackageVersion()}`;
+    const native = "plugins" in config ? plugins(config.plugins, false) : undefined;
+    const legacy = "plugin" in config ? plugins(config.plugin, true) : undefined;
+    if (native && legacy) {
+        if (JSON.stringify(native) !== JSON.stringify(legacy))
+            throw new JsoncError("conflict", "Conflicting plugin and plugins sections; migrate explicitly before config setup");
+        edits.push({ kind: "remove-key", path: ["plugin"] });
+    }
+    else if (legacy)
+        edits.push({ kind: "rename-key", path: ["plugin"], to: "plugins" });
+    const normalized = [];
+    let pinnedPresent = false;
+    for (const entry of native ?? legacy ?? []) {
+        if (!ourEntry(entry)) {
+            normalized.push(entry);
+            continue;
+        }
+        if (pinnedPresent)
+            continue;
+        normalized.push(object(entry) ? { ...entry, package: pinned } : pinned);
+        pinnedPresent = true;
+    }
+    const entries = normalized;
+    if (!pinnedPresent)
+        entries.push(pinned);
+    edits.push({ kind: "set-value", path: ["plugins"], value: entries });
+    return edits;
+}

package/dist/plugins/code-simplify.d.ts

@@ -0,0 +1,25 @@
+import type { Plugin } from "@opencode/plugin";
+export type CodeSimplifyLevel = "off" | "lite" | "full" | "ultra";
+export declare const CODE_SIMPLIFY_ROLES: readonly ["manager", "architect", "mapper", "worker", "review", "critic"];
+export type CodeSimplifyRole = (typeof CODE_SIMPLIFY_ROLES)[number];
+export type CodeSimplifyOptions = {
+    level?: CodeSimplifyLevel;
+    /** Agent roles that receive the injection; every role when absent. */
+    scope?: readonly CodeSimplifyRole[];
+};
+export declare function codeSimplify(options?: CodeSimplifyOptions): {
+    context?: undefined;
+} | {
+    context: (input: {
+        agent?: string;
+        system: Array<{
+            type: "text";
+            text: string;
+        }>;
+    }) => Promise<void>;
+};
+declare const _default: {
+    id: string;
+    setup(ctx: Plugin.Context): Promise<void>;
+};
+export default _default;