@kisev/skills-opencode 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,160 @@
+import backgroundAttempts, { type BackgroundAttemptsOptions } from "./plugins/background-attempts.js";
+import goalLoop, { type GoalLoopOptions } from "./plugins/goal-loop.js";
+import scheduler, { type SchedulerOptions } from "./plugins/schedule.js";
+import autonomyPolicy, { type AutonomyPolicyOptions } from "./plugins/autonomy-policy.js";
+import rulesInjector, { type RulesInjectorOptions } from "./plugins/rules-injector.js";
+import rtk, { type RtkOptions } from "./plugins/rtk.js";
+import zedBell, { type ZedBellOptions } from "./plugins/zed-bell.js";
+import zedClickablePaths, { type ZedClickablePathsOptions } from "./plugins/zed-clickable-paths.js";
+export { COMMAND_REGISTRY, renderCommand } from "./registry.js";
+export { CATEGORIES, resolveRouting, RoutingGate } from "./routing.js";
+export { backgroundAttempts, goalLoop, scheduler, autonomyPolicy, rulesInjector, rtk, zedBell, zedClickablePaths };
+export type OpenCodeOptions = {
+    backgroundAttempts?: BackgroundAttemptsOptions;
+    goalLoop?: GoalLoopOptions;
+    scheduler?: SchedulerOptions;
+    autonomyPolicy?: AutonomyPolicyOptions;
+    rulesInjector?: RulesInjectorOptions;
+    rtk?: RtkOptions;
+    zedBell?: ZedBellOptions;
+    zedClickablePaths?: ZedClickablePathsOptions;
+};
+declare const plugin: () => Promise<{
+    tool: {
+        route: {
+            description: string;
+            args: {
+                action: import("zod").ZodEnum<{
+                    preview: "preview";
+                    dispatch: "dispatch";
+                }>;
+                category: import("zod").ZodEnum<{
+                    exploration: "exploration";
+                    architecture: "architecture";
+                    implementation: "implementation";
+                    review: "review";
+                    documentation: "documentation";
+                    quick: "quick";
+                }>;
+                task: import("zod").ZodString;
+                requirements: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+                agents: import("zod").ZodArray<import("zod").ZodObject<{
+                    agent: import("zod").ZodString;
+                    available: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    capabilities: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                    tools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                }, import("zod/v4/core").$strip>>;
+                override: import("zod").ZodOptional<import("zod").ZodString>;
+                budget: import("zod").ZodOptional<import("zod").ZodObject<{
+                    cost_class: import("zod").ZodOptional<import("zod").ZodString>;
+                    latency_class: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+                decision: import("zod").ZodOptional<import("zod").ZodAny>;
+            };
+            execute(args: {
+                action: "preview" | "dispatch";
+                category: "exploration" | "architecture" | "implementation" | "review" | "documentation" | "quick";
+                task: string;
+                requirements: string[];
+                agents: {
+                    agent: string;
+                    available?: boolean | undefined;
+                    capabilities?: string[] | undefined;
+                    tools?: string[] | undefined;
+                }[];
+                override?: string | undefined;
+                budget?: {
+                    cost_class?: string | undefined;
+                    latency_class?: string | undefined;
+                } | undefined;
+                decision?: any;
+            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+        };
+        capabilities: {
+            description: string;
+            args: {};
+            execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+        };
+        doctor: {
+            description: string;
+            args: {};
+            execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+        };
+    };
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID: string;
+    }, output: {
+        args: unknown;
+    }) => Promise<void>;
+}>;
+export declare const server: () => Promise<{
+    tool: {
+        route: {
+            description: string;
+            args: {
+                action: import("zod").ZodEnum<{
+                    preview: "preview";
+                    dispatch: "dispatch";
+                }>;
+                category: import("zod").ZodEnum<{
+                    exploration: "exploration";
+                    architecture: "architecture";
+                    implementation: "implementation";
+                    review: "review";
+                    documentation: "documentation";
+                    quick: "quick";
+                }>;
+                task: import("zod").ZodString;
+                requirements: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+                agents: import("zod").ZodArray<import("zod").ZodObject<{
+                    agent: import("zod").ZodString;
+                    available: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    capabilities: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                    tools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                }, import("zod/v4/core").$strip>>;
+                override: import("zod").ZodOptional<import("zod").ZodString>;
+                budget: import("zod").ZodOptional<import("zod").ZodObject<{
+                    cost_class: import("zod").ZodOptional<import("zod").ZodString>;
+                    latency_class: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+                decision: import("zod").ZodOptional<import("zod").ZodAny>;
+            };
+            execute(args: {
+                action: "preview" | "dispatch";
+                category: "exploration" | "architecture" | "implementation" | "review" | "documentation" | "quick";
+                task: string;
+                requirements: string[];
+                agents: {
+                    agent: string;
+                    available?: boolean | undefined;
+                    capabilities?: string[] | undefined;
+                    tools?: string[] | undefined;
+                }[];
+                override?: string | undefined;
+                budget?: {
+                    cost_class?: string | undefined;
+                    latency_class?: string | undefined;
+                } | undefined;
+                decision?: any;
+            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+        };
+        capabilities: {
+            description: string;
+            args: {};
+            execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+        };
+        doctor: {
+            description: string;
+            args: {};
+            execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+        };
+    };
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID: string;
+    }, output: {
+        args: unknown;
+    }) => Promise<void>;
+}>;
+export default plugin;

package/dist/index.js

@@ -0,0 +1,69 @@
+import { tool } from "@opencode-ai/plugin";
+import { CATEGORIES, RoutingGate } from "./routing.js";
+import backgroundAttempts from "./plugins/background-attempts.js";
+import goalLoop from "./plugins/goal-loop.js";
+import scheduler from "./plugins/schedule.js";
+import autonomyPolicy from "./plugins/autonomy-policy.js";
+import rulesInjector from "./plugins/rules-injector.js";
+import rtk from "./plugins/rtk.js";
+import zedBell from "./plugins/zed-bell.js";
+import zedClickablePaths from "./plugins/zed-clickable-paths.js";
+export { COMMAND_REGISTRY, renderCommand } from "./registry.js";
+export { CATEGORIES, resolveRouting, RoutingGate } from "./routing.js";
+export { backgroundAttempts, goalLoop, scheduler, autonomyPolicy, rulesInjector, rtk, zedBell, zedClickablePaths };
+const CATALOG = {
+    skills: ["attempt", "goal", "schedule", "multi-run", "usage", "overview", "lsp-report"],
+    plugins: ["background-attempts", "goal-loop", "schedule", "autonomy-policy", "rules-injector", "rtk", "zed-bell", "zed-clickable-paths"],
+    replacements: ["capabilities", "route", "doctor"],
+    version: "1.0.0",
+};
+const plugin = (async () => {
+    const gate = new RoutingGate();
+    const route = tool({
+        description: "Resolve a capability category and dispatch one eligible agent through a one-use Task receipt gate.",
+        args: {
+            action: tool.schema.enum(["preview", "dispatch"]),
+            category: tool.schema.enum(CATEGORIES),
+            task: tool.schema.string(),
+            requirements: tool.schema.array(tool.schema.string()).default([]),
+            agents: tool.schema.array(tool.schema.object({ agent: tool.schema.string(), available: tool.schema.boolean().optional(), capabilities: tool.schema.array(tool.schema.string()).optional(), tools: tool.schema.array(tool.schema.string()).optional() })),
+            override: tool.schema.string().optional(),
+            budget: tool.schema.object({ cost_class: tool.schema.string().optional(), latency_class: tool.schema.string().optional() }).optional(),
+            decision: tool.schema.any().optional()
+        },
+        async execute(args, context) {
+            const input = { category: args.category, requirements: args.requirements, agents: args.agents, override: args.override, budget: args.budget };
+            if (args.action === "preview")
+                return JSON.stringify(gate.preview(input));
+            const decision = gate.dispatch(input, args.decision);
+            gate.grant(context.sessionID, decision);
+            return JSON.stringify({ decision, status: "routed" });
+        }
+    });
+    const capabilities = tool({
+        description: "Show the bundled OpenCode capability catalog without installing or changing anything.",
+        args: {},
+        async execute() { return JSON.stringify({ schema_version: 1, status: "ok", ...CATALOG }); },
+    });
+    const doctor = tool({
+        description: "Read package health and opt-in defaults without installing or repairing anything.",
+        args: {},
+        async execute() {
+            return JSON.stringify({ schema_version: 1, status: "ok", package: "@kisev/skills-opencode", opencode: ">=1.18.29", state: "not-inspected", mutations: false, defaults: { backgroundAttempts: false, goalLoop: false, scheduler: false, autonomyPolicy: false, zedBell: false, zedClickablePaths: false } });
+        },
+    });
+    return {
+        tool: { route, capabilities, doctor },
+        "tool.execute.before": async (input, output) => {
+            if (input.tool !== "task")
+                return;
+            const args = output.args && typeof output.args === "object" ? output.args : {};
+            const agent = typeof args.agent === "string" ? args.agent : typeof args.subagent_type === "string" ? args.subagent_type : undefined;
+            if (!agent)
+                throw new Error("Native Task requires an explicit agent and an active routing receipt");
+            gate.consume(input.sessionID, agent);
+        }
+    };
+});
+export const server = plugin;
+export default plugin;

package/dist/installer.d.ts

@@ -0,0 +1,25 @@
+export type Scope = "global" | "project";
+export type Action = "install" | "uninstall";
+export type Operation = "create" | "update" | "remove" | "unchanged" | "missing" | "conflict";
+export type PlanItem = {
+    path: string;
+    operation: Operation;
+    reason?: string;
+    sha256?: string;
+};
+export type Plan = {
+    schema_version: 1;
+    action: Action;
+    scope: Scope;
+    root: string;
+    operations: PlanItem[];
+    manifest_sha256?: string;
+    digest: string;
+};
+export declare class InstallerError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare function preview(action: Action, scope: Scope, cwd?: string, home?: string): Promise<Plan>;
+export declare function apply(action: Action, scope: Scope, digest: string, cwd?: string, home?: string): Promise<Plan>;
+export declare function result(plan: Plan, applied: boolean): string;

package/dist/installer.js

@@ -0,0 +1,332 @@
+import { createHash, randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { lstat, mkdir, readdir, readFile, rename, rm, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, normalize, parse, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+const PACKAGE_NAME = "@kisev/skills-opencode";
+const MANIFEST_NAME = ".skills-opencode-manifest.json";
+const MANIFEST_SCHEMA_VERSION = 1;
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const assetsRoot = resolve(packageRoot, "assets");
+export class InstallerError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+function stable(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(stable).join(",")}]`;
+    const object = value;
+    return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stable(object[key])}`).join(",")}}`;
+}
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function planDigest(plan) {
+    return sha256(stable(plan));
+}
+function packageVersion() {
+    const metadata = JSON.parse(requireReadFile(resolve(packageRoot, "package.json")));
+    if (typeof metadata.version !== "string" || !metadata.version)
+        throw new InstallerError("invalid_package", "Package version is unavailable");
+    return metadata.version;
+}
+function requireReadFile(path) {
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch (error) {
+        throw new InstallerError("asset_error", `Cannot read ${path}: ${String(error)}`);
+    }
+}
+function isInside(root, target) {
+    const difference = relative(root, target);
+    return difference === "" || (!difference.startsWith(`..${sep}`) && difference !== ".." && !isAbsolute(difference));
+}
+function assertSafeRelative(value) {
+    if (!value || isAbsolute(value) || normalize(value) !== value || value.split(/[\\/]/).some((part) => !part || part === "." || part === "..")) {
+        throw new InstallerError("unsafe_path", `Unsafe relative path: ${value}`);
+    }
+}
+async function lstatSafe(path) {
+    try {
+        return await lstat(path);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+async function assertSafeAncestors(path) {
+    const parsed = parse(resolve(path));
+    let current = parsed.root;
+    const pieces = resolve(path).slice(parsed.root.length).split(sep).filter(Boolean);
+    for (const piece of pieces) {
+        current = join(current, piece);
+        const stat = await lstatSafe(current);
+        if (!stat)
+            return;
+        if (stat.isSymbolicLink())
+            throw new InstallerError("unsafe_path", `Symlink is not allowed: ${current}`);
+        if (current !== resolve(path) && !stat.isDirectory())
+            throw new InstallerError("unsafe_path", `Path parent is not a directory: ${current}`);
+    }
+}
+async function readRegular(path) {
+    await assertSafeAncestors(path);
+    const stat = await lstatSafe(path);
+    if (!stat)
+        return undefined;
+    if (!stat.isFile())
+        throw new InstallerError("unsafe_path", `Target is not a regular file: ${path}`);
+    return readFile(path);
+}
+async function ensureSafeDirectory(path) {
+    await assertSafeAncestors(path);
+    const stat = await lstatSafe(path);
+    if (stat && !stat.isDirectory())
+        throw new InstallerError("unsafe_path", `Destination root is not a directory: ${path}`);
+    await mkdir(path, { recursive: true });
+    await assertSafeAncestors(path);
+}
+function rootFor(scope, cwd = process.cwd(), home = homedir()) {
+    return scope === "global" ? resolve(home, ".config", "opencode") : resolve(cwd, ".opencode");
+}
+function destination(root, relativePath) {
+    assertSafeRelative(relativePath);
+    const target = resolve(root, relativePath);
+    if (!isInside(root, target))
+        throw new InstallerError("unsafe_path", `Path escapes destination root: ${relativePath}`);
+    return target;
+}
+async function assets() {
+    const result = [];
+    for (const category of ["agents", "commands", "plugins"]) {
+        const directory = resolve(assetsRoot, category);
+        await assertSafeAncestors(directory);
+        const entries = await readdir(directory, { withFileTypes: true });
+        for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+            const extension = category === "plugins" ? ".js" : ".md";
+            if (!entry.isFile() || entry.isSymbolicLink() || !entry.name.endsWith(extension))
+                throw new InstallerError("asset_error", `Asset is not a regular ${extension} asset: ${entry.name}`);
+            const relativePath = `${category}/${entry.name}`;
+            assertSafeRelative(relativePath);
+            const source = destination(assetsRoot, relativePath);
+            const content = await readRegular(source);
+            if (!content)
+                throw new InstallerError("asset_error", `Asset is missing: ${relativePath}`);
+            result.push({ relativePath, content, sha256: sha256(content) });
+        }
+    }
+    return result.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+}
+function manifestPath(root) {
+    return destination(root, MANIFEST_NAME);
+}
+function parseManifest(value, path) {
+    let parsed;
+    try {
+        parsed = JSON.parse(value.toString("utf8"));
+    }
+    catch {
+        throw new InstallerError("invalid_manifest", `Ownership manifest is not valid JSON: ${path}`);
+    }
+    if (!parsed || typeof parsed !== "object")
+        throw new InstallerError("invalid_manifest", `Ownership manifest is not an object: ${path}`);
+    const manifest = parsed;
+    if (manifest.schema_version !== MANIFEST_SCHEMA_VERSION || manifest.package !== PACKAGE_NAME || typeof manifest.version !== "string" || (manifest.state !== undefined && manifest.state !== "applying") || !manifest.files || typeof manifest.files !== "object" || Array.isArray(manifest.files))
+        throw new InstallerError("invalid_manifest", `Ownership manifest has an unexpected format: ${path}`);
+    for (const [relativePath, record] of Object.entries(manifest.files)) {
+        assertSafeRelative(relativePath);
+        if (!record || typeof record !== "object" || typeof record.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(record.sha256) || (record.previous_sha256 !== undefined && (typeof record.previous_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(record.previous_sha256))))
+            throw new InstallerError("invalid_manifest", `Ownership manifest has an invalid record: ${relativePath}`);
+    }
+    return manifest;
+}
+async function manifestFor(root) {
+    const path = manifestPath(root);
+    const content = await readRegular(path);
+    return content ? { manifest: parseManifest(content, path), sha256: sha256(content) } : {};
+}
+function makePlan(action, scope, root, operations, manifestHash) {
+    const base = { schema_version: 1, action, scope, root, operations, ...(manifestHash ? { manifest_sha256: manifestHash } : {}) };
+    return { ...base, digest: planDigest(base) };
+}
+async function installPlan(scope, cwd, home) {
+    const root = rootFor(scope, cwd, home);
+    await assertSafeAncestors(root);
+    const [owned, currentAssets] = await Promise.all([manifestFor(root), assets()]);
+    const manifest = owned.manifest;
+    const operations = [];
+    for (const asset of currentAssets) {
+        const target = destination(root, asset.relativePath);
+        const content = await readRegular(target);
+        if (!content) {
+            operations.push({ path: asset.relativePath, operation: "create", sha256: asset.sha256 });
+            continue;
+        }
+        const currentHash = sha256(content);
+        const record = manifest?.files[asset.relativePath];
+        if (!record)
+            operations.push({ path: asset.relativePath, operation: "conflict", reason: "unmanaged_file", sha256: currentHash });
+        else if (record.sha256 !== currentHash && !(manifest?.state === "applying" && record.previous_sha256 === currentHash))
+            operations.push({ path: asset.relativePath, operation: "conflict", reason: "managed_file_changed", sha256: currentHash });
+        else if (currentHash === asset.sha256)
+            operations.push({ path: asset.relativePath, operation: "unchanged", sha256: currentHash });
+        else
+            operations.push({ path: asset.relativePath, operation: "update", sha256: asset.sha256 });
+    }
+    const active = new Set(currentAssets.map((asset) => asset.relativePath));
+    for (const [relativePath, record] of Object.entries(manifest?.files ?? {}).sort(([left], [right]) => left.localeCompare(right))) {
+        if (active.has(relativePath))
+            continue;
+        const content = await readRegular(destination(root, relativePath));
+        if (!content)
+            operations.push({ path: relativePath, operation: "missing" });
+        else if (sha256(content) === record.sha256)
+            operations.push({ path: relativePath, operation: "remove", sha256: record.sha256 });
+        else
+            operations.push({ path: relativePath, operation: "conflict", reason: "managed_file_changed", sha256: sha256(content) });
+    }
+    return { plan: makePlan("install", scope, root, operations, owned.sha256), assets: currentAssets, manifest };
+}
+async function uninstallPlan(scope, cwd, home) {
+    const root = rootFor(scope, cwd, home);
+    await assertSafeAncestors(root);
+    const owned = await manifestFor(root);
+    if (!owned.manifest)
+        return { plan: makePlan("uninstall", scope, root, []) };
+    const operations = [];
+    for (const [relativePath, record] of Object.entries(owned.manifest.files).sort(([left], [right]) => left.localeCompare(right))) {
+        const content = await readRegular(destination(root, relativePath));
+        if (!content)
+            operations.push({ path: relativePath, operation: "missing" });
+        else if (sha256(content) === record.sha256)
+            operations.push({ path: relativePath, operation: "remove", sha256: record.sha256 });
+        else
+            operations.push({ path: relativePath, operation: "conflict", reason: "managed_file_changed", sha256: sha256(content) });
+    }
+    return { plan: makePlan("uninstall", scope, root, operations, owned.sha256), manifest: owned.manifest };
+}
+export async function preview(action, scope, cwd, home) {
+    return action === "install" ? (await installPlan(scope, cwd, home)).plan : (await uninstallPlan(scope, cwd, home)).plan;
+}
+async function writeAtomically(path, content) {
+    await ensureSafeDirectory(dirname(path));
+    await assertSafeAncestors(path);
+    const temporary = join(dirname(path), `.${basename(path)}.${process.pid}.${randomUUID()}.tmp`);
+    try {
+        await writeFile(temporary, content, { flag: "wx", mode: 0o644 });
+        await rename(temporary, path);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+async function writeManifest(root, manifest, existingHash, expectAbsent = false) {
+    const target = manifestPath(root);
+    const current = await readRegular(target);
+    if (existingHash && (!current || sha256(current) !== existingHash))
+        throw new InstallerError("stale_plan", "Ownership manifest changed after preview");
+    if (expectAbsent && current)
+        throw new InstallerError("stale_plan", "Ownership manifest appeared after preview");
+    const content = Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`);
+    if (!current || !current.equals(content))
+        await writeAtomically(target, content);
+    return sha256(content);
+}
+async function applyInstall(scope, expectedDigest, cwd, home) {
+    const initial = await installPlan(scope, cwd, home);
+    if (initial.plan.digest !== expectedDigest)
+        throw new InstallerError("stale_plan", "Install plan changed; request a new dry-run");
+    if (initial.plan.operations.some((item) => item.operation === "conflict"))
+        throw new InstallerError("conflict", "Install plan contains conflicts");
+    const verified = await installPlan(scope, cwd, home);
+    if (verified.plan.digest !== expectedDigest)
+        throw new InstallerError("stale_plan", "Install plan changed before apply");
+    await ensureSafeDirectory(verified.plan.root);
+    const staged = {
+        schema_version: MANIFEST_SCHEMA_VERSION,
+        package: PACKAGE_NAME,
+        version: packageVersion(),
+        state: "applying",
+        files: Object.fromEntries(verified.assets.map((asset) => {
+            const operation = verified.plan.operations.find((item) => item.path === asset.relativePath)?.operation;
+            const previous = operation === "update" ? verified.manifest?.files[asset.relativePath]?.previous_sha256 ?? verified.manifest?.files[asset.relativePath]?.sha256 : undefined;
+            return [asset.relativePath, { sha256: asset.sha256, ...(previous ? { previous_sha256: previous } : {}) }];
+        }))
+    };
+    const stagedHash = await writeManifest(verified.plan.root, staged, verified.plan.manifest_sha256, !verified.plan.manifest_sha256);
+    for (const asset of verified.assets) {
+        const item = verified.plan.operations.find((candidate) => candidate.path === asset.relativePath);
+        if (item?.operation === "create" || item?.operation === "update") {
+            const target = destination(verified.plan.root, asset.relativePath);
+            const current = await readRegular(target);
+            const expected = item.operation === "create" ? undefined : verified.manifest?.files[asset.relativePath]?.previous_sha256 ?? verified.manifest?.files[asset.relativePath]?.sha256;
+            if ((current && sha256(current)) !== expected)
+                throw new InstallerError("stale_plan", `Destination changed: ${asset.relativePath}`);
+            await writeAtomically(target, asset.content);
+        }
+    }
+    for (const item of verified.plan.operations.filter((candidate) => candidate.operation === "remove")) {
+        const target = destination(verified.plan.root, item.path);
+        const current = await readRegular(target);
+        if (!current || sha256(current) !== item.sha256)
+            throw new InstallerError("stale_plan", `Destination changed: ${item.path}`);
+        await unlink(target);
+    }
+    const completed = {
+        schema_version: MANIFEST_SCHEMA_VERSION,
+        package: PACKAGE_NAME,
+        version: packageVersion(),
+        files: Object.fromEntries(verified.assets.map((asset) => [asset.relativePath, { sha256: asset.sha256 }]))
+    };
+    await writeManifest(verified.plan.root, completed, stagedHash);
+    return verified.plan;
+}
+async function applyUninstall(scope, expectedDigest, cwd, home) {
+    const initial = await uninstallPlan(scope, cwd, home);
+    if (initial.plan.digest !== expectedDigest)
+        throw new InstallerError("stale_plan", "Uninstall plan changed; request a new dry-run");
+    if (!initial.manifest)
+        return initial.plan;
+    const verified = await uninstallPlan(scope, cwd, home);
+    if (verified.plan.digest !== expectedDigest || !verified.manifest)
+        throw new InstallerError("stale_plan", "Uninstall plan changed before apply");
+    const remaining = {};
+    for (const item of verified.plan.operations) {
+        if (item.operation === "remove") {
+            const target = destination(verified.plan.root, item.path);
+            const current = await readRegular(target);
+            if (!current || sha256(current) !== item.sha256)
+                throw new InstallerError("stale_plan", `Destination changed: ${item.path}`);
+            await unlink(target);
+        }
+        else if (item.operation === "conflict") {
+            remaining[item.path] = verified.manifest.files[item.path];
+        }
+    }
+    const manifestTarget = manifestPath(verified.plan.root);
+    const manifestContent = await readRegular(manifestTarget);
+    if (!manifestContent || sha256(manifestContent) !== verified.plan.manifest_sha256)
+        throw new InstallerError("stale_plan", "Ownership manifest changed after preview");
+    if (Object.keys(remaining).length)
+        await writeManifest(verified.plan.root, { schema_version: MANIFEST_SCHEMA_VERSION, package: PACKAGE_NAME, version: packageVersion(), files: remaining }, verified.plan.manifest_sha256);
+    else
+        await unlink(manifestTarget);
+    return verified.plan;
+}
+export async function apply(action, scope, digest, cwd, home) {
+    if (!/^[a-f0-9]{64}$/.test(digest))
+        throw new InstallerError("invalid_digest", "Confirmation digest must be a SHA-256 hex value");
+    return action === "install" ? applyInstall(scope, digest, cwd, home) : applyUninstall(scope, digest, cwd, home);
+}
+export function result(plan, applied) {
+    return JSON.stringify({ status: "ok", applied, plan }, null, 2);
+}

package/dist/plugins/autonomy-policy.d.ts

@@ -0,0 +1,21 @@
+export type AutonomyPolicyOptions = {
+    enabled?: boolean;
+    now?: () => number;
+};
+export declare function autonomyPolicy({ directory, cwd }?: {
+    directory?: string;
+    cwd?: string;
+}, options?: AutonomyPolicyOptions): Promise<{
+    "permission.ask"?: undefined;
+} | {
+    "permission.ask": (input: {
+        permission: string;
+        sessionID: string;
+        patterns?: string[];
+        metadata?: Record<string, unknown>;
+        tool?: string;
+    }, output: {
+        status: "ask" | "deny" | "allow";
+    }) => Promise<void>;
+}>;
+export default autonomyPolicy;