@kisev/skills-opencode 2.1.0 → 2.2.1

package/dist/installer.js

@@ -44,7 +44,8 @@ export function normalizeSelection(value = {}) {
         commands,
         agents: agents.sort(),
         plugins: plugins.sort(),
-        core_activation: Boolean(value.core_activation ?? (commands.some((name) => PACKAGE_COMMANDS.includes(name)) || agents.length)),
+        core_activation: Boolean(value.core_activation ??
+            (commands.some((name) => PACKAGE_COMMANDS.includes(name)) || agents.length)),
     };
 }
 export class InstallerError extends LifecycleError {
@@ -112,27 +113,57 @@ function parseManifest(raw, path) {
             package_version: manifest.version,
             version: manifest.version,
             scope: "global",
-            commands: Object.keys(files).filter((path) => path.startsWith("commands/")).map((path) => path.slice(9, -3)).sort(),
+            commands: Object.keys(files)
+                .filter((path) => path.startsWith("commands/"))
+                .map((path) => path.slice(9, -3))
+                .sort(),
             agents: [...FIXED_AGENT_ROLES].filter((role) => `agents/${role}.md` in files),
-            plugins: Object.keys(files).filter((path) => path.startsWith("plugins/")).map((path) => path.slice(8, -3)).filter((name) => SELECTABLE_PLUGINS.includes(name)),
+            plugins: Object.keys(files)
+                .filter((path) => path.startsWith("plugins/"))
+                .map((path) => path.slice(8, -3))
+                .filter((name) => SELECTABLE_PLUGINS.includes(name)),
             core_activation: true,
             files,
         };
     }
-    if (manifest.schema_version !== 2 || manifest.package !== PACKAGE_NAME || typeof manifest.package_version !== "string" || (manifest.scope !== "global" && manifest.scope !== "project") || !Array.isArray(manifest.commands) || !Array.isArray(manifest.agents) || !Array.isArray(manifest.plugins) || typeof manifest.core_activation !== "boolean" || !manifest.files || typeof manifest.files !== "object" || Array.isArray(manifest.files)) {
+    if (manifest.schema_version !== 2 ||
+        manifest.package !== PACKAGE_NAME ||
+        typeof manifest.package_version !== "string" ||
+        (manifest.scope !== "global" && manifest.scope !== "project") ||
+        !Array.isArray(manifest.commands) ||
+        !Array.isArray(manifest.agents) ||
+        !Array.isArray(manifest.plugins) ||
+        typeof manifest.core_activation !== "boolean" ||
+        !manifest.files ||
+        typeof manifest.files !== "object" ||
+        Array.isArray(manifest.files)) {
         throw new InstallerError("invalid_manifest", `Ownership manifest has an unexpected format: ${path}`);
     }
     const files = Object.fromEntries(Object.entries(manifest.files).map(([relativePath, record]) => {
         destination("/", relativePath);
-        if (!record || typeof record !== "object" || typeof record.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(record.sha256)) {
+        if (!record ||
+            typeof record !== "object" ||
+            typeof record.sha256 !== "string" ||
+            !/^[a-f0-9]{64}$/.test(record.sha256)) {
             throw new InstallerError("invalid_manifest", `Ownership manifest has an invalid record: ${relativePath}`);
         }
         const existing = record;
-        return [relativePath, {
+        return [
+            relativePath,
+            {
                 sha256: existing.sha256,
                 mode: Number.isInteger(existing.mode) ? existing.mode : 0o644,
-                kind: ["command", "agent", "plugin", "state"].includes(String(existing.kind)) ? existing.kind : relativePath.startsWith("commands/") ? "command" : relativePath.startsWith("plugins/") ? "plugin" : relativePath.startsWith("agents/") ? "agent" : "state",
-            }];
+                kind: ["command", "agent", "plugin", "state"].includes(String(existing.kind))
+                    ? existing.kind
+                    : relativePath.startsWith("commands/")
+                        ? "command"
+                        : relativePath.startsWith("plugins/")
+                            ? "plugin"
+                            : relativePath.startsWith("agents/")
+                                ? "agent"
+                                : "state",
+            },
+        ];
     }));
     return { ...manifest, files };
 }
@@ -150,14 +181,16 @@ export async function archiveMutations(candidates, scope, cwd, home, sourceVersi
             return undefined;
         throw new InstallerError("unsafe_path", "Archive root is inaccessible");
     });
