heedvane 0.0.0-stage → 0.2.0

package/dist/state.js

@@ -0,0 +1,118 @@
+import { mkdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import writeFileAtomic from "write-file-atomic";
+import { errorMessage, isRecord } from "./guards.js";
+/** Error for a state.json that exists but cannot be trusted. Carries the exact remediation. */
+export class HeedStateCorruptError extends Error {
+    path;
+    constructor(path, reason) {
+        super(`corrupt heedvane state file at ${path}: ${reason}. Fix: delete ${path} or run npx heedvane doctor`);
+        this.name = "HeedStateCorruptError";
+        this.path = path;
+    }
+}
+export function statePath(root) {
+    return join(root, "state.json");
+}
+/** Protocol version stamped into new state files. */
+const PROTOCOL_VERSION = "1";
+/**
+ * A fresh, empty state for a new install. Endpoint starts unassigned
+ * (port 0 / empty token) until the listener resolves and persists one.
+ */
+export function emptyState(skillDigest = null) {
+    return {
+        schemaVersion: 1,
+        protocolVersion: PROTOCOL_VERSION,
+        endpoint: { port: 0, token: "" },
+        installed: {},
+        skill: skillDigest === null ? null : { version: "1", digest: skillDigest },
+    };
+}
+/** The `installed` row shape: string entries plus a string→string digest map. */
+function isInstalledRow(installed) {
+    if (!isRecord(installed))
+        return false;
+    if (!Array.isArray(installed["entries"]) || !installed["entries"].every((e) => typeof e === "string")) {
+        return false;
+    }
+    const digests = installed["digests"];
+    if (!isRecord(digests))
+        return false;
+    for (const digest of Object.values(digests)) {
+        if (typeof digest !== "string")
+            return false;
+    }
+    return true;
+}
+/** The optional `skill` block: absent, or a {version, digest} record of strings. */
+function isSkillBlock(skill) {
+    if (skill === null || skill === undefined)
+        return true;
+    if (!isRecord(skill))
+        return false;
+    return typeof skill["version"] === "string" && typeof skill["digest"] === "string";
+}
+/** Structural validation: required fields present and well-typed; unknown extras ignored. */
+function isHeedState(value) {
+    if (!isRecord(value))
+        return false;
+    if (value["schemaVersion"] !== 1)
+        return false;
+    if (typeof value["protocolVersion"] !== "string" || value["protocolVersion"].length === 0) {
+        return false;
+    }
+    const endpoint = value["endpoint"];
+    if (!isRecord(endpoint))
+        return false;
+    if (!Number.isInteger(endpoint["port"]) || typeof endpoint["token"] !== "string")
+        return false;
+    const installed = value["installed"];
+    if (!isRecord(installed))
+        return false;
+    for (const row of Object.values(installed)) {
+        if (!isInstalledRow(row))
+            return false;
+    }
+    return isSkillBlock(value["skill"]);
+}
+/**
+ * Read <root>/state.json. Returns null when the file does not exist.
+ * Throws {@link HeedStateCorruptError} (remediation: "delete <path> or run
+ * npx heedvane doctor") when the file exists but is unparseable or does not
+ * match the HeedState schema.
+ */
+export async function readState(root) {
+    const path = statePath(root);
+    let text;
+    try {
+        text = await readFile(path, "utf8");
+    }
+    catch (err) {
+        if (isRecord(err) && err["code"] === "ENOENT")
+            return null;
+        throw err;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (err) {
+        const reason = errorMessage(err);
+        throw new HeedStateCorruptError(path, `not valid JSON (${reason})`);
+    }
+    if (!isHeedState(parsed)) {
+        throw new HeedStateCorruptError(path, "does not match the HeedState schema (schemaVersion 1)");
+    }
+    return parsed;
+}
+/**
+ * Atomically write state to <root>/state.json (create parent dirs, mode 0600).
+ * write-file-atomic writes to a sibling temp file and renames, so readers never
+ * observe a partial state.
+ */
+export async function writeStateAtomic(root, state) {
+    await mkdir(root, { recursive: true });
+    const payload = `${JSON.stringify(state, null, 2)}\n`;
+    await writeFileAtomic(statePath(root), payload, { mode: 0o600 });
+}

package/dist/steering/rules.d.ts

@@ -0,0 +1,49 @@
+import { type Backend } from "../backend/client.js";
+import type { Envelope } from "../events/contract.js";
+import { type Verdict } from "../reply/verdict.js";
+export interface DeterministicRule {
+    id: string;
+    kind: "command_contains" | "path_glob";
+    tools: string[] | null;
+    /** `fragments` for command_contains, `globs` for path_glob. */
+    patterns: string[];
+    message: string;
+    /** The rule's version, named in delivery reports; absent from a server that does not send it. */
+    sha256?: string;
+}
+/** An organization instruction, injected as context; it never blocks. */
+export interface Instruction {
+    id: string;
+    text: string;
+    inject: "session_start" | "every_prompt";
+}
+export interface SteeringPolicy {
+    enabled: boolean;
+    rules: DeterministicRule[];
+    instructions: Instruction[];
+}
+/** Heedvane's COMMAND_TOO_LONG_MESSAGE: what an over-budget command is enforced with, instead of each rule's advice. */
+export declare const COMMAND_TOO_LONG_MESSAGE = "This command is too long for Heedvane to check against your organization's rules; split it into shorter commands.";
+/** The policy in a rules answer; null when it is not one. Rules and instructions that do not parse are skipped. */
+export declare function steeringPolicy(value: unknown): SteeringPolicy | null;
+/**
+ * The matched rules' verdict for one `pre_tool_use`: every matched rule enforces, in policy order. A
+ * command too long to read within Heedvane's work budget is enforced unread by every command rule
+ * (`unchecked`), with one message saying so.
+ */
+export declare function deterministicVerdict(envelope: Envelope, rules: readonly DeterministicRule[]): Verdict;
+/** The instructions' text for an event: `session_start` ones at session start, `every_prompt` ones with each prompt, in policy order. */
+export declare function instructionContext(policy: SteeringPolicy | null, event: string): string[];
+/** The sync's outcome: the policy with the answer it came in (cached as is), or the status Heedvane refused it with (null: no answer). */
+export type PolicySync = {
+    policy: SteeringPolicy;
+    answer: unknown;
+} | {
+    status: number | null;
+};
+export declare function fetchSteeringPolicy(backend: Backend, timeoutMs: number): Promise<PolicySync>;
+export declare function steeringPolicyPath(root: string): string;
+/** The last synced policy, or null before the first sync or when the cache does not parse. */
+export declare function readSteeringPolicy(root: string, identity: string | null): Promise<SteeringPolicy | null>;
+/** Keep a rules answer as Heedvane sent it, plus whose sign-in fetched it (`cachedFor`). */
+export declare function saveSteeringPolicy(root: string, answer: unknown, identity: string | null): Promise<void>;

package/dist/steering/rules.js

@@ -0,0 +1,165 @@
+/**
+ * The organization's steering policy on this machine: `GET /api/agent/steering/rules` answers
+ * `{ enabled, rules, instructions }` (docs/product/agent-integration/steering.md, "Rule format" and
+ * "Organization instructions"). The deterministic rules (`command_contains`, `path_glob`) are evaluated
+ * here on `pre_tool_use`, the only event that carries the tool input they read, so a slow or failed
+ * server answer can never cancel them. They match exactly as Heedvane's own evaluation does
+ * (`deterministicResult` and `touchedFile` in apps/web): a glob sees the first of `file_path`,
+ * `notebook_path`, `path`, relative to `cwd` when inside it, normalized, at most 1,024 characters; a
+ * command too long to read within the work budget enforces every command rule unread (`unchecked`).
+ * Semantic rules are evaluated by Heedvane, which answers the event with its verdict; they are ignored here.
+ *
+ * The last synced policy is kept in `<root>/steering-policy.json`, so a restarted listener enforces and
+ * injects instructions before its first sync, and with Heedvane down.
+ */
+import { readFile } from "node:fs/promises";
+import { isAbsolute, join, matchesGlob, normalize, relative } from "node:path";
+import writeFileAtomic from "write-file-atomic";
+import { callHeedvane } from "../backend/client.js";
+import { isRecord } from "../guards.js";
+import { ALLOW } from "../reply/verdict.js";
+/** Heedvane's MAX_MATCHED_PATH: a longer (normalized) path matches no glob. */
+const MAX_MATCHED_PATH = 1024;
+/** Heedvane's MAX_COMMAND_MATCH_WORK: command length × the applicable fragments' characters it reads at most. */
+const MAX_COMMAND_MATCH_WORK = 130_000_000;
+/** Heedvane's COMMAND_TOO_LONG_MESSAGE: what an over-budget command is enforced with, instead of each rule's advice. */
+export const COMMAND_TOO_LONG_MESSAGE = "This command is too long for Heedvane to check against your organization's rules; split it into shorter commands.";
+/** The policy in a rules answer; null when it is not one. Rules and instructions that do not parse are skipped. */
+export function steeringPolicy(value) {
+    if (!isRecord(value) || typeof value["enabled"] !== "boolean" || !Array.isArray(value["rules"]))
+        return null;
+    const instructions = Array.isArray(value["instructions"]) ? value["instructions"] : [];
+    return {
+        enabled: value["enabled"],
+        rules: value["rules"].flatMap((rule) => parsed(parseRule(rule))),
+        instructions: instructions.flatMap((instruction) => parsed(parseInstruction(instruction))),
+    };
+}
+function parsed(value) {
+    return value === null ? [] : [value];
+}
+/** A rule this machine can enforce: deterministic, and on `pre_tool_use` (the default). */
+function parseRule(rule) {
+    if (!isRecord(rule) || typeof rule["id"] !== "string" || typeof rule["message"] !== "string")
+        return null;
+    const kind = rule["kind"];
+    if (kind !== "command_contains" && kind !== "path_glob")
+        return null;
+    if (isStrings(rule["events"]) && !rule["events"].includes("pre_tool_use"))
+        return null;
+    const patterns = kind === "command_contains" ? rule["fragments"] : rule["globs"];
+    if (!isStrings(patterns))
+        return null;
+    return {
+        id: rule["id"],
+        kind,
+        tools: isStrings(rule["tools"]) ? rule["tools"] : null,
+        patterns,
+        message: rule["message"],
+        ...(typeof rule["sha256"] === "string" ? { sha256: rule["sha256"] } : {}),
+    };
+}
+function parseInstruction(instruction) {
+    if (!isRecord(instruction) || typeof instruction["id"] !== "string" || typeof instruction["text"] !== "string")
+        return null;
+    const inject = instruction["inject"];
+    return inject === "session_start" || inject === "every_prompt" ? { id: instruction["id"], text: instruction["text"], inject } : null;
+}
+function isStrings(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+/**
+ * The matched rules' verdict for one `pre_tool_use`: every matched rule enforces, in policy order. A
+ * command too long to read within Heedvane's work budget is enforced unread by every command rule
+ * (`unchecked`), with one message saying so.
+ */
+export function deterministicVerdict(envelope, rules) {
+    if (envelope.event !== "pre_tool_use")
+        return ALLOW;
+    const input = envelope.payload["tool_input"];
+    const applicable = rules.filter((rule) => applies(rule, envelope));
+    const unchecked = commandTooLong(input, applicable);
+    const matched = applicable.filter((rule) => (unchecked && rule.kind === "command_contains") || matches(rule, input, envelope.payload["cwd"]));
+    if (matched.length === 0)
+        return ALLOW;
+    const message = (rule) => (unchecked && rule.kind === "command_contains" ? COMMAND_TOO_LONG_MESSAGE : rule.message);
+    return {
+        decision: "steer",
+        messages: [...new Set(matched.map(message))],
+        context: [],
+        enforcements: matched.map((rule) => ({ ruleId: rule.id, ...(rule.sha256 === undefined ? {} : { ruleSha256: rule.sha256 }) })),
+    };
+}
+function applies(rule, envelope) {
+    const tool = envelope.payload["tool"];
+    return rule.tools === null || (typeof tool === "string" && rule.tools.includes(tool));
+}
+function commandTooLong(input, rules) {
+    const command = isRecord(input) ? input["command"] : undefined;
+    const fragmentCharacters = rules.reduce((total, rule) => total + (rule.kind === "command_contains" ? rule.patterns.join("").length : 0), 0);
+    return typeof command === "string" && command.length * fragmentCharacters > MAX_COMMAND_MATCH_WORK;
+}
+function matches(rule, input, cwd) {
+    if (!isRecord(input))
+        return false;
+    if (rule.kind === "command_contains") {
+        const command = input["command"];
+        return typeof command === "string" && rule.patterns.some((fragment) => command.includes(fragment));
+    }
+    const touched = touchedFile(input, cwd);
+    // Normalized first, so `./././` padding cannot push a real file past the length bound.
+    const path = touched === null ? null : normalize(touched);
+    return path !== null && path.length <= MAX_MATCHED_PATH && rule.patterns.some((glob) => matchesGlob(path, glob));
+}
+/** The file a tool event touches, relative to `cwd` when inside it (Heedvane's `touchedFile`). */
+function touchedFile(input, cwd) {
+    const path = ["file_path", "notebook_path", "path"].map((key) => input[key]).find((value) => typeof value === "string" && value !== "");
+    if (path === undefined)
+        return null;
+    if (typeof cwd !== "string" || cwd === "" || !isAbsolute(path))
+        return path;
+    const inside = relative(cwd, path);
+    return inside !== "" && !inside.startsWith("..") ? inside : path;
+}
+/** The instructions' text for an event: `session_start` ones at session start, `every_prompt` ones with each prompt, in policy order. */
+export function instructionContext(policy, event) {
+    const inject = { session_start: "session_start", user_prompt_submit: "every_prompt" }[event];
+    if (policy === null || !policy.enabled || inject === undefined)
+        return [];
+    return policy.instructions.filter((instruction) => instruction.inject === inject).map((instruction) => instruction.text);
+}
+export async function fetchSteeringPolicy(backend, timeoutMs) {
+    const answer = await callHeedvane(backend, { method: "GET", path: "/api/agent/steering/rules", timeoutMs });
+    const policy = answer?.status === 200 ? steeringPolicy(answer.json) : null;
+    return policy === null ? { status: answer?.status ?? null } : { policy, answer: answer.json };
+}
+export function steeringPolicyPath(root) {
+    return join(root, "steering-policy.json");
+}
+/** The last synced policy, or null before the first sync or when the cache does not parse. */
+export async function readSteeringPolicy(root, identity) {
+    let text;
+    try {
+        text = await readFile(steeringPolicyPath(root), "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        throw err;
+    }
+    try {
+        const cached = JSON.parse(text);
+        // Only the rules this very sign-in fetched apply: another organization's, one from before identities were kept, and any with no sign-in do not.
+        if (!isRecord(cached) || identity === null || cached["cachedFor"] !== identity)
+            return null;
+        return steeringPolicy(cached);
+    }
+    catch {
+        return null; // a torn or hand-edited cache: wait for the next sync rather than enforce a guess
+    }
+}
+/** Keep a rules answer as Heedvane sent it, plus whose sign-in fetched it (`cachedFor`). */
+export async function saveSteeringPolicy(root, answer, identity) {
+    const cached = identity !== null && isRecord(answer) ? { ...answer, cachedFor: identity } : answer;
+    await writeFileAtomic(steeringPolicyPath(root), `${JSON.stringify(cached, null, 2)}\n`, { mode: 0o600 });
+}

package/dist/steering/steer.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The organization's steering for one event (docs/product/agent-integration/steering.md, "Hook response
+ * contract"). A hook never reads the network. The synced deterministic rules decide `pre_tool_use` locally
+ * (`localVerdict`) and enforce at once. While the policy is enabled every steered event also goes to
+ * `POST /api/agent/steering`, also the ones nothing enforces, so Heedvane can tell whether the agent
+ * complied; that call runs in the background (`steer`) and its `enforce` or `halt` answer becomes an open
+ * violation (src/steering/violations.ts), delivered at the agent's next tool call or stop. Steering never
+ * only warns: every matched rule enforces.
+ */
+import { type Backend } from "../backend/client.js";
+import type { Envelope } from "../events/contract.js";
+import { type Verdict } from "../reply/verdict.js";
+import { type DeterministicRule } from "./rules.js";
+/** The events steering enforces on (a rule on any other event is refused by Heedvane). */
+export declare const STEERED_EVENTS: ReadonlySet<string>;
+/** Who decided an enforcement: this machine's synced rules, or Heedvane's background verdict, delivered with a later event. */
+export type Delivery = "local" | "next_event";
+export interface SteeringRequest {
+    envelope: Envelope;
+    repository: string;
+    /** The event's tool input before the payload caps: the local rules match on it, and Heedvane's evaluation (held in memory there, never stored) is sent it. The forwarded, recorded envelope stays capped. */
+    toolInput?: unknown;
+}
+/** The synced deterministic rules' verdict for one event; they see the whole tool input, not the capped one. */
+export declare function localVerdict({ envelope, toolInput }: SteeringRequest, rules: readonly DeterministicRule[]): Verdict;
+/** Heedvane's answer for the event: `enforce` and `halt` enforce; null when it did not answer in time or validly. */
+export declare function steer(backend: Backend, request: SteeringRequest): Promise<Verdict | null>;
+/** What `POST /api/agent/steering` reads at most (steering.md "Hook response contract": 413 past it). */
+export declare const MAX_STEERING_REQUEST_BYTES: number;

package/dist/steering/steer.js

@@ -0,0 +1,64 @@
+/**
+ * The organization's steering for one event (docs/product/agent-integration/steering.md, "Hook response
+ * contract"). A hook never reads the network. The synced deterministic rules decide `pre_tool_use` locally
+ * (`localVerdict`) and enforce at once. While the policy is enabled every steered event also goes to
+ * `POST /api/agent/steering`, also the ones nothing enforces, so Heedvane can tell whether the agent
+ * complied; that call runs in the background (`steer`) and its `enforce` or `halt` answer becomes an open
+ * violation (src/steering/violations.ts), delivered at the agent's next tool call or stop. Steering never
+ * only warns: every matched rule enforces.
+ */
+import { callHeedvane } from "../backend/client.js";
+import { isRecord } from "../guards.js";
+import { ALLOW } from "../reply/verdict.js";
+import { deterministicVerdict } from "./rules.js";
+/** The events steering enforces on (a rule on any other event is refused by Heedvane). */
+export const STEERED_EVENTS = new Set(["pre_tool_use", "user_prompt_submit", "stop", "subagent_stop"]);
+/** How long a background evaluation may take; no hook waits for it. */
+const STEERING_TIMEOUT_MS = 15_000;
+/** The synced deterministic rules' verdict for one event; they see the whole tool input, not the capped one. */
+export function localVerdict({ envelope, toolInput }, rules) {
+    return deterministicVerdict(toolInput === undefined ? envelope : { ...envelope, payload: { ...envelope.payload, tool_input: toolInput } }, rules);
+}
+/** Heedvane's answer for the event: `enforce` and `halt` enforce; null when it did not answer in time or validly. */
+export async function steer(backend, request) {
+    const body = steeringBody(request);
+    const answer = await callHeedvane(backend, { method: "POST", path: "/api/agent/steering", body, timeoutMs: STEERING_TIMEOUT_MS });
+    if (answer?.status !== 200 || !isRecord(answer.json))
+        return null;
+    const { decision, messages, enforcements } = answer.json;
+    if (decision === "allow")
+        return ALLOW;
+    if ((decision !== "enforce" && decision !== "halt") || !Array.isArray(messages))
+        return null;
+    return {
+        decision: "steer",
+        messages: messages.filter((message) => typeof message === "string"),
+        context: [],
+        enforcements: enforced(enforcements),
+        ...(decision === "halt" ? { halt: true } : {}),
+    };
+}
+/** What `POST /api/agent/steering` reads at most (steering.md "Hook response contract": 413 past it). */
+export const MAX_STEERING_REQUEST_BYTES = 1024 * 1024;
+/**
+ * The evaluation request. Its envelope carries the whole tool input, so an AI rule can see a harmful
+ * tail the 8 KB payload cap would cut; when that does not fit the request limit, the capped envelope
+ * goes instead and Heedvane treats a "no" about capped content as uncertain.
+ */
+function steeringBody(request) {
+    const { envelope, toolInput, repository } = request;
+    const withRepository = (value) => (repository === "" ? { envelope: value } : { envelope: value, repository });
+    if (toolInput === undefined)
+        return withRepository(envelope);
+    const whole = withRepository({ ...envelope, payload: { ...envelope.payload, tool_input: toolInput } });
+    return Buffer.byteLength(JSON.stringify(whole)) <= MAX_STEERING_REQUEST_BYTES ? whole : withRepository(envelope);
+}
+function enforced(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => {
+        if (!isRecord(item) || typeof item["ruleId"] !== "string")
+            return [];
+        return [{ ruleId: item["ruleId"], ...(typeof item["ruleSha256"] === "string" ? { ruleSha256: item["ruleSha256"] } : {}) }];
+    });
+}

package/dist/steering/violations.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Heedvane's background verdicts that enforce, held per session until the agent's next tool call or
+ * stop carries them (docs/product/agent-integration/steering.md, "Hook response contract"). A verdict
+ * is delivered once: taking it removes it. The hook never waits for a verdict, so one still in flight
+ * when a stop is answered is delivered with a later event, or never if the session ends first.
+ */
+import type { Envelope } from "../events/contract.js";
+import type { Verdict } from "../reply/verdict.js";
+/** An enforcing verdict and the event Heedvane judged, which a delivery report names. */
+export interface Violation {
+    judged: Envelope;
+    verdict: Verdict;
+}
+/** Open violations by session. shortcut: a session that never ends keeps its entry until the listener restarts; upgrade if sessions pile up. */
+export type Violations = Map<string, Violation[]>;
+/** The events whose answer carries an open violation. */
+export declare const DELIVERY_EVENTS: ReadonlySet<string>;
+export declare function openViolation(open: Violations, violation: Violation): void;
+/** The session's open violations, removed: they are delivered exactly once. */
+export declare function takeViolations(open: Violations, session: string): Violation[];
+/**
+ * The verdict less the rules this machine's synced rules enforced on this very event (they denied it on
+ * the spot), or null when nothing else is left: the agent was told about those once. A rule the local copy
+ * did not match here stays, so a server that matches it still reaches the agent. Messages stay whole: they
+ * are not tied to a rule, and a duplicate reason is better than a lost one.
+ */
+export declare function withoutRules(verdict: Verdict, enforcedHere: ReadonlySet<string>): Verdict | null;

package/dist/steering/violations.js

@@ -0,0 +1,24 @@
+/** The events whose answer carries an open violation. */
+export const DELIVERY_EVENTS = new Set(["pre_tool_use", "stop", "subagent_stop"]);
+export function openViolation(open, violation) {
+    const { session } = violation.judged;
+    open.set(session, [...(open.get(session) ?? []), violation]);
+}
+/** The session's open violations, removed: they are delivered exactly once. */
+export function takeViolations(open, session) {
+    const taken = open.get(session) ?? [];
+    open.delete(session);
+    return taken;
+}
+/**
+ * The verdict less the rules this machine's synced rules enforced on this very event (they denied it on
+ * the spot), or null when nothing else is left: the agent was told about those once. A rule the local copy
+ * did not match here stays, so a server that matches it still reaches the agent. Messages stay whole: they
+ * are not tied to a rule, and a duplicate reason is better than a lost one.
+ */
+export function withoutRules(verdict, enforcedHere) {
+    if (enforcedHere.size === 0)
+        return verdict;
+    const enforcements = (verdict.enforcements ?? []).filter((enforced) => !enforcedHere.has(enforced.ruleId));
+    return enforcements.length === 0 ? null : { ...verdict, enforcements };
+}

package/dist/uninstall.d.ts

@@ -0,0 +1,23 @@
+import { type ResolvedClient, type Env } from "./clients/definitions.js";
+import { type ConfigFormat } from "./config-doc.js";
+export interface UninstallItem {
+    clientId: string;
+    name: string;
+    path: string;
+    status: "removed" | "absent" | "skipped" | "failed";
+    detail?: string;
+}
+export interface UninstallInput {
+    home: string;
+    env: Env;
+    agents?: string[];
+    purgeConfig?: boolean;
+}
+/** Setup's half: our hook groups under any event this client no longer installs, removed from its hooks file. */
+export declare function removeStaleHookGroups(client: ResolvedClient, target: {
+    path: string;
+    format: ConfigFormat;
+}): Promise<UninstallItem[]>;
+/** When hooksDeferredTo skips a client whose hooks an earlier run installed, remove our hook groups so events do not fire twice. */
+export declare function removeDeferredHookGroups(client: ResolvedClient): Promise<UninstallItem[]>;
+export declare function uninstall(input: UninstallInput): Promise<UninstallItem[]>;