@kisev/skills-opencode 1.0.0

package/dist/plugins/autonomy-policy.js

@@ -0,0 +1,71 @@
+import { readFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { appendState, configRoot, stateRoot, readState, writeState } from "../runtime/state.js";
+function match(pattern, value) { return new RegExp(`^${pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`).test(value); }
+function rule(rules, tool, operation) { return [...rules].reverse().find((item) => match(item.tool, tool) && match(item.operation, operation)); }
+function valid(value) {
+    const item = value;
+    return Boolean(item && item.schema_version === 1 && item.on_exhausted === "ask_pause" && Number.isInteger(item.max_mutations_per_session) && Number.isInteger(item.max_mutations_per_hour) && Array.isArray(item.always_ask) && Array.isArray(item.classifications));
+}
+export async function autonomyPolicy({ directory, cwd } = {}, options = {}) {
+    if (!options.enabled)
+        return {};
+    const project = resolve(directory ?? cwd ?? process.cwd());
+    const root = stateRoot("autonomy-policy");
+    const load = async () => {
+        let current = project;
+        while (true) {
+            try {
+                const value = JSON.parse(await readFile(resolve(current, ".opencode", "autonomy-policy.json"), "utf8"));
+                if (valid(value))
+                    return value;
+                return undefined;
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    return undefined;
+            }
+            const parent = dirname(current);
+            if (parent === current)
+                break;
+            current = parent;
+        }
+        try {
+            const value = JSON.parse(await readFile(resolve(configRoot("autonomy-policy"), "autonomy-policy.json"), "utf8"));
+            return valid(value) ? value : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const inspect = async (input, output) => {
+        const policy = await load();
+        const tool = input.tool ?? input.permission;
+        const operation = typeof input.metadata?.operation === "string" ? input.metadata.operation : input.patterns?.[0] ?? input.permission;
+        const classification = policy && rule(policy.classifications, tool, operation);
+        if (!policy || !classification || classification.class === "destructive" || rule(policy.always_ask, tool, operation)) {
+            output.status = "ask";
+            return;
+        }
+        if (classification.class === "read" || output.status === "deny")
+            return;
+        const path = resolve(root, `${encodeURIComponent(input.sessionID)}.json`);
+        const previous = await readState(path, root);
+        const state = previous && previous.schema_version === 1 ? previous : { schema_version: 1, session_id: input.sessionID, mutations: 0, timestamps: [], paused: false };
+        const current = options.now?.() ?? Date.now();
+        state.timestamps = state.timestamps.filter((value) => value > current - 3_600_000);
+        if ((policy.max_mutations_per_session > 0 && state.mutations >= policy.max_mutations_per_session) || (policy.max_mutations_per_hour > 0 && state.timestamps.length >= policy.max_mutations_per_hour)) {
+            state.paused = true;
+            await writeState(path, root, state);
+            await appendState(resolve(root, "receipts.jsonl"), root, { schema_version: 1, session_id: input.sessionID, tool, class: "mutate", decision: "ask", reason: "budget-exhausted", at: new Date().toISOString() });
+            output.status = "ask";
+            return;
+        }
+        state.mutations += 1;
+        state.timestamps.push(current);
+        await writeState(path, root, state);
+        await appendState(resolve(root, "receipts.jsonl"), root, { schema_version: 1, session_id: input.sessionID, tool, class: "mutate", decision: "passed", reason: "budget-available", at: new Date().toISOString() });
+    };
+    return { "permission.ask": inspect };
+}
+export default autonomyPolicy;

package/dist/plugins/background-attempts.d.ts

@@ -0,0 +1,76 @@
+type Client = {
+    session: {
+        create?: (input: {
+            query?: Record<string, unknown>;
+            body: Record<string, unknown>;
+        }) => Promise<unknown>;
+        prompt: (input: {
+            path: {
+                id: string;
+            };
+            body: Record<string, unknown>;
+        }) => Promise<unknown>;
+        abort?: (input: {
+            path: {
+                id: string;
+            };
+        }) => Promise<unknown>;
+    };
+};
+export type BackgroundAttemptsOptions = {
+    enabled?: boolean;
+    concurrency?: number;
+    parentConcurrency?: number;
+};
+export declare function backgroundAttempts({ client, directory, cwd }: {
+    client: Client;
+    directory?: string;
+    cwd?: string;
+}, options?: BackgroundAttemptsOptions): Promise<{
+    tool?: undefined;
+    "tool.execute.before"?: undefined;
+} | {
+    tool: {
+        background_attempts: {
+            description: string;
+            args: {
+                action: import("zod").ZodEnum<{
+                    cancel: "cancel";
+                    list: "list";
+                    result: "result";
+                    status: "status";
+                    start: "start";
+                    retry: "retry";
+                }>;
+                task: import("zod").ZodOptional<import("zod").ZodString>;
+                category: import("zod").ZodOptional<import("zod").ZodString>;
+                decision: import("zod").ZodOptional<import("zod").ZodAny>;
+                priority: import("zod").ZodOptional<import("zod").ZodNumber>;
+                read_only: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                attempt_id: import("zod").ZodOptional<import("zod").ZodString>;
+                expected_revision: import("zod").ZodOptional<import("zod").ZodNumber>;
+                expected_status: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    queued: "queued";
+                    running: "running";
+                    waiting: "waiting";
+                }>>;
+            };
+            execute(args: {
+                action: "cancel" | "list" | "result" | "status" | "start" | "retry";
+                task?: string | undefined;
+                category?: string | undefined;
+                decision?: any;
+                priority?: number | undefined;
+                read_only?: boolean | undefined;
+                attempt_id?: string | undefined;
+                expected_revision?: number | undefined;
+                expected_status?: "queued" | "running" | "waiting" | undefined;
+            }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+        };
+    };
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID: string;
+    }) => Promise<void>;
+}>;
+export default backgroundAttempts;

package/dist/plugins/background-attempts.js

@@ -0,0 +1,113 @@
+import { randomUUID } from "node:crypto";
+import { join, resolve } from "node:path";
+import { tool } from "@opencode-ai/plugin";
+import { appendState, listState, readState, stateRoot, writeState } from "../runtime/state.js";
+const TERMINAL = new Set(["completed", "failed", "cancelled", "orphaned"]);
+const LIMIT = 2;
+function id(value) {
+    const item = (value?.data ?? value);
+    return typeof item?.id === "string" && item.id ? item.id : undefined;
+}
+export async function backgroundAttempts({ client, directory, cwd }, options = {}) {
+    if (!options.enabled)
+        return {};
+    const project = resolve(directory ?? cwd ?? process.cwd());
+    const root = stateRoot("attempt");
+    const attemptsRoot = join(root, "attempts");
+    const load = async (attemptID) => readState(join(attemptsRoot, `${attemptID}.json`), root);
+    const all = async () => (await Promise.all((await listState(attemptsRoot)).map((name) => load(name.slice(0, -5))))).filter((item) => Boolean(item));
+    const save = async (item, event) => {
+        item.receipts.push({ at: new Date().toISOString(), event, status: item.status, revision: item.revision });
+        await writeState(join(attemptsRoot, `${item.attempt_id}.json`), root, item);
+        await appendState(join(root, "receipts.jsonl"), root, { attempt_id: item.attempt_id, event, status: item.status, revision: item.revision, at: new Date().toISOString() });
+    };
+    const transition = async (item, status, event) => {
+        if (!TERMINAL.has(item.status)) {
+            item.status = status;
+            item.revision += 1;
+        }
+        await save(item, event);
+    };
+    const pump = async () => {
+        const records = await all();
+        const running = records.filter((item) => item.status === "running" || item.status === "waiting");
+        const limit = options.concurrency ?? LIMIT;
+        for (const item of records.filter((candidate) => candidate.project === project && candidate.status === "queued").sort((left, right) => left.priority - right.priority || left.created_at.localeCompare(right.created_at))) {
+            if (running.length >= limit || running.filter((candidate) => candidate.parent_session_id === item.parent_session_id).length >= (options.parentConcurrency ?? 1))
+                continue;
+            if (!client.session.create) {
+                item.error = { message: "session.create unavailable", retryable: false };
+                await transition(item, "failed", "dispatch.error");
+                continue;
+            }
+            const created = await client.session.create({ query: { directory: item.directory }, body: { title: `background-attempt:${item.attempt_id}`, parentID: item.parent_session_id, directory: item.directory } });
+            const child = id(created);
+            if (!child) {
+                item.error = { message: "OpenCode did not return child session id", retryable: false };
+                await transition(item, "failed", "dispatch.error");
+                continue;
+            }
+            item.child_session_id = child;
+            await transition(item, "running", "session.created");
+            running.push(item);
+            void client.session.prompt({ path: { id: child }, body: { agent: item.agent, parts: [{ type: "text", text: `Complete this bounded background attempt. Do not create recursive attempts.\nTask:\n${item.task}` }] } }).catch(async (error) => {
+                item.error = { message: String(error), retryable: false };
+                await transition(item, "failed", "session.prompt.error");
+            });
+        }
+    };
+    const attempts = tool({
+        description: "Start and manage bounded routed background attempts.",
+        args: { action: tool.schema.enum(["start", "list", "status", "result", "cancel", "retry"]), task: tool.schema.string().optional(), category: tool.schema.string().optional(), decision: tool.schema.any().optional(), priority: tool.schema.number().optional(), read_only: tool.schema.boolean().optional(), attempt_id: tool.schema.string().optional(), expected_revision: tool.schema.number().optional(), expected_status: tool.schema.enum(["queued", "running", "waiting"]).optional() },
+        async execute(args, context) {
+            if (args.action === "start") {
+                const decision = args.decision;
+                if (!args.task || !args.category || !decision || typeof decision.agent !== "string" || typeof decision.decision_digest !== "string")
+                    throw new Error("start requires a routed decision, task and category");
+                const item = { schema_version: 1, attempt_id: randomUUID(), parent_session_id: context.sessionID, project, directory: project, task: args.task, category: args.category, agent: decision.agent, routing_decision_digest: decision.decision_digest, status: "queued", revision: 0, priority: args.priority ?? 0, read_only: args.read_only !== false, created_at: new Date().toISOString(), receipts: [], retry_number: 0 };
+                await save(item, "attempt.queued");
+                await pump();
+                const current = await load(item.attempt_id);
+                return JSON.stringify({ attempt_id: item.attempt_id, status: current?.status ?? "queued" });
+            }
+            const candidates = (await all()).filter((item) => item.project === project && item.parent_session_id === context.sessionID);
+            if (args.action === "list")
+                return JSON.stringify(candidates.map(({ task: _task, receipts: _receipts, ...item }) => item));
+            const item = candidates.find((candidate) => candidate.attempt_id === args.attempt_id);
+            if (!item)
+                throw new Error("attempt not found in current parent session/project");
+            if (args.action === "retry") {
+                if (item.status !== "failed" || item.read_only !== true || item.error?.retryable !== true || item.retry_number >= 2)
+                    throw new Error("retry requires a failed, read-only, retryable attempt within its retry limit");
+                const retry = { ...item, attempt_id: randomUUID(), parent_attempt_id: item.attempt_id, retry_number: item.retry_number + 1, status: "queued", revision: 0, created_at: new Date().toISOString(), receipts: [], child_session_id: undefined, workspace_id: undefined, result: undefined, error: undefined };
+                await save(retry, "attempt.retry.queued");
+                await pump();
+                return JSON.stringify({ attempt_id: retry.attempt_id, parent_attempt_id: item.attempt_id, status: (await load(retry.attempt_id))?.status ?? "queued" });
+            }
+            if (args.action === "status")
+                return JSON.stringify(item);
+            if (args.action === "result")
+                return JSON.stringify(TERMINAL.has(item.status) ? { attempt_id: item.attempt_id, status: item.status, terminal: true, result: item.result, session_id: item.child_session_id, workspace_id: item.workspace_id } : { attempt_id: item.attempt_id, status: item.status, terminal: false });
+            if (TERMINAL.has(item.status))
+                return JSON.stringify({ attempt_id: item.attempt_id, status: item.status, cancelled: false, reason: "terminal" });
+            if (item.revision !== args.expected_revision || item.status !== args.expected_status)
+                throw new Error("attempt changed since cancellation preview");
+            if (item.status === "queued")
+                await transition(item, "cancelled", "cancel.confirmed");
+            else if (item.child_session_id && client.session.abort) {
+                await client.session.abort({ path: { id: item.child_session_id } });
+                await transition(item, "cancelled", "cancel.confirmed");
+            }
+            else
+                await transition(item, "orphaned", "cancel.unconfirmed");
+            return JSON.stringify({ attempt_id: item.attempt_id, status: item.status });
+        },
+    });
+    return { tool: { background_attempts: attempts }, "tool.execute.before": async (input) => {
+            if (input.tool !== "background_attempts" && input.tool !== "task")
+                return;
+            if ((await all()).some((item) => item.child_session_id === input.sessionID))
+                throw new Error("child attempts cannot create recursive attempts or tasks");
+        } };
+}
+export default backgroundAttempts;

package/dist/plugins/goal-loop.d.ts

@@ -0,0 +1,51 @@
+type Goal = {
+    schema_version: 1;
+    goal_id: string;
+    session_id: string;
+    status: "running" | "paused" | "complete" | "blocked";
+    revision: number;
+    limits: {
+        turn_cap: number;
+        token_budget: number;
+    };
+    usage: {
+        turns: number;
+        tokens: number;
+    };
+    receipts: Array<Record<string, unknown>>;
+    updated_at: string;
+};
+type Client = {
+    session: {
+        messages: (input: {
+            path: {
+                id: string;
+            };
+        }) => Promise<unknown>;
+        prompt: (input: {
+            path: {
+                id: string;
+            };
+            body: Record<string, unknown>;
+        }) => Promise<unknown>;
+    };
+};
+export type GoalLoopOptions = {
+    enabled?: boolean;
+    quietWindowMs?: number;
+    now?: () => number;
+    audit?: (goal: Readonly<Goal>) => Promise<"continue" | "complete" | "blocked">;
+};
+export declare function goalLoop({ client }: {
+    client: Client;
+}, options?: GoalLoopOptions): Promise<{
+    event?: undefined;
+} | {
+    event: ({ event }: {
+        event: {
+            type?: string;
+            properties?: Record<string, unknown>;
+        };
+    }) => Promise<void>;
+}>;
+export default goalLoop;

package/dist/plugins/goal-loop.js

@@ -0,0 +1,87 @@
+import { join } from "node:path";
+import { listState, readState, stateRoot, writeState } from "../runtime/state.js";
+function sessionID(event) {
+    const value = event.properties?.sessionID ?? event.properties?.session_id;
+    return typeof value === "string" && value ? value : undefined;
+}
+function tokens(messages) {
+    const entries = Array.isArray(messages) ? messages : messages?.data;
+    if (!Array.isArray(entries))
+        return 0;
+    const last = [...entries].reverse().find((entry) => (entry?.info?.role === "assistant"));
+    const value = last?.info?.tokens?.total ?? last?.info?.tokens?.output;
+    return typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : 0;
+}
+export async function goalLoop({ client }, options = {}) {
+    if (!options.enabled)
+        return {};
+    const root = stateRoot("goal");
+    const timers = new Map();
+    const lookup = async (session) => {
+        for (const name of await listState(root)) {
+            const state = await readState(join(root, name), root);
+            if (state?.schema_version === 1 && state.session_id === session)
+                return { state, path: join(root, name) };
+        }
+        return undefined;
+    };
+    const settle = async (session, status, note) => {
+        const item = await lookup(session);
+        if (!item || item.state.status !== "running")
+            return;
+        item.state.status = status;
+        item.state.revision += 1;
+        item.state.updated_at = new Date().toISOString();
+        item.state.receipts.push({ revision: item.state.revision, status, note, at: item.state.updated_at });
+        await writeState(item.path, root, item.state);
+    };
+    const run = async (session) => {
+        timers.delete(session);
+        const item = await lookup(session);
+        if (!item || item.state.status !== "running")
+            return;
+        try {
+            const used = tokens(await client.session.messages({ path: { id: session } }));
+            item.state.usage.turns += 1;
+            item.state.usage.tokens += used;
+            item.state.revision += 1;
+            item.state.updated_at = new Date().toISOString();
+            item.state.receipts.push({ revision: item.state.revision, status: "running", note: "turn audited", at: item.state.updated_at });
+            await writeState(item.path, root, item.state);
+            if (item.state.usage.turns >= item.state.limits.turn_cap)
+                return settle(session, "blocked", "turn cap reached");
+            if (item.state.limits.token_budget > 0 && item.state.usage.tokens >= item.state.limits.token_budget)
+                return settle(session, "blocked", "token budget reached");
+            const verdict = await (options.audit?.(item.state) ?? Promise.resolve("continue"));
+            if (verdict === "complete" || verdict === "blocked")
+                return settle(session, verdict, "audit verdict");
+            await client.session.prompt({ path: { id: session }, body: { parts: [{ type: "text", text: "Continue the current goal within its declared constraints and boundaries." }] } });
+        }
+        catch (error) {
+            await settle(session, "blocked", String(error));
+        }
+    };
+    const schedule = (session) => {
+        const previous = timers.get(session);
+        if (previous)
+            clearTimeout(previous);
+        timers.set(session, setTimeout(() => void run(session), options.quietWindowMs ?? 250));
+    };
+    return { event: async ({ event }) => {
+            const session = sessionID(event);
+            if (!session)
+                return;
+            if (event.type === "session.abort" || event.type === "session.aborted") {
+                const timer = timers.get(session);
+                if (timer)
+                    clearTimeout(timer);
+                timers.delete(session);
+                await settle(session, "paused", "user abort");
+            }
+            else if (event.type === "session.error")
+                await settle(session, "blocked", "session error");
+            else if (event.type === "session.idle")
+                schedule(session);
+        } };
+}
+export default goalLoop;

package/dist/plugins/rtk.d.ts

@@ -0,0 +1,21 @@
+type HookInput = {
+    tool: string;
+    args?: {
+        command?: unknown;
+    };
+};
+type HookOutput = {
+    output?: unknown;
+};
+export type RtkOptions = {
+    enabled?: boolean;
+    bin?: string;
+    threshold?: number;
+    run?: (filter: string, input: string) => Promise<string | undefined>;
+};
+export declare function rtk(options?: RtkOptions): Promise<{
+    "tool.execute.after"?: undefined;
+} | {
+    "tool.execute.after": (input: HookInput, output: HookOutput) => Promise<void>;
+}>;
+export default rtk;

package/dist/plugins/rtk.js

@@ -0,0 +1,48 @@
+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" },
+];
+function filter(command) {
+    if (/[|;$&\n()`]/.test(command))
+        return undefined;
+    const values = command.trim().split(/\s+/);
+    return FILTERS.find((item) => item.prefix.every((part, index) => values[index] === part))?.filter;
+}
+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("")}`;
+}
+function external(binary, selected, input) {
+    return new Promise((done) => {
+        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.once("error", () => done(undefined));
+        child.once("close", (code) => done(code === 0 ? output : undefined));
+        child.stdin.end(input, "utf8");
+    });
+}
+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) => {
+            try {
+                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))
+                    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);
+                output.output = `${result}\n[rtk: compressed ${output.output.length} chars using ${compressed ? `rtk/${selected}` : "head+tail"}]`;
+            }
+            catch { /* RTK is fail-open: preserve original tool output on plugin failure. */ }
+        } };
+}
+export default rtk;

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