-    if (rootInfo && (!rootInfo.isDirectory() || rootInfo.isSymbolicLink() || (rootInfo.mode & 0o077) !== 0))
+    if (rootInfo &&
+        (!rootInfo.isDirectory() || rootInfo.isSymbolicLink() || (rootInfo.mode & 0o077) !== 0))
         throw new InstallerError("unsafe_path", "Archive root must be a private directory");
     const objectsInfo = await lstat(join(root, "objects")).catch((error) => {
         if (error.code === "ENOENT")
             return undefined;
         throw new InstallerError("unsafe_path", "Archive object store is inaccessible");
     });
-    if (objectsInfo && (!objectsInfo.isDirectory() || objectsInfo.isSymbolicLink() || (objectsInfo.mode & 0o077) !== 0))
+    if (objectsInfo &&
+        (!objectsInfo.isDirectory() || objectsInfo.isSymbolicLink() || (objectsInfo.mode & 0o077) !== 0))
         throw new InstallerError("unsafe_path", "Archive object store must be private");
     const indexPath = destination(root, "index.json");
     const existingRaw = await readRegular(indexPath);
@@ -218,7 +251,14 @@ export async function archiveMutations(candidates, scope, cwd, home, sourceVersi
     }
     const next = Buffer.from(`${stable({ schema_version: 1, version: packageVersion(), entries: entries.sort((a, b) => String(a.original_path).localeCompare(String(b.original_path)) || String(a.digest).localeCompare(String(b.digest))) })}\n`);
     if (!existingRaw || !existingRaw.equals(next)) {
-        mutations.push({ root, path: "index.json", operation: "write", content: next, mode: 0o600, expected: existingRaw ? { sha256: sha256(existingRaw) } : { absent: true } });
+        mutations.push({
+            root,
+            path: "index.json",
+            operation: "write",
+            content: next,
+            mode: 0o600,
+            expected: existingRaw ? { sha256: sha256(existingRaw) } : { absent: true },
+        });
     }
     return mutations;
 }
