freeharness 0.4.1

package/dist/cli/profile.d.ts

@@ -0,0 +1,170 @@
+import type { ExecStep, HarnessTarget, Profile, Scope, SelectItem, Tier } from "@freeharness/core";
+import type { ProfileRecord } from "../infra/manifest.js";
+/** On-disk shape of a `claude-code-env` profile (local-ollama.json). */
+export interface EnvProfileFile {
+    name: string;
+    kind: "claude-code-env";
+    base_url: string;
+    auth_token?: string;
+    models: Record<Tier, string>;
+    probe?: {
+        kind: string;
+        path: string;
+    };
+    notes?: string[];
+}
+/** On-disk shape of an `opencode-provider` profile (local-llamacpp.json). */
+export interface ProviderProfileFile {
+    name: string;
+    kind: "opencode-provider";
+    provider_id: string;
+    provider: Record<string, unknown>;
+    models: Record<Tier, string>;
+    notes_file: string;
+    notes_source: string;
+}
+/** One catalog entry of the `mcp` profile. */
+export interface McpCatalogServer {
+    name: string;
+    description: string;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    type?: "stdio" | "http" | "sse";
+    url?: string;
+    tools_approx: number;
+    context_cost: string;
+}
+/** On-disk shape of the `mcp-catalog` profile (mcp.json). */
+export interface McpProfileFile {
+    name: string;
+    kind: "mcp-catalog";
+    servers: McpCatalogServer[];
+}
+export type ProfileFile = EnvProfileFile | ProviderProfileFile | McpProfileFile;
+/**
+ * Reads a profile data file from canonical/profiles/.
+ * @param canonicalDir Resolved canonical directory.
+ * @param profile Registry entry.
+ * @returns Parsed file.
+ */
+export declare function loadProfileFile(canonicalDir: string, profile: Profile): ProfileFile;
+/**
+ * Resolves a `--profile` value: a registry id, or `none`.
+ * @param id Value passed on the command line.
+ * @returns The registry entry (undefined for `none`).
+ */
+export declare function resolveProfile(id: string): Profile | undefined;
+/** Outcome of the env merge preview/apply. */
+export interface EnvMerge {
+    /** Keys written with the profile value (new, or previously ours). */
+    set: Record<string, string>;
+    /** Keys present in the env block that were not ours: kept with the user's value. */
+    kept: Record<string, unknown>;
+    /** Keys previously ours whose value changed. */
+    updated: string[];
+}
+/**
+ * Plans (and, unless dry, applies) the additive env merge of a local-model profile into a
+ * Claude Code settings.json: the profile keys are added; a key already present and not
+ * recorded as ours in the manifest keeps the user's value; a key recorded as ours is updated
+ * to the profile value. Foreign keys and every other settings key are untouched.
+ * @param settingsPath The settings.json (created when missing).
+ * @param env The env block from `tierEnv`.
+ * @param ours Keys recorded as written by this profile earlier (manifest).
+ * @param dry When true nothing is written.
+ * @returns What was set, kept and updated.
+ */
+export declare function mergeEnvProfile(settingsPath: string, env: Record<string, string>, ours: string[], dry: boolean): EnvMerge;
+/**
+ * Removes from the env block exactly the keys a profile wrote; an empty env block is
+ * dropped. Nothing else in the file changes.
+ * @param settingsPath The settings.json.
+ * @param keys Keys recorded in the manifest.
+ * @param dry When true nothing is written.
+ * @returns Keys removed (those still present).
+ */
+export declare function removeEnvKeys(settingsPath: string, keys: string[], dry: boolean): string[];
+/**
+ * Removes a `provider.<id>` block from an opencode.json (only when it was ours); an empty
+ * `provider` map is dropped.
+ * @param file opencode.json path.
+ * @param providerId Provider id recorded in the manifest.
+ * @param dry When true nothing is written.
+ * @returns True when the block was removed.
+ */
+export declare function removeProviderBlock(file: string, providerId: string, dry: boolean): boolean;
+/** One planned change of a profile pass, printable. */
+export interface ProfilePlan {
+    profileId: string;
+    target: HarnessTarget;
+    scope: Scope;
+    /** Preview lines (`write:` / `note:` style). */
+    lines: string[];
+    /** Side-effecting actions (MCP registrations). */
+    actions: ExecStep[];
+    /** Manifest record (null when the pass removes the profile; undefined when nothing to record). */
+    record?: ProfileRecord | null;
+    /** Files this pass writes (for the manifest `files` list). */
+    written: string[];
+}
+/** Inputs shared by the profile passes. */
+export interface ProfileContext {
+    canonicalDir: string;
+    scope: Scope;
+    projectRoot: string;
+    /** `~/.claude` for user scope, `<project>/.claude` for project scope. */
+    claudeDir: string;
+    dryRun: boolean;
+    /** Existing manifest records, by profile id. */
+    existing: Record<string, ProfileRecord>;
+}
+/**
+ * Applies (or previews) the `claude-code-env` profile: the tier env merged into the scope's
+ * settings.json.
+ * @param profile Registry entry.
+ * @param data Profile file.
+ * @param ctx Pass context.
+ * @returns The plan with its manifest record.
+ */
+export declare function applyEnvProfile(profile: Profile, data: EnvProfileFile, ctx: ProfileContext): ProfilePlan;
+/**
+ * Applies (or previews) the `opencode-provider` profile: the provider block merged into
+ * `<project>/opencode.json` and the notes file written next to it.
+ * @param profile Registry entry.
+ * @param data Profile file.
+ * @param ctx Pass context.
+ * @returns The plan with its manifest record.
+ */
+export declare function applyProviderProfile(profile: Profile, data: ProviderProfileFile, ctx: ProfileContext): ProfilePlan;
+/**
+ * Selectable items of the MCP catalog (id + label with tool count and cost).
+ * @param data Catalog file.
+ * @returns Items in catalog order.
+ */
+export declare function mcpCatalogItems(data: McpProfileFile): SelectItem[];
+/**
+ * The `claude mcp add` command for a catalog entry (same shape the `mcp` capability emits).
+ * @param s Catalog entry.
+ * @param scope user -> `-s user`, project -> `-s local`.
+ * @returns Shell command.
+ */
+export declare function mcpAddCommand(s: McpCatalogServer, scope: Scope): string;
+/**
+ * Builds the MCP profile plan for a selection: one `claude mcp add` action per selected
+ * server, nothing for an empty selection.
+ * @param profile Registry entry.
+ * @param data Catalog file.
+ * @param selected Selected server names (unknown names are reported and ignored).
+ * @param ctx Pass context.
+ * @returns The plan (no manifest record: registrations live in ~/.claude.json, owned by `claude`).
+ */
+export declare function applyMcpProfile(profile: Profile, data: McpProfileFile, selected: string[], ctx: ProfileContext): ProfilePlan;
+/**
+ * Plans (or applies) the removal of every profile recorded in the manifest: env keys and
+ * provider blocks we wrote, and the notes files. Foreign keys are never touched.
+ * @param existing Manifest records.
+ * @param dry When true nothing is written.
+ * @returns One plan per recorded profile (record = null).
+ */
+export declare function removeProfiles(existing: Record<string, ProfileRecord>, dry: boolean): ProfilePlan[];

