@kisev/agentomatic 11.0.2 → 12.0.0

package/dist/plugins/code-simplify.js

@@ -0,0 +1,49 @@
+export const CODE_SIMPLIFY_ROLES = [
+    "manager",
+    "architect",
+    "mapper",
+    "worker",
+    "review",
+    "critic",
+];
+const LADDER = `Prevention ladder for the code being written or changed, applied in order; stop at the first step that satisfies the agreed need: 1) necessity; 2) existing code; 3) standard library; 4) native platform; 5) installed dependency; 6) one line; 7) minimum. The ladder applies to the current change only; never scan repositories or unrelated files — a targeted caller search by exact name for code you are changing is not scanning. Fix the caller in the same change when that is the smaller diff. A conscious cut records a one-line SIMPLIFY marker (ceiling -> upgrade trigger) on the added or changed code in the same edit. Keep new verification proportionate: one runnable check for logic that is not evidently correct, none for a trivial one-liner. Never cancel a clarification or confirmation gate.`;
+const AUDIT = `Complexity audit only on an explicit request, only in the requested scope, always report-only. Findings are ranked one-liners: exact location, one tag of delete/stdlib/native/reuse/yagni/shrink, and the concrete simpler alternative that preserves behavior. Collect SIMPLIFY debt markers in the scope into a separate registry section, never tagged findings: location, ceiling, trigger; mark a marker no-trigger when its upgrade trigger has not fired.`;
+const GUARDS = `Search every usage, including dynamic references, before any delete finding. Never propose simplification that crosses a trust boundary, risks data loss, weakens security or accessibility, drops error handling that hides failures, or removes explicitly requested behavior.`;
+function rules(level) {
+    const parts = level === "lite" ? [LADDER] : level === "full" ? [LADDER, AUDIT] : [LADDER, AUDIT, GUARDS];
+    return `[code-simplify level=${level}]\n${parts.join("\n\n")}\n[/code-simplify]`;
+}
+function roleOf(agent) {
+    if (agent && CODE_SIMPLIFY_ROLES.includes(agent))
+        return agent;
+    return agent?.startsWith("critic-") ? "critic" : undefined;
+}
+export function codeSimplify(options = {}) {
+    const level = options.level ?? "full";
+    if (level === "off")
+        return {};
+    if (options.scope?.some((role) => !CODE_SIMPLIFY_ROLES.includes(role)))
+        throw new Error(`code-simplify scope must list roles from ${CODE_SIMPLIFY_ROLES.join(", ")}`);
+    const scope = options.scope ? new Set(options.scope) : undefined;
+    const text = rules(level);
+    return {
+        context: async (input) => {
+            if (scope) {
+                const role = roleOf(input.agent);
+                if (!role || !scope.has(role))
+                    return;
+            }
+            if (input.system.some((part) => part.type === "text" && part.text === text))
+                return;
+            input.system.push({ type: "text", text });
+        },
+    };
+}
+export default {
+    id: "agentomatic.code-simplify",
+    async setup(ctx) {
+        const hooks = await codeSimplify(ctx.options);
+        if (hooks.context)
+            await ctx.session.hook("context", hooks.context);
+    },
+};

package/dist/plugins/events.d.ts

@@ -0,0 +1,20 @@
+import type { Plugin } from "@opencode/plugin";
+import type { Result } from "@opencode/plugin/promise/tool";
+export type ToolAfter = {
+    tool: string;
+    sessionID: string;
+    input: unknown;
+} & ({
+    status: "completed";
+    result: Result;
+} | {
+    status: "error";
+    error: unknown;
+});
+export declare function toolInput(value: unknown): Record<string, unknown>;
+export declare function resultText(result: Result): string | undefined;
+export declare function replaceResultText(result: Result, text: string): Result;
+export declare function subscribeEvents(ctx: Plugin.Context, receive: (event: {
+    type: string;
+    data?: unknown;
+}) => Promise<void>): () => Promise<void>;

package/dist/plugins/events.js