@@ -263,7 +303,9 @@ async function validateGenericDeployment(root, action, expectedAssets, plannedOp
     }
 }
 function asLegacy(manifest) {
-    return manifest?.version === "1.0.0" ? manifest : undefined;
+    return manifest?.version === "1.0.0"
+        ? manifest
+        : undefined;
 }
 async function build(action, scope, cwd = process.cwd(), home = homedir(), requestedSelection) {
     const root = deploymentRoot(scope, cwd, home);
@@ -280,10 +322,18 @@ async function build(action, scope, cwd = process.cwd(), home = homedir(), reque
     const bundled = await assets(selection);
     const retiredPaths = retiredAssetPaths();
     const legacyRecord = owned.manifest && owned.raw && asLegacy(owned.manifest)
-        ? { manifest: asLegacy(owned.manifest), manifestPath: destination(root, MANIFEST_NAME), manifestSha256: sha256(owned.raw) }
+        ? {
+            manifest: asLegacy(owned.manifest),
+            manifestPath: destination(root, MANIFEST_NAME),
+            manifestSha256: sha256(owned.raw),
+        }
         : undefined;
     const profiles = await buildAgentProfilePlan({ action }, scope, cwd, home, legacyRecord, selection.agents);
-    const operations = profiles.plan.operations.map((item) => ({ path: item.path, operation: item.operation, reason: item.reason }));
+    const operations = profiles.plan.operations.map((item) => ({
+        path: item.path,
+        operation: item.operation,
+        reason: item.reason,
+    }));
     const mutations = [...profiles.mutations];
     const archiveCandidates = [];
     const desiredFiles = {};
@@ -298,13 +348,29 @@ async function build(action, scope, cwd = process.cwd(), home = homedir(), reque
             const record = owned.manifest?.files[asset.relativePath];
             if (!current) {
                 operations.push({ path: asset.relativePath, operation: "create", sha256: asset.sha256 });
-                mutations.push({ path: asset.relativePath, operation: "write", content: asset.content, mode: asset.mode, expected: { absent: true } });
+                mutations.push({
+                    path: asset.relativePath,
+                    operation: "write",
+                    content: asset.content,
+                    mode: asset.mode,
+                    expected: { absent: true },
+                });
             }
             else if (!record) {
-                operations.push({ path: asset.relativePath, operation: "conflict", reason: "unmanaged_file", sha256: sha256(current) });
+                operations.push({
+                    path: asset.relativePath,
+                    operation: "conflict",
+                    reason: "unmanaged_file",
+                    sha256: sha256(current),
+                });
             }
             else if (sha256(current) !== record.sha256) {
-                operations.push({ path: asset.relativePath, operation: "conflict", reason: "managed_file_changed", sha256: sha256(current) });
+                operations.push({
+                    path: asset.relativePath,
+                    operation: "conflict",
+                    reason: "managed_file_changed",
+                    sha256: sha256(current),
+                });
             }
             else if (current.equals(asset.content) &&
                 ((await lstat(destination(root, asset.relativePath))).mode & 0o777) === asset.mode) {
@@ -312,7 +378,13 @@ async function build(action, scope, cwd = process.cwd(), home = homedir(), reque
             }
             else {
                 operations.push({ path: asset.relativePath, operation: "update", sha256: asset.sha256 });
-                mutations.push({ path: asset.relativePath, operation: "write", content: asset.content, mode: asset.mode, expected: { sha256: record.sha256 } });
+                mutations.push({
+                    path: asset.relativePath,
+                    operation: "write",
+                    content: asset.content,
+                    mode: asset.mode,
+                    expected: { sha256: record.sha256 },
+                });
             }
         }
         const active = new Set(bundled.map((asset) => asset.relativePath));
@@ -325,28 +397,72 @@ async function build(action, scope, cwd = process.cwd(), home = homedir(), reque
                     operations.push({ path: relativePath, operation: "missing", sha256: record.sha256 });
                 }
                 else if (sha256(current) !== record.sha256) {
-                    operations.push({ path: relativePath, operation: "conflict", reason: "managed_file_changed", sha256: sha256(current) });
+                    operations.push({
+                        path: relativePath,
+                        operation: "conflict",
+                        reason: "managed_file_changed",
+                        sha256: sha256(current),
+                    });
                 }
                 else {
-                    operations.push({ path: relativePath, operation: "archive-pending", reason: "archive lifecycle is pending", sha256: record.sha256 });
-                    archiveCandidates.push({ path: relativePath, record, content: current, reason: "retired managed asset", kind: record.kind });
-                    mutations.push({ path: relativePath, operation: "remove", expected: { sha256: record.sha256 } });
+                    operations.push({
+                        path: relativePath,
+                        operation: "archive-pending",
+                        reason: "archive lifecycle is pending",
+                        sha256: record.sha256,
+                    });
+                    archiveCandidates.push({
+                        path: relativePath,
+                        record,
+                        content: current,
+                        reason: "retired managed asset",
+                        kind: record.kind,
+                    });
+                    mutations.push({
+                        path: relativePath,
+                        operation: "remove",
+                        expected: { sha256: record.sha256 },
+                    });
                 }
                 continue;
             }
             if (relativePath.startsWith("agents/")) {
-                operations.push({ path: relativePath, operation: "conflict", reason: "v1.0.0_agent_ownership_mismatch" });
+                operations.push({
+                    path: relativePath,
+                    operation: "conflict",
+                    reason: "v1.0.0_agent_ownership_mismatch",
+                });
                 continue;
             }
             if (!current)
                 operations.push({ path: relativePath, operation: "missing" });
             else if (sha256(current) === record.sha256) {
-                operations.push({ path: relativePath, operation: "archive-pending", reason: "stale managed asset is archived", sha256: record.sha256 });
-                archiveCandidates.push({ path: relativePath, record, content: current, reason: "stale managed asset", kind: record.kind });
-                mutations.push({ path: relativePath, operation: "remove", expected: { sha256: record.sha256 } });
+                operations.push({
+                    path: relativePath,
+                    operation: "archive-pending",
+                    reason: "stale managed asset is archived",
+                    sha256: record.sha256,
+                });
+                archiveCandidates.push({
+                    path: relativePath,
+                    record,
+                    content: current,
+                    reason: "stale managed asset",
+                    kind: record.kind,
+                });
+                mutations.push({
+                    path: relativePath,
+                    operation: "remove",
+                    expected: { sha256: record.sha256 },
+                });
             }
             else
-                operations.push({ path: relativePath, operation: "conflict", reason: "managed_file_changed", sha256: sha256(current) });
+                operations.push({
+                    path: relativePath,
+                    operation: "conflict",
+                    reason: "managed_file_changed",
+                    sha256: sha256(current),
+                });
         }
     }
     else {
@@ -357,28 +473,68 @@ async function build(action, scope, cwd = process.cwd(), home = homedir(), reque
                     operations.push({ path: relativePath, operation: "missing", sha256: record.sha256 });
                 }
                 else if (sha256(current) !== record.sha256) {
-                    operations.push({ path: relativePath, operation: "conflict", reason: "managed_file_changed", sha256: sha256(current) });
+                    operations.push({
+                        path: relativePath,
+                        operation: "conflict",
+                        reason: "managed_file_changed",
+                        sha256: sha256(current),
+                    });
                 }
                 else {
-                    operations.push({ path: relativePath, operation: "archive-pending", reason: "archive lifecycle is pending", sha256: record.sha256 });
-                    archiveCandidates.push({ path: relativePath, record, content: current, reason: "retired managed asset", kind: record.kind });
-                    mutations.push({ path: relativePath, operation: "remove", expected: { sha256: record.sha256 } });
+                    operations.push({
+                        path: relativePath,
+                        operation: "archive-pending",
+                        reason: "archive lifecycle is pending",
+                        sha256: record.sha256,
+                    });
+                    archiveCandidates.push({
+                        path: relativePath,
+                        record,
+                        content: current,
+                        reason: "retired managed asset",
+                        kind: record.kind,
+                    });
+                    mutations.push({
+                        path: relativePath,
+                        operation: "remove",
+                        expected: { sha256: record.sha256 },
+                    });
                 }
             }
             else if (!current)
                 operations.push({ path: relativePath, operation: "missing" });
             else if (sha256(current) === record.sha256) {
-                operations.push({ path: relativePath, operation: "archive-pending", reason: "stale managed asset is archived", sha256: record.sha256 });
-                archiveCandidates.push({ path: relativePath, record, content: current, reason: "stale managed asset", kind: record.kind });
-                mutations.push({ path: relativePath, operation: "remove", expected: { sha256: record.sha256 } });
+                operations.push({
+                    path: relativePath,
+                    operation: "archive-pending",
+                    reason: "stale managed asset is archived",
+                    sha256: record.sha256,
+                });
+                archiveCandidates.push({
+                    path: relativePath,
+                    record,
+                    content: current,
+                    reason: "stale managed asset",
+                    kind: record.kind,
+                });
+                mutations.push({
+                    path: relativePath,
+                    operation: "remove",
+                    expected: { sha256: record.sha256 },
+                });
             }
             else {
-                operations.push({ path: relativePath, operation: "conflict", reason: "managed_file_changed", sha256: sha256(current) });
+                operations.push({
+                    path: relativePath,
+                    operation: "conflict",
+                    reason: "managed_file_changed",
+                    sha256: sha256(current),
+                });
                 desiredFiles[relativePath] = record;
             }
         }
     }