package/dist/cli/profile.js

@@ -0,0 +1,285 @@
+// Opt-in profiles (v4 P6): `init --profile <id>` applies one data file from
+// canonical/profiles/ to an existing target. Three kinds: a Claude Code env block
+// (local-ollama), an OpenCode provider block + notes file (local-llamacpp) and an MCP
+// catalog with a selection prompt (mcp). Every write is additive (a key the user set is
+// kept), previewed first, confirmed second, and recorded in the install manifest so
+// `--profile none` removes exactly the keys and files a profile wrote. index.ts composes
+// the two passes; nothing here prompts.
+import fs from "node:fs";
+import path from "node:path";
+import { PROFILES, PROFILE_NONE, getProfile, tierEnv } from "@freeharness/core";
+import { ensureDir } from "../infra/fsutil.js";
+/**
+ * Reads a profile data file from canonical/profiles/.
+ * @param canonicalDir Resolved canonical directory.
+ * @param profile Registry entry.
+ * @returns Parsed file.
+ */
+export function loadProfileFile(canonicalDir, profile) {
+    const file = path.join(canonicalDir, "profiles", profile.file);
+    if (!fs.existsSync(file))
+        throw new Error(`profile ${profile.id}: data file missing at ${file}`);
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+/**
+ * Resolves a `--profile` value: a registry id, or `none`.
+ * @param id Value passed on the command line.
+ * @returns The registry entry (undefined for `none`).
+ */
+export function resolveProfile(id) {
+    if (id === PROFILE_NONE)
+        return undefined;
+    const p = getProfile(id);
+    if (!p)
+        throw new Error(`Unknown profile: ${id}. Valid: ${PROFILES.map((x) => x.id).join(", ")}, ${PROFILE_NONE}`);
+    return p;
+}
+/**
+ * Reads a JSON file when present.
+ * @param file Path.
+ * @returns Parsed object or {} when absent.
+ */
+function readJsonOr(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Writes a JSON file (2-space indent, trailing newline), creating its directory.
+ * @param file Path.
+ * @param value Serializable value.
+ * @param dry When true nothing is written.
+ */
+function writeJson(file, value, dry) {
+    if (dry)
+        return;
+    ensureDir(path.dirname(file), false);
+    fs.writeFileSync(file, JSON.stringify(value, null, 2) + "\n", "utf8");
+}
+/**
+ * Plans (and, unless dry, applies) the additive env merge of a local-model profile into a
+ * Claude Code settings.json: the profile keys are added; a key already present and not
+ * recorded as ours in the manifest keeps the user's value; a key recorded as ours is updated
+ * to the profile value. Foreign keys and every other settings key are untouched.
+ * @param settingsPath The settings.json (created when missing).
+ * @param env The env block from `tierEnv`.
+ * @param ours Keys recorded as written by this profile earlier (manifest).
+ * @param dry When true nothing is written.
+ * @returns What was set, kept and updated.
+ */
+export function mergeEnvProfile(settingsPath, env, ours, dry) {
+    const settings = readJsonOr(settingsPath);
+    const block = { ...(settings.env ?? {}) };
+    const out = { set: {}, kept: {}, updated: [] };
+    for (const [k, v] of Object.entries(env)) {
+        const present = Object.prototype.hasOwnProperty.call(block, k);
+        if (present && !ours.includes(k)) {
+            out.kept[k] = block[k];
+            continue;
+        }
+        if (present && block[k] !== v)
+            out.updated.push(k);
+        block[k] = v;
+        out.set[k] = v;
+    }
+    if (!dry && Object.keys(out.set).length > 0)
+        writeJson(settingsPath, { ...settings, env: block }, false);
+    return out;
+}
+/**
+ * Removes from the env block exactly the keys a profile wrote; an empty env block is
+ * dropped. Nothing else in the file changes.
+ * @param settingsPath The settings.json.
+ * @param keys Keys recorded in the manifest.
+ * @param dry When true nothing is written.
+ * @returns Keys removed (those still present).
+ */
+export function removeEnvKeys(settingsPath, keys, dry) {
+    if (!fs.existsSync(settingsPath))
+        return [];
+    const settings = readJsonOr(settingsPath);
+    const block = { ...(settings.env ?? {}) };
+    const removed = keys.filter((k) => Object.prototype.hasOwnProperty.call(block, k));
+    for (const k of removed)
+        delete block[k];
+    if (removed.length > 0 && !dry) {
+        const next = { ...settings };
+        if (Object.keys(block).length > 0)
+            next.env = block;
+        else
+            delete next.env;
+        writeJson(settingsPath, next, false);
+    }
+    return removed;
+}
+/**
+ * Removes a `provider.<id>` block from an opencode.json (only when it was ours); an empty
+ * `provider` map is dropped.
+ * @param file opencode.json path.
+ * @param providerId Provider id recorded in the manifest.
+ * @param dry When true nothing is written.
+ * @returns True when the block was removed.
+ */
+export function removeProviderBlock(file, providerId, dry) {
+    if (!fs.existsSync(file))
+        return false;
+    const cfg = readJsonOr(file);
+    if (!cfg.provider || !(providerId in cfg.provider))
+        return false;
+    const provider = { ...cfg.provider };
+    delete provider[providerId];
+    const next = { ...cfg };
+    if (Object.keys(provider).length > 0)
+        next.provider = provider;
+    else
+        delete next.provider;
+    writeJson(file, next, dry);
+    return true;
+}
+/**
+ * Applies (or previews) the `claude-code-env` profile: the tier env merged into the scope's
+ * settings.json.
+ * @param profile Registry entry.
+ * @param data Profile file.
+ * @param ctx Pass context.
+ * @returns The plan with its manifest record.
+ */
+export function applyEnvProfile(profile, data, ctx) {
+    const settingsPath = path.join(ctx.claudeDir, "settings.json");
+    const env = tierEnv({ baseUrl: data.base_url, models: data.models, authToken: data.auth_token });
+    const ours = ctx.existing[profile.id]?.keys ?? [];
+    const merge = mergeEnvProfile(settingsPath, env, ours, ctx.dryRun);
+    const lines = [`  edit:  ${settingsPath} (env block, additive)`];
+    for (const [k, v] of Object.entries(merge.set))
+        lines.push(`    ${merge.updated.includes(k) ? "update" : "set   "} ${k}=${v}`);
+    for (const [k, v] of Object.entries(merge.kept))
+        lines.push(`    keep   ${k}=${String(v)} (set by you; not overwritten)`);
+    for (const n of data.notes ?? [])
+        lines.push(`  note:  ${n}`);
+    lines.push("  note:  remove with `freeharness init --profile none`; doctor probes the base URL.");
+    const record = { target: "claude-code", file: settingsPath, keys: Object.keys(merge.set), files: [], appliedAt: new Date().toISOString() };
+    return { profileId: profile.id, target: "claude-code", scope: ctx.scope, lines, actions: [], record, written: [] };
+}
+/**
+ * Applies (or previews) the `opencode-provider` profile: the provider block merged into
+ * `<project>/opencode.json` and the notes file written next to it.
+ * @param profile Registry entry.
+ * @param data Profile file.
+ * @param ctx Pass context.
+ * @returns The plan with its manifest record.
+ */
+export function applyProviderProfile(profile, data, ctx) {
+    const file = path.join(ctx.projectRoot, "opencode.json");
+    const cfg = readJsonOr(file);
+    const provider = { ...(cfg.provider ?? {}) };
+    const ours = ctx.existing[profile.id]?.keys ?? [];
+    const key = `provider.${data.provider_id}`;
+    const present = Object.prototype.hasOwnProperty.call(provider, data.provider_id);
+    const lines = [];
+    let keys = [];
+    if (present && !ours.includes(key)) {
+        lines.push(`  keep:  ${file} already has provider.${data.provider_id} (set by you; not overwritten)`);
+    }
+    else {
+        provider[data.provider_id] = data.provider;
+        const next = { ...(cfg.$schema ? {} : { $schema: "https://opencode.ai/config.json" }), ...cfg, provider };
+        writeJson(file, next, ctx.dryRun);
+        lines.push(`  edit:  ${file} (${present ? "update" : "add"} provider.${data.provider_id}, other providers kept)`);
+        keys = [key];
+    }
+    const notesFile = path.join(ctx.projectRoot, data.notes_file);
+    const notesSrc = path.join(ctx.canonicalDir, "profiles", data.notes_source);
+    if (!ctx.dryRun) {
+        ensureDir(path.dirname(notesFile), false);
+        fs.writeFileSync(notesFile, fs.readFileSync(notesSrc, "utf8"), "utf8");
+    }
+    lines.push(`  write: ${notesFile} (Jinja template guidance, context size, tier placeholders)`);
+    for (const tier of ["strong", "standard", "fast"])
+        lines.push(`  note:  ${tier} -> ${data.models[tier]} (export OPENCODE_${tier.toUpperCase()}_MODEL=${data.models[tier]})`);
+    const record = { target: "opencode", file, keys, files: [notesFile], appliedAt: new Date().toISOString() };
+    return { profileId: profile.id, target: "opencode", scope: ctx.scope, lines, actions: [], record, written: [notesFile] };
+}
+/**
+ * Selectable items of the MCP catalog (id + label with tool count and cost).
+ * @param data Catalog file.
+ * @returns Items in catalog order.
+ */
+export function mcpCatalogItems(data) {
+    return data.servers.map((s) => ({ id: s.name, label: `~${s.tools_approx} tools — ${s.description} [${s.context_cost}]` }));
+}
+/**
+ * The `claude mcp add` command for a catalog entry (same shape the `mcp` capability emits).
+ * @param s Catalog entry.
+ * @param scope user -> `-s user`, project -> `-s local`.
+ * @returns Shell command.
+ */
+export function mcpAddCommand(s, scope) {
+    const sc = scope === "user" ? "user" : "local";
+    const envFlags = Object.entries(s.env ?? {}).map(([k, v]) => `-e ${k}=${v}`).join(" ");
+    if (s.type === "http" || s.type === "sse")
+        return `claude mcp add --transport ${s.type} ${s.name} -s ${sc} ${s.url}`;
+    return `claude mcp add ${s.name} -s ${sc}${envFlags ? ` ${envFlags}` : ""} -- ${s.command} ${(s.args ?? []).join(" ")}`;
+}
+/**
+ * Builds the MCP profile plan for a selection: one `claude mcp add` action per selected
+ * server, nothing for an empty selection.
+ * @param profile Registry entry.
+ * @param data Catalog file.
+ * @param selected Selected server names (unknown names are reported and ignored).
+ * @param ctx Pass context.
+ * @returns The plan (no manifest record: registrations live in ~/.claude.json, owned by `claude`).
+ */
+export function applyMcpProfile(profile, data, selected, ctx) {
+    const lines = [];
+    const actions = [];
+    const unknown = selected.filter((n) => !data.servers.some((s) => s.name === n));
+    for (const u of unknown)
+        lines.push(`  note:  unknown server '${u}' ignored (catalog: ${data.servers.map((s) => s.name).join(", ")})`);
+    const chosen = data.servers.filter((s) => selected.includes(s.name));
+    if (chosen.length === 0) {
+        lines.push("  note:  no server selected; nothing is registered (pass --select a,b or answer the prompt).");
+        return { profileId: profile.id, target: "claude-code", scope: ctx.scope, lines, actions, written: [] };
+    }
+    for (const s of chosen) {
+        lines.push(`  mcp:   ${s.name} (~${s.tools_approx} tools) — ${s.context_cost}`);
+        if (s.env)
+            lines.push(`         env placeholders to set: ${Object.keys(s.env).join(", ")}`);
+        actions.push({ description: `Register MCP server ${s.name} (~${s.tools_approx} tools; profile mcp)`, command: mcpAddCommand(s, ctx.scope), optional: true });
+    }
+    lines.push("  note:  tool schemas ride on every request; `freeharness doctor` lists the registered servers with these counts. Remove one with `claude mcp remove <name>`.");
+    return { profileId: profile.id, target: "claude-code", scope: ctx.scope, lines, actions, written: [] };
+}
+/**
+ * Plans (or applies) the removal of every profile recorded in the manifest: env keys and
+ * provider blocks we wrote, and the notes files. Foreign keys are never touched.
+ * @param existing Manifest records.
+ * @param dry When true nothing is written.
+ * @returns One plan per recorded profile (record = null).
+ */
+export function removeProfiles(existing, dry) {
+    const plans = [];
+    for (const [id, rec] of Object.entries(existing)) {
+        const lines = [];
+        const envKeys = rec.keys.filter((k) => !k.startsWith("provider."));
+        if (envKeys.length > 0) {
+            const removed = removeEnvKeys(rec.file, envKeys, dry);
+            lines.push(`  edit:  ${rec.file} (remove ${removed.length > 0 ? removed.join(", ") : "nothing: keys already gone"}; other env keys kept)`);
+        }
+        for (const k of rec.keys.filter((x) => x.startsWith("provider."))) {
+            const gone = removeProviderBlock(rec.file, k.slice("provider.".length), dry);
+            lines.push(`  edit:  ${rec.file} (${gone ? `remove ${k}` : `${k} already gone`}; other providers kept)`);
+        }
+        for (const f of rec.files) {
+            if (fs.existsSync(f)) {
+                if (!dry)
+                    fs.rmSync(f);
+                lines.push(`  rm:    ${f}`);
+            }
+        }
+        plans.push({ profileId: id, target: rec.target, scope: "user", lines, actions: [], record: null, written: [] });
+    }
+    return plans;
+}

package/dist/cli/runner.d.ts

@@ -0,0 +1,10 @@
+import type { AdapterResult, InstallContext } from "@freeharness/core";
+import type { InstallPlan } from "@freeharness/core";
+/**
+ * Applies every step of the plan through its target adapter. One adapter instance per
+ * target per pass, so adapters that emit shared scaffolding (the plugin manifest) do it once.
+ * @param plan The ordered install plan.
+ * @param base Install context shared by every step.
+ * @returns One result per step, in plan order.
+ */
+export declare function runPlan(plan: InstallPlan, base: InstallContext): Promise<AdapterResult[]>;

package/dist/cli/runner.js

@@ -0,0 +1,27 @@
+// Runner: emit files for an install plan through the harness adapters. The heavier
+// side effects are returned as actions and handled by the executor.
+import { getAdapter } from "../adapters/harness/index.js";
+import { getCapability } from "@freeharness/core";
+/**
+ * Applies every step of the plan through its target adapter. One adapter instance per
+ * target per pass, so adapters that emit shared scaffolding (the plugin manifest) do it once.
+ * @param plan The ordered install plan.
+ * @param base Install context shared by every step.
+ * @returns One result per step, in plan order.
+ */
+export async function runPlan(plan, base) {
+    const results = [];
+    const adapters = new Map();
+    for (const step of plan.steps) {
+        const cap = getCapability(step.capabilityId);
+        if (!cap)
+            continue;
+        let adapter = adapters.get(step.target);
+        if (!adapter) {
+            adapter = getAdapter(step.target);
+            adapters.set(step.target, adapter);
+        }
+        results.push(await adapter.apply(cap, base));
+    }
+    return results;
+}

package/dist/cli/uninstall.d.ts

@@ -0,0 +1,65 @@
+import type { Scope } from "@freeharness/core";
+/** Command substrings that identify the hook entries FreeHarness writes into settings.json. */
+export declare const OUR_HOOK_MARKERS: readonly ["freeharness-session-start", "freeharness-memory-guard", "freeharness-config-guard", "freeharness-repeat-tool", "freeharness-security-guidance", "freeharness-cost-tracker", "freeharness-output-pruner", "freeharness-context-monitor", "freeharness-precompact", "freeharness-auto-memory", "freeharness-converge"];
+/** What an uninstall pass would (or did) do. */
+export interface UninstallPlan {
+    manifest: string;
+    /** Files removed (or to remove). */
+    remove: string[];
+    /** Manifest entries already gone. */
+    missing: string[];
+    /** Manifest entries kept on purpose, with the reason. */
+    kept: {
+        path: string;
+        reason: string;
+    }[];
+    /** settings.json files whose FreeHarness hook entries are pruned. */
+    settings: string[];
+    /** Directories pruned because they became empty. */
+    prunedDirs: string[];
+}
+interface HookEntry {
+    matcher?: string;
+    hooks?: {
+        command?: string;
+    }[];
+}
+/**
+ * Tells whether a hook entry is one FreeHarness wrote.
+ * @param e A settings.json hook entry.
+ * @returns True when any of its commands carries our marker.
+ */
+export declare function isOurHook(e: HookEntry): boolean;
+/**
+ * Tells whether a hook entry is an upstream claude-mem wired into settings.json (`npx
+ * claude-mem start ...`); the plugin ships its own hooks.json, so the entry duplicates it.
+ * @param e A settings.json hook entry.
+ * @returns True when a command names claude-mem and the entry is not ours.
+ */
+export declare function isClaudeMemHook(e: HookEntry): boolean;
+/**
+ * Removes the hook entries of a settings.json that satisfy a predicate; every other entry
+ * and key is untouched. Emptied events and an emptied `hooks` object are dropped.
+ * @param settingsPath The settings.json.
+ * @param predicate Which entries to remove.
+ * @param dryRun Report only.
+ * @returns Number of entries removed (or that would be); 0 when the file is unreadable.
+ */
+export declare function pruneHooksMatching(settingsPath: string, predicate: (e: HookEntry) => boolean, dryRun: boolean): number;
+/**
+ * Removes FreeHarness hook entries from a settings.json; foreign entries, keys and
+ * `enabledPlugins` are untouched.
+ * @param settingsPath The settings.json.
+ * @param dryRun Report only.
+ * @returns Number of entries removed (or that would be).
+ */
+export declare function pruneOurHooks(settingsPath: string, dryRun: boolean): number;
+/**
+ * Runs (or previews) an uninstall for a scope.
+ * @param scope user | project.
+ * @param projectRoot Project root (project scope).
+ * @param dryRun Compute the plan without deleting anything.
+ * @returns The plan; undefined when no manifest exists.
+ */
+export declare function uninstallScope(scope: Scope, projectRoot: string, dryRun: boolean): UninstallPlan | undefined;
+export {};