@@ -0,0 +1,48 @@
+export function toolInput(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+export function resultText(result) {
+    if (typeof result.content === "string")
+        return result.content;
+    if (Array.isArray(result.content))
+        return result.content
+            .filter((part) => part.type === "text")
+            .map((part) => part.text)
+            .join("\n");
+    return undefined;
+}
+export function replaceResultText(result, text) {
+    if (!Array.isArray(result.content))
+        return { ...result, content: text };
+    let replaced = false;
+    return {
+        ...result,
+        content: result.content.flatMap((part) => {
+            if (part.type !== "text")
+                return [part];
+            if (replaced)
+                return [];
+            replaced = true;
+            return [{ type: "text", text }];
+        }),
+    };
+}
+export function subscribeEvents(ctx, receive) {
+    const controller = new AbortController();
+    const subscription = (async () => {
+        try {
+            for await (const event of ctx.event.subscribe({ signal: controller.signal }))
+                await receive(event);
+        }
+        catch (error) {
+            if (!controller.signal.aborted)
+                console.error("agentomatic event subscription failed", error);
+        }
+    })();
+    return async () => {
+        controller.abort();
+        await subscription;
+    };
+}

package/dist/plugins/rtk.d.ts

@@ -1,12 +1,5 @@
-type HookInput = {
-    tool: string;
-    args?: {
-        command?: unknown;
-    };
-};
-type HookOutput = {
-    output?: unknown;
-};
+import type { Plugin } from "@opencode/plugin";
+import { type ToolAfter } from "./events.js";
 export type RtkMethod = "compressed-rtk" | "truncated-head-tail" | "rtk-unavailable" | "ineligible" | "below-threshold";
 export type RtkStats = {
     schema_version: 1;
@@ -34,8 +27,12 @@ export declare function rtkCharsSaved(stats: RtkStats): number;
 export declare function rtkTokensSavedEstimate(stats: RtkStats): number;
 export declare function readRtkStats(path?: string): Promise<RtkStats | undefined>;
 export declare function rtk(options?: RtkOptions): Promise<{
-    "tool.execute.after"?: undefined;
+    "execute.after"?: undefined;
 } | {
-    "tool.execute.after": (input: HookInput, output: HookOutput) => Promise<void>;
+    "execute.after": (input: ToolAfter) => Promise<void>;
 }>;
-export default rtk;
+declare const _default: {
+    id: string;
+    setup(ctx: Plugin.Context): Promise<void>;
+};
+export default _default;

package/dist/plugins/rtk.js

@@ -1,3 +1,4 @@
+import { resultText, replaceResultText, toolInput } from "./events.js";
 import { spawn } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
@@ -137,26 +138,33 @@ export async function rtk(options = {}) {
         ((selected, input) => external(options.bin ?? "rtk", selected, input));
     const statsPath = options.statsPath === null ? undefined : (options.statsPath ?? rtkStatsPath());
     return {
-        "tool.execute.after": async (input, output) => {
+        "execute.after": async (input) => {
+            if (input.status !== "completed")
+                return;
+            const output = { output: resultText(input.result) };
             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" ||
+                if (input.tool !== "shell" ||
                     typeof output.output !== "string" ||
                     output.output.length < (options.threshold ?? THRESHOLD)) {
-                    if (input.tool === "bash" && typeof output.output === "string" && statsPath)
+                    if (input.tool === "shell" && typeof output.output === "string" && statsPath)
                         await recordStats(statsPath, "below-threshold", output.output.length, output.output.length);
+                    if (output.output !== undefined)
+                        input.result = replaceResultText(input.result, output.output);
                     return;
                 }
-                const selected = typeof input.args?.command === "string" ? filter(input.args.command) : undefined;
+                const command = toolInput(input.input).command;
+                const selected = typeof command === "string" ? filter(command) : undefined;
                 const compressed = selected ? await run(selected, output.output) : undefined;
                 const result = compressed && compressed.length < output.output.length
                     ? compressed
                     : truncate(output.output);
                 const originalSize = output.output.length;
                 output.output = `${result}\n[rtk: compressed method=${result === compressed ? `rtk/${selected}` : "head+tail"}; sizes=${originalSize}->${result.length}; evidence_complete=false; loss=possible]`;
+                input.result = replaceResultText(input.result, output.output);
                 if (statsPath) {
                     const method = result === compressed
                         ? "compressed-rtk"
@@ -174,4 +182,11 @@ export async function rtk(options = {}) {
         },
     };
 }
-export default rtk;
+export default {
+    id: "agentomatic.rtk",
+    async setup(ctx) {
+        const hooks = await rtk(ctx.options);
+        if (hooks["execute.after"])
+            await ctx.tool.hook("execute.after", hooks["execute.after"]);
+    },
+};

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

@@ -1,22 +1,32 @@
+import type { Plugin } from "@opencode/plugin";
+import { type ToolAfter } from "./events.js";
 export type RulesInjectorOptions = {
     budget?: number;
     cwd?: string;
     enabled?: boolean;
 };
 export declare function rulesInjector(options?: RulesInjectorOptions): Promise<{
-    "tool.execute.after"?: undefined;
+    "execute.after"?: undefined;
     event?: undefined;
-    "experimental.chat.system.transform"?: undefined;
+    context?: undefined;
 } | {
-    "tool.execute.after": (input: unknown, result: unknown) => Promise<void>;
-    event: ({ event, }: {
-        event?: {
-            type?: string;
-            properties?: Record<string, unknown>;
-        };
+    "execute.after": (input: ToolAfter & {
+        directory?: string;
     }) => Promise<void>;
-    "experimental.chat.system.transform": (input: unknown, result: {
-        system?: unknown[];
+    event: (event: {
+        type: string;
+        data?: unknown;
+    }) => Promise<void>;
+    context: (input: {
+        sessionID: string;
+        system: Array<{
+            type: "text";
+            text: string;
+        }>;
     }) => Promise<void>;
 }>;
-export default rulesInjector;
+declare const _default: {
+    id: string;
+    setup(ctx: Plugin.Context): Promise<(() => Promise<void>) | undefined>;
+};
+export default _default;

package/dist/plugins/rules-injector.js

@@ -1,3 +1,4 @@
+import { resultText, replaceResultText, subscribeEvents, toolInput, } from "./events.js";
 import { lstat, readFile, realpath } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, resolve } from "node:path";
@@ -9,20 +10,6 @@ function sessionID(value) {
             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}]`;
 }
@@ -44,16 +31,19 @@ export async function rulesInjector(options = {}) {
         }
         return item;
     };
-    const inject = async (input, result) => {
-        const call = input;
-        if (call?.tool !== "read" && call?.tool !== "edit")
+    const inject = async (input) => {
+        if (input.status !== "completed" || (input.tool !== "read" && input.tool !== "edit"))
             return;
-        const identifier = sessionID(input);
-        const target = pathOf(input, result);
-        if (!identifier || !target)
+        const identifier = input.sessionID;
+        const target = toolInput(input.input).path;
+        const original = resultText(input.result);
+        if (!identifier || typeof target !== "string" || original === undefined)
             return;
+        const output = (text) => {
+            input.result = replaceResultText(input.result, `${original}\n${text}`);
+        };
         try {
-            const native = typeof call?.directory === "string" ? call.directory : cwd;
+            const native = input.directory ?? cwd;
             const paths = [];
             let current = dirname(resolve(native, target));
             while (true) {
@@ -103,29 +93,51 @@ export async function rulesInjector(options = {}) {
                 }
             }
             if (additions.length)
-                output(result, additions.join("\n\n"));
+                output(additions.join("\n\n"));
         }
         catch (error) {
-            output(result, `[rules-injector warning] cannot read AGENTS.md: ${String(error)}`);
+            output(`[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);
+        "execute.after": inject,
+        event: async (event) => {
+            if (event.type === "session.compacted" || event.type.includes("compaction")) {
+                const identifier = sessionID(event.data);
                 if (identifier)
                     state(identifier).replay = true;
             }
         },
-        "experimental.chat.system.transform": async (input, result) => {
+        context: async (input) => {
             const identifier = sessionID(input);
-            if (!identifier || !state(identifier).replay || !Array.isArray(result.system))
+            if (!identifier || !state(identifier).replay)
                 return;
             for (const rule of state(identifier).loaded.values())
-                result.system.push(block(rule));
+                input.system.push({ type: "text", text: block(rule) });
             state(identifier).replay = false;
         },
     };
 }
-export default rulesInjector;
+export default {
+    id: "agentomatic.rules-injector",
+    async setup(ctx) {
+        const hooks = await rulesInjector({ ...ctx.options, cwd: ctx.location.directory });
+        if (hooks["execute.after"])
+            await ctx.tool.hook("execute.after", async (event) => {
+                if (event.status !== "completed" || (event.tool !== "read" && event.tool !== "edit"))
+                    return;
+                const session = await ctx.session
+                    .get({ sessionID: event.sessionID })
+                    .catch(() => undefined);
+                if (session) {
+                    const scoped = { ...event, directory: session.location.directory };
+                    await hooks["execute.after"](scoped);
+                    event.result = scoped.result;
+                }
+            });
+        if (hooks.context)
+            await ctx.session.hook("context", hooks.context);
+        if (hooks.event)
+            return subscribeEvents(ctx, hooks.event);
+    },
+};

package/dist/plugins/zed-bell.d.ts

@@ -1,13 +1,16 @@
+import type { Plugin } from "@opencode/plugin";
 export type ZedBellOptions = {
     enabled?: boolean;
 };
 export declare function zedBell(options?: ZedBellOptions): Promise<{
     event?: undefined;
 } | {
-    event: ({ event }: {
-        event: {
-            type?: string;
-        };
+    event: (event: {
+        type: string;
     }) => Promise<void>;
 }>;
-export default zedBell;
+declare const _default: {
+    id: string;
+    setup(ctx: Plugin.Context): Promise<(() => Promise<void>) | undefined>;
+};
+export default _default;

package/dist/plugins/zed-bell.js

@@ -1,8 +1,9 @@
+import { subscribeEvents } from "./events.js";
 export async function zedBell(options = {}) {
     if (!options.enabled)
         return {};
     return {
-        event: async ({ event }) => {
+        event: async (event) => {
             if (event.type !== "session.idle" && event.type !== "permission.asked")
                 return;
             const acp = process.env.OPENCODE_CLIENT === "acp" || process.argv.includes("acp");
@@ -11,4 +12,11 @@ export async function zedBell(options = {}) {
         },
     };
 }
-export default zedBell;
+export default {
+    id: "agentomatic.zed-bell",
+    async setup(ctx) {
+        const hooks = await zedBell(ctx.options);
+        if (hooks.event)
+            return subscribeEvents(ctx, hooks.event);
+    },
+};

package/dist/reconcile.d.ts

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

package/dist/reconcile.js

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

package/dist/registry.d.ts

@@ -9,6 +9,7 @@ export type PackageCommandRegistration = {
     body: readonly string[];
 };
 export type CommandRegistration = SkillCommandRegistration | PackageCommandRegistration;
+export declare const COMMANDLESS_SKILLS: readonly ["debugging", "tdd", "verification"];
 export declare const COMMAND_REGISTRY: ({
     name: string;
     description: string;

package/dist/registry.js

@@ -4,13 +4,16 @@ function description(english, russianTrigger) {
 }
 const SKILL_NAMES = [
     "agents-md",
+    "asd-ste100",
     "askme",
     "ast-grep",
     "code-explain",
     "code-review",
+    "code-simplify",
     "commit-msg",
     "docs-prepare",
     "docs-review",
+    "eli5",
     "goal",
     "humanize",
     "mattermost",
@@ -19,10 +22,10 @@ const SKILL_NAMES = [
     "release-prepare",
     "release-review",
     "rtk",
-    "skill-improve",
+    "skill-doctor",
     "slides-prompts-prepare",
     "spec-manage",
-    "stopit",
+    "handoff",
     "briefing",
     "task-prepare",
     "task-review",
@@ -42,13 +45,21 @@ const SKILL_NAMES = [
     "team-sprint-close",
     "team-sprint-start",
 ];
+// Skills that opt out of command ownership through their frontmatter
+// `metadata.command: false` label (the inspired-by era). They are installed
+// like every other skill and load through the native Skill tool; only the
+// thin slash-command adapter is absent. Keep this list in sync with the
+// frontmatter labels; tests pin the two-way mapping.
+export const COMMANDLESS_SKILLS = ["debugging", "tdd", "verification"];
 const COMMANDS = [
     ...SKILL_NAMES.map((name) => ({
         name,
         skill: name,
         description: name === "spec-manage"
             ? description("Create greenfield specs, onboard an existing project, update target state, or review specs", "спецификация проекта")
-            : description(`Run the ${name} Agent Skill`, name),
+            : name === "code-simplify"
+                ? description("Apply the passive prevention ladder while coding and audit a requested scope for unnecessary complexity on an explicit request", "упростить код")
+                : description(`Run the ${name} Agent Skill`, name),
     })),
     {
         name: "rtk-stats",
@@ -57,7 +68,7 @@ const COMMANDS = [
             "Show the RTK output-compression observability summary for this host.",
             `Run \`npx --yes @kisev/agentomatic@${requirePackageVersion()} doctor --json\` and render the \`rtk.observability\` check as a short human summary: wrapper status, rtk binary availability, event counters, characters saved, and the token estimate.`,
             "When the doctor command is unavailable, read the stats file directly: `$XDG_STATE_HOME/opencode/skills/rtk/stats.json`, or `~/.local/state/opencode/skills/rtk/stats.json` when that variable is unset.",
-            "Zero counters with an active wrapper mean no verbose bash output has been compressed yet.",
+            "Zero counters with an active wrapper mean no verbose shell output has been compressed yet.",
             "The `/rtk` command still loads the portable rtk skill and is unaffected by this summary.",
         ],
     },
@@ -83,7 +94,12 @@ export function renderCommand(command) {
             "Natural requests are supported. Explicit mode and scope arguments are passed unchanged; the skill verifies safety preconditions and asks before writing if intent remains ambiguous.",
             "Examples: `Create canonical specs for this empty project`; `Document this existing service`; `Change the canonical timeout`; `Audit specs without changes`.",
         ]
-        : [];
+        : command.name === "code-simplify"
+            ? [
+                "Prevention applies passively while coding: the ladder runs on the current change without scanning anything; a targeted caller search by exact name for the code being changed is not scanning, and a conscious cut records a SIMPLIFY debt marker in the same edit.",
+                "Audit is explicit and report-only: name the scope, receive ranked one-line tagged findings plus a separate debt-marker registry, and change nothing.",
+            ]
+            : [];
     return [
         "---",
         `description: ${command.description}`,

package/dist/routing.d.ts

@@ -123,11 +123,13 @@ export declare class ExecutionCardLifecycle {
 }
 export declare class RoutingGate {
     #private;
+    requiresReceipt(sessionID: string, agent: string | undefined): boolean;
+    hasActive(sessionID: string, agent: string, callID?: string): boolean;
     preview(input: RoutingInput): RoutingDecision;
     dispatch(input: RoutingInput, provided: unknown): RoutingDecision;
     grant(sessionID: string, decision: RoutingDecision, context?: ReceiptContext): RoutingReceipt;
-    cancel(sessionID: string): void;
-    consume(sessionID: string, agent: string, context?: ReceiptContext): void;
-    complete(sessionID: string, agent: string, output: unknown): void;
+    cancel(sessionID: string, callID?: string): void;
+    consume(sessionID: string, agent: string, context?: ReceiptContext, callID?: string): void;
+    complete(sessionID: string, agent: string, output: unknown, callID?: string): void;
 }
 export {};