-    mutations.push(...await archiveMutations(archiveCandidates, scope, cwd, home, owned.manifest?.package_version ?? "1.0.0"));
+    mutations.push(...(await archiveMutations(archiveCandidates, scope, cwd, home, owned.manifest?.package_version ?? "1.0.0")));
     const nextManifest = action === "install" || Object.keys(desiredFiles).length
         ? {
             schema_version: 2,
@@ -395,15 +551,46 @@ async function build(action, scope, cwd = process.cwd(), home = homedir(), reque
         : undefined;
     const manifestContent = nextManifest ? Buffer.from(`${stable(nextManifest)}\n`) : undefined;
     if (manifestContent && (!owned.raw || !owned.raw.equals(manifestContent))) {
-        operations.push({ path: MANIFEST_NAME, operation: owned.raw ? "update" : "create", reason: "generic installer ownership" });
-        mutations.push({ path: MANIFEST_NAME, operation: "write", content: manifestContent, mode: 0o600, expected: owned.raw ? { sha256: sha256(owned.raw) } : { absent: true } });
+        operations.push({
+            path: MANIFEST_NAME,
+            operation: owned.raw ? "update" : "create",
+            reason: "generic installer ownership",
+        });
+        mutations.push({
+            path: MANIFEST_NAME,
+            operation: "write",
+            content: manifestContent,
+            mode: 0o600,
+            expected: owned.raw ? { sha256: sha256(owned.raw) } : { absent: true },
+        });
     }
     else if (!manifestContent && owned.raw) {
-        operations.push({ path: MANIFEST_NAME, operation: "remove", reason: "generic assets uninstalled" });
-        mutations.push({ path: MANIFEST_NAME, operation: "remove", expected: { sha256: sha256(owned.raw) } });
+        operations.push({
+            path: MANIFEST_NAME,
+            operation: "remove",
+            reason: "generic assets uninstalled",
+        });
+        mutations.push({
+            path: MANIFEST_NAME,
+            operation: "remove",
+            expected: { sha256: sha256(owned.raw) },
+        });
     }
     const sorted = operations.sort((left, right) => left.path.localeCompare(right.path) || left.operation.localeCompare(right.operation));
-    const base = { schema_version: 2, action, scope, root, package_version: packageVersion(), selection, operations: sorted, requires_restart: (action === "install" && owned.manifest?.package_version !== packageVersion()) || profiles.plan.requires_restart || mutations.some((item) => item.path.startsWith("agents/") || item.path.startsWith("commands/") || item.path.startsWith("plugins/")) };
+    const base = {
+        schema_version: 2,
+        action,
+        scope,
+        root,
+        package_version: packageVersion(),
+        selection,
+        operations: sorted,
+        requires_restart: (action === "install" && owned.manifest?.package_version !== packageVersion()) ||
+            profiles.plan.requires_restart ||
+            mutations.some((item) => item.path.startsWith("agents/") ||
+                item.path.startsWith("commands/") ||
+                item.path.startsWith("plugins/")),
+    };
     const planDigest = digest(base);
     return {
         plan: { ...base, plan_digest: planDigest, digest: planDigest },
@@ -446,16 +633,25 @@ export async function apply(action, scope, confirmationDigest, cwd = process.cwd
         return await withLifecycleLock(stateRoot, async () => {
             if (await recoverTransaction(root, stateRoot))
                 throw new InstallerError("recovered_transaction", "Recovered an interrupted transaction; request a fresh plan");
-            const receipt = (await consumeReceipt(stateRoot, { digest: confirmationDigest, kind: `installer:${action}`, scope, root }));
+            const receipt = (await consumeReceipt(stateRoot, {
+                digest: confirmationDigest,
+                kind: `installer:${action}`,
+                scope,
+                root,
+            }));
             const built = await build(action, scope, cwd, home, selection);
             const savedPlanDigest = receipt.plan_digest ??
                 receipt.digest;
             if (built.plan.digest !== savedPlanDigest)
                 throw new InstallerError("stale_plan", "Installer plan changed after preview");
-            if (built.plan.operations.some((item) => item.operation === "conflict" && (item.reason === "unmanaged_file" || item.reason === "v1.0.0_agent_ownership_mismatch" || item.reason?.includes("collision")))) {
+            if (built.plan.operations.some((item) => item.operation === "conflict" &&
+                (item.reason === "unmanaged_file" ||
+                    item.reason === "v1.0.0_agent_ownership_mismatch" ||
+                    item.reason?.includes("collision")))) {
                 throw new InstallerError("conflict", "Installer plan contains an exact-name ownership conflict");
             }
-            if (action === "install" && built.plan.operations.some((item) => item.operation === "conflict"))
+            if (action === "install" &&
+                built.plan.operations.some((item) => item.operation === "conflict"))
                 throw new InstallerError("conflict", "Installer plan contains managed drift");
             await applyTransaction(root, stateRoot, built.mutations, {
                 ...options,
@@ -466,7 +662,12 @@ export async function apply(action, scope, confirmationDigest, cwd = process.cwd
                     if (action !== "install")
                         return;
                     const inventory = await listAgentProfiles(scope, cwd, home);
-                    if (built.plan.selection.agents.length > 0 && (inventory.collisions.length || inventory.drift.length || inventory.profiles.filter((item) => item.ownership !== "user-owned").some((item) => item.state !== "current"))) {
+                    if (built.plan.selection.agents.length > 0 &&
+                        (inventory.collisions.length ||
+                            inventory.drift.length ||
+                            inventory.profiles
+                                .filter((item) => item.ownership !== "user-owned")
+                                .some((item) => item.state !== "current"))) {
                         throw new InstallerError("final_validation_failed", "Final installed agent inventory is invalid");
                     }
                 },

package/dist/plugins/rtk.js

@@ -1,9 +1,13 @@
 import { spawn } from "node:child_process";
 const THRESHOLD = 8_000;
 const FILTERS = [
-    { prefix: ["git", "log"], filter: "git-log" }, { prefix: ["git", "diff"], filter: "git-diff" },
-    { prefix: ["git", "status"], filter: "git-status" }, { prefix: ["rg"], filter: "grep" },
-    { prefix: ["grep"], filter: "grep" }, { prefix: ["pytest"], filter: "pytest" }, { prefix: ["tsc"], filter: "tsc" },
+    { prefix: ["git", "log"], filter: "git-log" },
+    { prefix: ["git", "diff"], filter: "git-diff" },
+    { prefix: ["git", "status"], filter: "git-status" },
+    { prefix: ["rg"], filter: "grep" },
+    { prefix: ["grep"], filter: "grep" },
+    { prefix: ["pytest"], filter: "pytest" },
+    { prefix: ["tsc"], filter: "tsc" },
 ];
 function filter(command) {
     if (/[|;$&\n()`]/.test(command))
@@ -16,14 +20,21 @@ function filter(command) {
 function truncate(value) {
     const points = Array.from(value);
     const size = 3_200;
-    return points.length <= size * 2 ? value : `${points.slice(0, size).join("")}\n…\n${points.slice(-size).join("")}`;
+    return points.length <= size * 2
+        ? value
+        : `${points.slice(0, size).join("")}\n…\n${points.slice(-size).join("")}`;
 }
 function external(binary, selected, input) {
     return new Promise((done) => {
-        const child = spawn(binary, ["pipe", "--filter", selected], { stdio: ["pipe", "pipe", "ignore"], timeout: 5_000 });
+        const child = spawn(binary, ["pipe", "--filter", selected], {
+            stdio: ["pipe", "pipe", "ignore"],
+            timeout: 5_000,
+        });
         let output = "";
         child.stdout.setEncoding("utf8");
-        child.stdout.on("data", (chunk) => { output += chunk; });
+        child.stdout.on("data", (chunk) => {
+            output += chunk;
+        });
         child.once("error", () => done(undefined));
         child.once("close", (code) => done(code === 0 ? output : undefined));
         child.stdin.end(input, "utf8");
@@ -32,20 +43,31 @@ function external(binary, selected, input) {
 export async function rtk(options = {}) {
     if (options.enabled === false)
         return {};
-    const run = options.run ?? ((selected, input) => external(options.bin ?? "rtk", selected, input));
-    return { "tool.execute.after": async (input, output) => {
+    const run = options.run ??
+        ((selected, input) => external(options.bin ?? "rtk", selected, input));
+    return {
+        "tool.execute.after": async (input, output) => {
             try {
-                if (input.tool === "edit" && typeof output.output === "string" && /oldString (not found|found multiple times|and newString must be different)/i.test(output.output))
+                if (input.tool === "edit" &&
+                    typeof output.output === "string" &&
+                    /oldString (not found|found multiple times|and newString must be different)/i.test(output.output))
                     output.output = `${output.output}\nSTOP. Read the file before retrying Edit.`;
-                if (input.tool !== "bash" || typeof output.output !== "string" || output.output.length < (options.threshold ?? THRESHOLD))
+                if (input.tool !== "bash" ||
+                    typeof output.output !== "string" ||
+                    output.output.length < (options.threshold ?? THRESHOLD))
                     return;
                 const selected = typeof input.args?.command === "string" ? filter(input.args.command) : undefined;
                 const compressed = selected ? await run(selected, output.output) : undefined;
-                const result = compressed && compressed.length < output.output.length ? compressed : truncate(output.output);
+                const result = compressed && compressed.length < output.output.length
+                    ? compressed
+                    : truncate(output.output);
                 const originalSize = output.output.length;
                 output.output = `${result}\n[rtk: compressed method=${compressed ? `rtk/${selected}` : "head+tail"}; sizes=${originalSize}->${result.length}; evidence_complete=false; loss=possible]`;
             }
-            catch { /* RTK is fail-open: preserve original tool output on plugin failure. */ }
-        } };
+            catch {
+                /* RTK is fail-open: preserve original tool output on plugin failure. */
+            }
+        },
+    };
 }
 export default rtk;

package/dist/plugins/rules-injector.d.ts

@@ -9,7 +9,7 @@ export declare function rulesInjector(options?: RulesInjectorOptions): Promise<{
     "experimental.chat.system.transform"?: undefined;
 } | {
     "tool.execute.after": (input: unknown, result: unknown) => Promise<void>;
-    event: ({ event }: {
+    event: ({ event, }: {
         event?: {
             type?: string;
             properties?: Record<string, unknown>;

package/dist/plugins/rules-injector.js

@@ -2,19 +2,33 @@ import { lstat, readFile, realpath } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, resolve } from "node:path";
 const NAME = "AGENTS.md";
-function sessionID(value) { const item = value; for (const key of ["sessionID", "sessionId", "session_id"])
-    if (typeof item?.[key] === "string" && item[key])
-        return item[key]; return undefined; }
-function pathOf(input, output) { for (const value of [input, output]) {
-    const args = value?.args;
-    for (const key of ["filePath", "file_path", "path"])
-        if (typeof args?.[key] === "string")
-            return args[key];
-} return undefined; }
-function output(value, text) { const item = value; if (typeof item?.output === "string")
-    item.output = `${item.output}\n${text}`; }
-function marker(rule) { return `[rules-injector source=${rule.path} revision=${rule.revision}]`; }
-function block(rule) { return `${marker(rule)}\n${rule.content}\n[/rules-injector source=${rule.path}]`; }
+function sessionID(value) {
+    const item = value;
+    for (const key of ["sessionID", "sessionId", "session_id"])
+        if (typeof item?.[key] === "string" && item[key])
+            return item[key];
+    return undefined;
+}
+function pathOf(input, output) {
+    for (const value of [input, output]) {
+        const args = value?.args;
+        for (const key of ["filePath", "file_path", "path"])
+            if (typeof args?.[key] === "string")
+                return args[key];
+    }
+    return undefined;
+}
+function output(value, text) {
+    const item = value;
+    if (typeof item?.output === "string")
+        item.output = `${item.output}\n${text}`;
+}
+function marker(rule) {
+    return `[rules-injector source=${rule.path} revision=${rule.revision}]`;
+}
+function block(rule) {
+    return `${marker(rule)}\n${rule.content}\n[/rules-injector source=${rule.path}]`;
+}
 export async function rulesInjector(options = {}) {
     if (options.enabled === false)
         return {};
@@ -22,10 +36,14 @@ export async function rulesInjector(options = {}) {
     const cwd = resolve(options.cwd ?? process.cwd());
     const global = resolve(process.env.XDG_CONFIG_HOME ?? resolve(homedir(), ".config"), "opencode");
     const sessions = new Map();
-    const state = (identifier) => { let item = sessions.get(identifier); if (!item) {
-        item = { loaded: new Map(), injected: new Set(), used: 0, replay: false };
-        sessions.set(identifier, item);
-    } return item; };
+    const state = (identifier) => {
+        let item = sessions.get(identifier);
+        if (!item) {
+            item = { loaded: new Map(), injected: new Set(), used: 0, replay: false };
+            sessions.set(identifier, item);
+        }
+        return item;
+    };
     const inject = async (input, result) => {
         const call = input;
         if (call?.tool !== "read" && call?.tool !== "edit")
@@ -42,7 +60,9 @@ export async function rulesInjector(options = {}) {
                 const candidate = resolve(current, NAME);
                 try {
                     const info = await lstat(candidate);
-                    if (info.isFile() && candidate !== resolve(native, NAME) && candidate !== resolve(global, NAME))
+                    if (info.isFile() &&
+                        candidate !== resolve(native, NAME) &&
+                        candidate !== resolve(global, NAME))
                         paths.push(await realpath(candidate));
                 }
                 catch (error) {
@@ -63,7 +83,11 @@ export async function rulesInjector(options = {}) {
                     const info = await lstat(path);
                     if (!info.isFile())
                         continue;
-                    const rule = { path, revision: `${Math.trunc(info.mtimeMs)}:${info.size}`, content: await readFile(path, "utf8") };
+                    const rule = {
+                        path,
+                        revision: `${Math.trunc(info.mtimeMs)}:${info.size}`,
+                        content: await readFile(path, "utf8"),
+                    };
                     const text = block(rule);
                     if (currentState.used + text.length > budget) {
                         additions.push(`[rules-injector warning] context budget exhausted; skipped ${path}`);
@@ -85,12 +109,23 @@ export async function rulesInjector(options = {}) {
             output(result, `[rules-injector warning] cannot read AGENTS.md: ${String(error)}`);
         }
     };
-    return { "tool.execute.after": inject, event: async ({ event }) => { if (event?.type?.includes("compaction")) {
-            const identifier = sessionID(event.properties);
-            if (identifier)
-                state(identifier).replay = true;
-        } }, "experimental.chat.system.transform": async (input, result) => { const identifier = sessionID(input); if (!identifier || !state(identifier).replay || !Array.isArray(result.system))
-            return; for (const rule of state(identifier).loaded.values())
-            result.system.push(block(rule)); state(identifier).replay = false; } };
+    return {
+        "tool.execute.after": inject,
+        event: async ({ event, }) => {
+            if (event?.type?.includes("compaction")) {
+                const identifier = sessionID(event.properties);
+                if (identifier)
+                    state(identifier).replay = true;
+            }
+        },
+        "experimental.chat.system.transform": async (input, result) => {
+            const identifier = sessionID(input);
+            if (!identifier || !state(identifier).replay || !Array.isArray(result.system))
+                return;
+            for (const rule of state(identifier).loaded.values())
+                result.system.push(block(rule));
+            state(identifier).replay = false;
+        },
+    };
 }
 export default rulesInjector;