@@ -0,0 +1,22 @@
+export type RulesInjectorOptions = {
+    budget?: number;
+    cwd?: string;
+    enabled?: boolean;
+};
+export declare function rulesInjector(options?: RulesInjectorOptions): Promise<{
+    "tool.execute.after"?: undefined;
+    event?: undefined;
+    "experimental.chat.system.transform"?: undefined;
+} | {
+    "tool.execute.after": (input: unknown, result: unknown) => Promise<void>;
+    event: ({ event }: {
+        event?: {
+            type?: string;
+            properties?: Record<string, unknown>;
+        };
+    }) => Promise<void>;
+    "experimental.chat.system.transform": (input: unknown, result: {
+        system?: unknown[];
+    }) => Promise<void>;
+}>;
+export default rulesInjector;

package/dist/plugins/rules-injector.js

@@ -0,0 +1,96 @@
+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}]`; }
+export async function rulesInjector(options = {}) {
+    if (options.enabled === false)
+        return {};
+    const budget = options.budget ?? 12_000;
+    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 inject = async (input, result) => {
+        const call = input;
+        if (call?.tool !== "read" && call?.tool !== "edit")
+            return;
+        const identifier = sessionID(input);
+        const target = pathOf(input, result);
+        if (!identifier || !target)
+            return;
+        try {
+            const native = typeof call?.directory === "string" ? call.directory : cwd;
+            const paths = [];
+            let current = dirname(resolve(native, target));
+            while (true) {
+                const candidate = resolve(current, NAME);
+                try {
+                    const info = await lstat(candidate);
+                    if (info.isFile() && candidate !== resolve(native, NAME) && candidate !== resolve(global, NAME))
+                        paths.push(await realpath(candidate));
+                }
+                catch (error) {
+                    if (error.code !== "ENOENT")
+                        throw error;
+                }
+                const parent = dirname(current);
+                if (parent === current)
+                    break;
+                current = parent;
+            }
+            const currentState = state(identifier);
+            const additions = [];
+            for (const path of paths.reverse()) {
+                if (currentState.injected.has(path))
+                    continue;
+                try {
+                    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 text = block(rule);
+                    if (currentState.used + text.length > budget) {
+                        additions.push(`[rules-injector warning] context budget exhausted; skipped ${path}`);
+                        continue;
+                    }
+                    currentState.loaded.set(path, rule);
+                    currentState.injected.add(path);
+                    currentState.used += text.length;
+                    additions.push(text);
+                }
+                catch (error) {
+                    additions.push(`[rules-injector warning] cannot read ${path}: ${String(error)}`);
+                }
+            }
+            if (additions.length)
+                output(result, additions.join("\n\n"));
+        }
+        catch (error) {
+            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; } };
+}
+export default rulesInjector;

package/dist/plugins/schedule.d.ts

@@ -0,0 +1,36 @@
+type Client = {
+    session: {
+        create?: (input: {
+            body: Record<string, unknown>;
+        }) => Promise<unknown>;
+        prompt: (input: {
+            path: {
+                id: string;
+            };
+            body: Record<string, unknown>;
+        }) => Promise<unknown>;
+        abort?: (input: {
+            path: {
+                id: string;
+            };
+        }) => Promise<unknown>;
+    };
+};
+export type SchedulerOptions = {
+    enabled?: boolean;
+    clock?: () => number;
+};
+export declare function scheduler({ client, directory, cwd }: {
+    client: Client;
+    directory?: string;
+    cwd?: string;
+}, options?: SchedulerOptions): Promise<{
+    event?: undefined;
+} | {
+    event: ({ event }: {
+        event: {
+            type?: string;
+        };
+    }) => Promise<void>;
+}>;
+export default scheduler;