@smeltjs/core 0.1.0 → 0.2.0

package/dist/cli/hooks.js

@@ -0,0 +1,1180 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, isAbsolute, join, relative, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createInterface } from 'node:readline/promises';
+import { CliUsageError } from '../errors.js';
+import { DEFAULT_SUGGESTION_BUDGET_BYTES, DEFAULT_THRESHOLD_BYTES } from '../hooks/guard-core.js';
+import { CLI_NAME } from './args.js';
+import { CONFIG_FILE_NAME, CONFIG_VERSION, findConfigFile, parseConfig } from './config.js';
+/** One line of honesty per tier, shown wherever a tier label appears. */
+export const TIER_HONESTY = {
+    verified: 'schema verified against primary docs and pinned by fixtures',
+    experimental: 'schema mapped from the 2026-09-02 capability matrix, not yet smoke-tested against the real binary',
+    advisory: 'no usable hook API — instructions only, nothing enforces them',
+};
+export const HARNESSES = [
+    {
+        id: 'claude-code',
+        name: 'Claude Code',
+        tier: 'verified',
+        detect: ['.claude'],
+        detectHome: ['.claude'],
+        instructionFile: 'CLAUDE.md',
+        caveats: [],
+    },
+    {
+        id: 'codex',
+        name: 'Codex CLI',
+        tier: 'verified',
+        detect: ['.codex'],
+        detectHome: ['.codex'],
+        instructionFile: 'AGENTS.md',
+        caveats: [
+            'project-level Codex hooks run only once the project is trusted (features.hooks; see docs/research/2026-09-02-agent-enforcement.md § 3)',
+        ],
+    },
+    {
+        id: 'gemini',
+        name: 'Gemini CLI',
+        tier: 'experimental',
+        detect: ['.gemini'],
+        detectHome: ['.gemini'],
+        instructionFile: 'GEMINI.md',
+        caveats: [
+            'Gemini policy-engine allow rules are ignored in non-interactive runs (google-gemini/gemini-cli#20469) — verify hook behaviour in CI before relying on it',
+        ],
+    },
+    {
+        id: 'grok',
+        name: 'Grok CLI',
+        tier: 'experimental',
+        detect: ['.grok'],
+        detectHome: ['.grok'],
+        instructionFile: 'AGENTS.md',
+        caveats: [
+            'deny-only hooks: input rewrite is not supported, so rewrite mode falls back to deny',
+        ],
+    },
+    {
+        id: 'hermes',
+        name: 'Hermes Agent',
+        tier: 'experimental',
+        detect: ['.hermes', '.hermes.md'],
+        detectHome: ['.hermes'],
+        instructionFile: 'AGENTS.md',
+        caveats: [
+            'Hermes memory tools bypass disabled_toolsets (NousResearch/hermes-agent#46171) — treat tool gating there as leaky',
+            'hook config may need merging into ~/.hermes/config.yaml by hand; the written file says how',
+        ],
+    },
+    {
+        id: 'cursor',
+        name: 'Cursor',
+        tier: 'experimental',
+        detect: ['.cursor'],
+        detectHome: ['.cursor'],
+        instructionFile: 'AGENTS.md',
+        caveats: ['Cursor has no static permission config — gating is entirely hook code'],
+    },
+    {
+        id: 'opencode',
+        name: 'opencode',
+        tier: 'experimental',
+        detect: ['.opencode', 'opencode.json'],
+        detectHome: ['.config/opencode'],
+        instructionFile: 'AGENTS.md',
+        caveats: [
+            'MCP tools can bypass opencode plugin hooks (sst/opencode#2319) — the guard sees built-in tools only',
+        ],
+    },
+    {
+        id: 'cline',
+        name: 'Cline',
+        tier: 'experimental',
+        detect: ['.clinerules'],
+        detectHome: [],
+        instructionFile: '.clinerules/smelt.md',
+        caveats: [
+            'deny-only hooks: input rewrite is not supported, so rewrite mode falls back to deny',
+        ],
+    },
+    {
+        id: 'kilocode',
+        name: 'KiloCode',
+        tier: 'advisory',
+        detect: ['.kilocode'],
+        detectHome: ['.config/kilo'],
+        instructionFile: '.kilocode/rules/smelt.md',
+        caveats: [
+            'no first-class hooks (Kilo-Org/kilocode#5827): enforcement is permissions config + MCP, both manual',
+        ],
+    },
+    {
+        id: 'aider',
+        name: 'Aider',
+        tier: 'advisory',
+        detect: ['.aider.conf.yml'],
+        detectHome: ['.aider.conf.yml'],
+        instructionFile: 'CONVENTIONS.md',
+        caveats: [
+            'Aider auto-reads no rules file: add `read: CONVENTIONS.md` to .aider.conf.yml (or pass --read CONVENTIONS.md) yourself',
+        ],
+    },
+];
+export function harnessById(id) {
+    return HARNESSES.find((spec) => spec.id === id);
+}
+/** A harness whose config directory exists in the project or the home directory. */
+export function detectedHarnesses(cwd, home) {
+    return HARNESSES.filter((spec) => spec.detect.some((path) => existsSync(join(cwd, path))) ||
+        spec.detectHome.some((path) => existsSync(join(home, path))));
+}
+/* ------------------------------------------------------------------------------------
+ * Paths and commands
+ * ---------------------------------------------------------------------------------- */
+/**
+ * The `dist` directory of this installed package — where the shipped guard-core and
+ * shim scripts live. Computed from this module's own location, which is
+ * `<pkg>/dist/cli/` in every real run (the CLI executes from `dist`); under the test
+ * runner it is `<pkg>/src/cli/`, and the substitution still points at `dist`, which
+ * is where the scripts will exist once built — the paths are written into config
+ * files for *node* to execute, never imported.
+ */
+function packageDistDir() {
+    const here = dirname(fileURLToPath(import.meta.url)); // <pkg>/(dist|src)/cli
+    return join(dirname(dirname(here)), 'dist');
+}
+function shimScriptPath(id) {
+    return join(packageDistDir(), 'hooks', 'shims', `${id}.js`);
+}
+function guardCoreScriptPath() {
+    return join(packageDistDir(), 'hooks', 'guard-core.js');
+}
+function smeltBinPath() {
+    return join(packageDistDir(), 'cli', 'bin.js');
+}
+/** Inside the project, a project-relative path travels with the repo; outside, absolute. */
+function portablePath(cwd, absolute) {
+    const rel = relative(cwd, absolute);
+    return rel.startsWith('..') || isAbsolute(rel) ? absolute : rel.split(sep).join('/');
+}
+function nodeCommand(cwd, script, args = '') {
+    return `node "${portablePath(cwd, script)}"${args === '' ? '' : ` ${args}`}`;
+}
+/* ------------------------------------------------------------------------------------
+ * Generated content
+ * ---------------------------------------------------------------------------------- */
+/** Marker lines bracketing every block this installer owns inside a shared file. */
+export const SNIPPET_START_MD = '<!-- smelt:hooks v1 start -->';
+export const SNIPPET_END_MD = '<!-- smelt:hooks v1 end -->';
+const SNIPPET_START_HASH = '# smelt:hooks v1 start';
+const SNIPPET_END_HASH = '# smelt:hooks v1 end';
+/** Substring that identifies a file (or JSON hook entry) as written by this installer. */
+const OURS_TOKEN = 'smelt:hooks';
+/**
+ * The instruction snippet — belt and braces under every shim, and the *only* layer
+ * for advisory harnesses. It teaches the three commands, and in particular what to do
+ * after a guard deny: run the named replacement, then `smelt retrieve` per marker.
+ */
+export function instructionSnippet(thresholdBytes, budgetBytes) {
+    return `${SNIPPET_START_MD}
+
+## smelt — context discipline
+
+This project uses [smelt](https://github.com/smeltjs/smelt) to keep large tool output
+out of the context window, reversibly.
+
+- Do not read files over ${String(thresholdBytes)} bytes raw. Run
+  \`smelt <file> --budget ${String(budgetBytes)} --focus <what you are looking for>\`
+  instead (repeat \`--focus\` per term). Focused regions survive verbatim; everything
+  else collapses into a one-line marker stating what was removed.
+- Every marker ends in \`retrieve("hash")\`. \`smelt retrieve <hash>\` prints the
+  exact original bytes back. Retrieve what you actually need — retrievals are counted,
+  and \`smelt stats\` reports the honest expansion rate.
+- For orientation, \`smelt map . --budget ${String(budgetBytes)}\` prints a ranked
+  symbol map of the repository.
+- If a smelt guard hook denies a raw read, run the exact replacement command named in
+  the denial, then \`smelt retrieve\` any marker you need expanded.
+
+${SNIPPET_END_MD}
+`;
+}
+/** Claude-style hook entry: one command under an optional matcher. */
+function commandEntry(matcher, command) {
+    return {
+        ...(matcher === undefined ? {} : { matcher }),
+        hooks: [{ type: 'command', command }],
+    };
+}
+/** The three preset hooks in Claude Code's schema; Codex's hooks.json mirrors it. */
+function claudeStyleEvents(ctx, shim, preToolEvent, matchers) {
+    const shimCommand = nodeCommand(ctx.cwd, shimScriptPath(shim));
+    // The trailing shell comment tags the entry as this installer's (see isOursEntry):
+    // a bare `cli/bin.js` substring would also match some other npm CLI's built binary.
+    const stats = `${nodeCommand(ctx.cwd, smeltBinPath(), 'stats')} 2>/dev/null || true # ${OURS_TOKEN}`;
+    const map = `${nodeCommand(ctx.cwd, smeltBinPath(), `map . --budget ${String(ctx.budgetBytes)} --cache .smelt/tags`)} 2>/dev/null || true # ${OURS_TOKEN}`;
+    return {
+        ...(ctx.guard
+            ? {
+                [preToolEvent]: [
+                    commandEntry(matchers.read, shimCommand),
+                    commandEntry(matchers.bash, shimCommand),
+                ],
+            }
+            : {}),
+        ...(ctx.statsOnStop ? { Stop: [commandEntry(undefined, stats)] } : {}),
+        ...(ctx.mapOnStart
+            ? { SessionStart: [commandEntry('startup|resume|clear|compact', map)] }
+            : {}),
+    };
+}
+/**
+ * True for a hook entry this installer wrote. Matched on the shim/guard script paths
+ * and the `smelt:hooks` token the stats/map commands carry — never on a substring as
+ * generic as `cli/bin.js`, which another npm CLI's built binary could share: remove
+ * and re-install may only ever touch entries that are provably smelt's.
+ */
+function isOursEntry(entry) {
+    const text = JSON.stringify(entry) ?? '';
+    return (text.includes('hooks/shims/') ||
+        text.includes('hooks/guard-core.js') ||
+        text.includes(OURS_TOKEN));
+}
+/** The events this installer manages; foreign entries under them are always preserved. */
+const MANAGED_EVENTS = ['PreToolUse', 'Stop', 'SessionStart', 'BeforeTool', 'preToolUse'];
+/**
+ * Merge our hook entries into a JSON settings file, preserving everything foreign
+ * **byte-faithfully**: the merged `hooks` value is spliced into the original text, so
+ * unknown top-level keys, string escapes, number spellings, indentation and key order
+ * outside the `hooks` property ride through verbatim (founder ruling: an installer
+ * that reformats somebody's settings file has edited what it was never asked to).
+ * Inside `hooks`, unmanaged events and other people's entries under managed events
+ * are preserved; our previous entries are replaced (that is what makes a re-run edit
+ * toggles), and events left with no entries disappear. A semantic no-op returns the
+ * input text unchanged. Returns `undefined` when the existing file is not a JSON
+ * object — the caller skips the file rather than clobbering something it cannot
+ * understand.
+ */
+export function mergeJsonHooks(existingText, events, shape = {}) {
+    let root = {};
+    if (existingText !== undefined) {
+        try {
+            const parsed = JSON.parse(existingText);
+            if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+                return undefined;
+            root = parsed;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const hooksValue = root['hooks'];
+    const existingHooks = typeof hooksValue === 'object' && hooksValue !== null && !Array.isArray(hooksValue)
+        ? hooksValue
+        : undefined;
+    const hooks = { ...existingHooks };
+    for (const event of MANAGED_EVENTS) {
+        const existing = Array.isArray(hooks[event]) ? hooks[event] : [];
+        const foreign = existing.filter((entry) => !isOursEntry(entry));
+        const ours = events[event] ?? [];
+        const merged = [...foreign, ...ours];
+        if (merged.length > 0)
+            hooks[event] = merged;
+        else
+            delete hooks[event];
+    }
+    const mergedHooks = Object.keys(hooks).length > 0 ? hooks : undefined;
+    // A brand-new file: nothing to preserve, render fresh two-space JSON.
+    if (existingText === undefined) {
+        const fresh = {};
+        if (mergedHooks !== undefined)
+            fresh['hooks'] = mergedHooks;
+        if (shape.version !== undefined)
+            fresh['version'] = shape.version;
+        return `${JSON.stringify(fresh, null, 2)}\n`;
+    }
+    const hooksChanged = JSON.stringify(existingHooks ?? null) !== JSON.stringify(mergedHooks ?? null);
+    const needsVersion = shape.version !== undefined && root['version'] === undefined;
+    if (!hooksChanged && !needsVersion)
+        return existingText;
+    const newline = existingText.includes('\r\n') ? '\r\n' : '\n';
+    const indent = /\n([ \t]+)"/.exec(existingText)?.[1] ?? '  ';
+    let text = existingText;
+    if (hooksChanged) {
+        const scan = scanJsonTopLevel(text);
+        /* v8 ignore next -- unreachable: JSON.parse accepted the same text above */
+        if (scan === undefined)
+            return undefined;
+        const property = scan.properties.find((candidate) => candidate.key === 'hooks');
+        if (mergedHooks === undefined) {
+            if (property !== undefined)
+                text = removeJsonProperty(text, scan, property);
+        }
+        else {
+            const rendered = renderJsonValue(mergedHooks, indent, newline);
+            text =
+                property !== undefined
+                    ? `${text.slice(0, property.valueStart)}${rendered}${text.slice(property.valueEnd)}`
+                    : insertJsonProperty(text, scan, 'hooks', rendered, indent, newline);
+        }
+    }
+    if (needsVersion) {
+        const scan = scanJsonTopLevel(text);
+        /* v8 ignore next -- unreachable: every splice above keeps the text valid JSON */
+        if (scan === undefined)
+            return undefined;
+        text = insertJsonProperty(text, scan, 'version', JSON.stringify(shape.version), indent, newline);
+    }
+    return text;
+}
+/**
+ * Locate the top-level properties of a JSON object *in its source text*, so one
+ * property can be replaced, inserted or removed while every other byte of the file
+ * rides through verbatim. `undefined` when the text is not an object — callers have
+ * already `JSON.parse`d it, so that is belt and braces, not a validator.
+ */
+function scanJsonTopLevel(text) {
+    let i = skipJsonWhitespace(text, 0);
+    if (text[i] !== '{')
+        return undefined;
+    const open = i;
+    i = skipJsonWhitespace(text, i + 1);
+    const properties = [];
+    if (text[i] === '}')
+        return { open, close: i, properties };
+    for (;;) {
+        if (text[i] !== '"')
+            return undefined;
+        const keyStart = i;
+        const keyEnd = skipJsonString(text, i);
+        if (keyEnd === undefined)
+            return undefined;
+        const key = JSON.parse(text.slice(keyStart, keyEnd));
+        i = skipJsonWhitespace(text, keyEnd);
+        if (text[i] !== ':')
+            return undefined;
+        const valueStart = skipJsonWhitespace(text, i + 1);
+        const valueEnd = skipJsonValue(text, valueStart);
+        if (valueEnd === undefined)
+            return undefined;
+        properties.push({ key, keyStart, valueStart, valueEnd });
+        i = skipJsonWhitespace(text, valueEnd);
+        if (text[i] === ',') {
+            i = skipJsonWhitespace(text, i + 1);
+            continue;
+        }
+        if (text[i] === '}')
+            return { open, close: i, properties };
+        return undefined;
+    }
+}
+function skipJsonWhitespace(text, from) {
+    let i = from;
+    while (i < text.length && ' \t\r\n'.includes(text[i]))
+        i += 1;
+    return i;
+}
+/** `from` points at `"`; returns the offset one past the closing quote. */
+function skipJsonString(text, from) {
+    let i = from + 1;
+    while (i < text.length) {
+        if (text[i] === '\\')
+            i += 2;
+        else if (text[i] === '"')
+            return i + 1;
+        else
+            i += 1;
+    }
+    return undefined;
+}
+function skipJsonValue(text, from) {
+    const first = text[from];
+    if (first === '"')
+        return skipJsonString(text, from);
+    if (first === '{' || first === '[') {
+        let depth = 0;
+        let i = from;
+        while (i < text.length) {
+            const ch = text[i];
+            if (ch === '"') {
+                const end = skipJsonString(text, i);
+                if (end === undefined)
+                    return undefined;
+                i = end;
+                continue;
+            }
+            if (ch === '{' || ch === '[')
+                depth += 1;
+            else if (ch === '}' || ch === ']') {
+                depth -= 1;
+                if (depth === 0)
+                    return i + 1;
+            }
+            i += 1;
+        }
+        return undefined;
+    }
+    // number / true / false / null
+    let i = from;
+    while (i < text.length && !',}] \t\r\n'.includes(text[i]))
+        i += 1;
+    return i > from ? i : undefined;
+}
+/** A JSON value indented for embedding at a top-level property position. */
+function renderJsonValue(value, indent, newline) {
+    return JSON.stringify(value, null, indent).split('\n').join(`${newline}${indent}`);
+}
+function removeJsonProperty(text, scan, property) {
+    const index = scan.properties.indexOf(property);
+    const next = scan.properties[index + 1];
+    if (next !== undefined) {
+        // Delete through the separating comma and whitespace, up to the next key.
+        return text.slice(0, property.keyStart) + text.slice(next.keyStart);
+    }
+    const previous = scan.properties[index - 1];
+    // Last (or only) property: delete the preceding comma (if any) with it.
+    const from = previous !== undefined ? previous.valueEnd : scan.open + 1;
+    return text.slice(0, from) + text.slice(property.valueEnd);
+}
+function insertJsonProperty(text, scan, key, renderedValue, indent, newline) {
+    const entry = `${JSON.stringify(key)}: ${renderedValue}`;
+    if (scan.properties.length === 0) {
+        return `${text.slice(0, scan.open + 1)}${newline}${indent}${entry}${newline}${text.slice(scan.close)}`;
+    }
+    const last = scan.properties[scan.properties.length - 1];
+    return `${text.slice(0, last.valueEnd)},${newline}${indent}${entry}${text.slice(last.valueEnd)}`;
+}
+/** Replace this installer's marker block in `existingText`, or append it. */
+export function upsertMarkerBlock(existingText, block, start, end) {
+    if (existingText === undefined || existingText.trim() === '')
+        return block;
+    const startIndex = existingText.indexOf(start);
+    const endIndex = existingText.indexOf(end);
+    if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
+        const before = existingText.slice(0, startIndex);
+        const after = existingText.slice(endIndex + end.length).replace(/^\n/, '');
+        return `${before}${block}${after}`;
+    }
+    return `${existingText.replace(/\n*$/, '\n\n')}${block}`;
+}
+/** Remove the marker block. `undefined` when nothing (or only whitespace) remains. */
+export function stripMarkerBlock(existingText, start, end) {
+    const startIndex = existingText.indexOf(start);
+    const endIndex = existingText.indexOf(end);
+    if (startIndex === -1 || endIndex === -1 || endIndex <= startIndex)
+        return existingText;
+    const stripped = existingText.slice(0, startIndex).replace(/\n+$/, '\n') +
+        existingText.slice(endIndex + end.length).replace(/^\n+/, '');
+    return stripped.trim() === '' ? undefined : stripped;
+}
+/** The Codex `config.toml` block: enables the hooks feature, marker-bracketed. */
+function codexConfigTomlBlock() {
+    return `${SNIPPET_START_HASH}
+# Enables Codex's hooks feature so .codex/hooks.json is honored. Project-level hooks
+# run only once this project is trusted. Written by \`smelt hooks install\`.
+[features]
+hooks = true
+${SNIPPET_END_HASH}
+`;
+}
+/** The opencode plugin — the shim for a harness whose hooks are a JS plugin API. */
+function opencodePluginSource(cwd) {
+    const guardCore = portablePath(cwd, guardCoreScriptPath());
+    return `// smelt:hooks v1 — opencode plugin shim. EXPERIMENTAL tier: mapped from the
+// capability matrix (docs/research/2026-09-02-harness-capability-matrix.md, opencode
+// row; https://opencode.ai/docs/plugins/). This template's deny/pass/window paths
+// were exercised directly against the built guard core (KOT-212 verification,
+// 2026-09-02), but a live opencode session has not been smoke-tested — that needs
+// provider credentials. Caveat carried from the matrix: MCP tools can bypass plugin
+// hooks (sst/opencode#2319) — this guard sees built-in tools only.
+//
+// Thin adapter: maps tool.execute.before onto the smelt guard core (zero
+// dependencies), which owns every decision. Deny mode throws (opencode surfaces the
+// reason to the model); rewrite mode substitutes the faithful replacement command —
+// announced on stderr, because the plugin API has no reason channel on a rewrite
+// and a substitution must never be silent.
+import { pathToFileURL } from 'node:url';
+
+const GUARD_CORE = ${JSON.stringify(guardCore)};
+const core = await import(pathToFileURL(GUARD_CORE).href);
+
+export const SmeltGuard = async () => ({
+  'tool.execute.before': async (input, output) => {
+    const tool = input?.tool;
+    const args = output?.args ?? {};
+    let request;
+    if (tool === 'read' && typeof args.filePath === 'string') {
+      request = {
+        tool: 'Read',
+        input: {
+          path: args.filePath,
+          offsetLimited: args.offset !== undefined || args.limit !== undefined,
+        },
+      };
+    } else if (tool === 'bash' && typeof args.command === 'string') {
+      request = { tool: 'Bash', input: { command: args.command } };
+    } else {
+      return;
+    }
+    const warn = (text) => process.stderr.write(text + '\\n');
+    const settings = core.readGuardSettings(process.cwd(), warn);
+    const decision = core.decide(request, settings, process.cwd());
+    if (decision.action !== 'deny') return;
+    if (
+      settings.enforcement === 'rewrite' &&
+      request.tool === 'Bash' &&
+      decision.suggestion !== undefined
+    ) {
+      warn(
+        'smelt guard (rewrite mode): substituted the command in-flight with \`' +
+          decision.suggestion +
+          '\`. ' +
+          (decision.reason ?? ''),
+      );
+      output.args.command = decision.suggestion;
+      return;
+    }
+    throw new Error(decision.reason ?? 'denied by the smelt guard');
+  },
+});
+`;
+}
+/** Cline's hook is an executable file; this two-liner hands it to the cline shim. */
+function clineHookSource(cwd) {
+    return `#!/bin/sh
+# smelt:hooks v1 — Cline PreToolUse hook. EXPERIMENTAL tier: schema mapped from the
+# capability matrix (docs/research/2026-09-02-harness-capability-matrix.md, Cline row),
+# not yet smoke-tested against the real binary. Written by \`smelt hooks install\`.
+exec node "${portablePath(cwd, shimScriptPath('cline'))}"
+`;
+}
+/** Hermes hook config, as a mergeable snippet — their config is a home-level YAML. */
+function hermesHooksYaml(cwd) {
+    return `${SNIPPET_START_HASH}
+# Hermes Agent hook config for the smelt guard. EXPERIMENTAL tier: schema mapped from
+# the capability matrix (docs/research/2026-09-02-harness-capability-matrix.md, Hermes
+# row), not yet smoke-tested against the real binary. If Hermes does not read this
+# file directly, merge the \`hooks:\` section into ~/.hermes/config.yaml.
+hooks:
+  pre_tool_call:
+    - command: node "${portablePath(cwd, shimScriptPath('hermes'))}"
+${SNIPPET_END_HASH}
+`;
+}
+/** KiloCode's advisory rules file: the snippet plus the two manual enforcement legs. */
+function kilocodeRulesSource(thresholdBytes, budgetBytes) {
+    return `${instructionSnippet(thresholdBytes, budgetBytes)}
+<!-- smelt:hooks v1 advisory notes -->
+
+KiloCode has no first-class hook API (Kilo-Org/kilocode#5827), so nothing above is
+enforced — it is advisory. Two manual legs make it harder to bypass:
+
+1. Permissions: in your KiloCode per-tool permission config, set raw-read/execute
+   tools to "ask" so oversized reads surface for review instead of passing silently.
+2. MCP: expose smelt through an MCP server and prefer its tools; a resident server
+   also keeps smelt's grammar cache warm across calls.
+`;
+}
+function planFile(cwd, name, content, mode) {
+    const path = join(cwd, name);
+    const exists = existsSync(path);
+    const unchanged = exists && readFileSync(path, 'utf8') === content;
+    return { name, path, content, exists, unchanged, ...(mode === undefined ? {} : { mode }) };
+}
+function readIfExists(path) {
+    return existsSync(path) ? readFileSync(path, 'utf8') : undefined;
+}
+/**
+ * Every file `install` would write, computed against the current disk state — pure
+ * planning, nothing written. Shared instruction files (several harnesses read
+ * AGENTS.md) are planned once.
+ *
+ * @throws {CliUsageError} when an existing `smelt.config.json` is malformed — the
+ *   same refusal every other subcommand makes; an installer that guessed around a
+ *   broken config would write settings the guard then ignores.
+ */
+export function planInstall(cwd, choices) {
+    const files = new Map();
+    const skipped = [];
+    const notes = [];
+    // -- smelt.config.json: the guard's runtime settings live here, not in any harness
+    // file, so every shim reads one source of truth.
+    const configPath = findConfigFile(cwd) ?? join(cwd, CONFIG_FILE_NAME);
+    const existingConfig = readIfExists(configPath) === undefined
+        ? undefined
+        : parseConfig(readFileSync(configPath, 'utf8'), configPath);
+    const hooksBlock = {
+        thresholdBytes: choices.thresholdBytes,
+        enforcement: choices.enforcement,
+    };
+    const budgetBytes = existingConfig?.defaultBudgetBytes ?? DEFAULT_SUGGESTION_BUDGET_BYTES;
+    files.set(configPath, {
+        name: portablePath(cwd, configPath),
+        path: configPath,
+        content: renderConfigWithHooks(existingConfig, hooksBlock),
+        exists: existsSync(configPath),
+        unchanged: readIfExists(configPath) === renderConfigWithHooks(existingConfig, hooksBlock),
+    });
+    const ctx = {
+        cwd,
+        guard: choices.guard,
+        statsOnStop: choices.statsOnStop,
+        mapOnStart: choices.mapOnStart,
+        budgetBytes,
+    };
+    const snippet = instructionSnippet(choices.thresholdBytes, budgetBytes);
+    const planJsonHooks = (name, events, shape = {}) => {
+        const path = join(cwd, name);
+        // Nothing to install and nothing to strip: don't create an empty hooks file.
+        if (Object.keys(events).length === 0 && !existsSync(path))
+            return;
+        const merged = mergeJsonHooks(readIfExists(path), events, shape);
+        if (merged === undefined) {
+            skipped.push({
+                name,
+                why: 'exists but is not a JSON object — fix or remove it, then re-run',
+            });
+            return;
+        }
+        files.set(path, planFile(cwd, name, merged));
+    };
+    const planSnippetFile = (name) => {
+        const path = join(cwd, name);
+        if (files.has(path))
+            return; // shared instruction file, already planned
+        files.set(path, planFile(cwd, name, upsertMarkerBlock(readIfExists(path), snippet, SNIPPET_START_MD, SNIPPET_END_MD)));
+    };
+    for (const spec of choices.harnesses) {
+        switch (spec.id) {
+            case 'claude-code': {
+                planJsonHooks('.claude/settings.json', claudeStyleEvents(ctx, 'claude-code', 'PreToolUse', { read: 'Read', bash: 'Bash' }));
+                break;
+            }
+            case 'codex': {
+                planJsonHooks('.codex/hooks.json', claudeStyleEvents(ctx, 'codex', 'PreToolUse', { read: 'Read', bash: 'Bash' }));
+                const tomlPath = join(cwd, '.codex/config.toml');
+                const existingToml = readIfExists(tomlPath);
+                if (existingToml !== undefined &&
+                    !existingToml.includes(SNIPPET_START_HASH) &&
+                    existingToml.includes('[features]')) {
+                    skipped.push({
+                        name: '.codex/config.toml',
+                        why: 'already has a [features] table — add `hooks = true` to it yourself',
+                    });
+                }
+                else {
+                    files.set(tomlPath, planFile(cwd, '.codex/config.toml', upsertMarkerBlock(existingToml, codexConfigTomlBlock(), SNIPPET_START_HASH, SNIPPET_END_HASH)));
+                }
+                break;
+            }
+            case 'gemini': {
+                planJsonHooks('.gemini/settings.json', ctx.guard
+                    ? {
+                        BeforeTool: [
+                            commandEntry('read_file', nodeCommand(cwd, shimScriptPath('gemini'))),
+                            commandEntry('run_shell_command', nodeCommand(cwd, shimScriptPath('gemini'))),
+                        ],
+                    }
+                    : {});
+                break;
+            }
+            case 'grok': {
+                planJsonHooks('.grok/hooks.json', ctx.guard
+                    ? {
+                        PreToolUse: [
+                            commandEntry('Read', nodeCommand(cwd, shimScriptPath('grok'))),
+                            commandEntry('Bash', nodeCommand(cwd, shimScriptPath('grok'))),
+                        ],
+                    }
+                    : {});
+                break;
+            }
+            case 'hermes': {
+                if (ctx.guard) {
+                    files.set(join(cwd, '.hermes/hooks.yaml'), planFile(cwd, '.hermes/hooks.yaml', hermesHooksYaml(cwd)));
+                }
+                break;
+            }
+            case 'cursor': {
+                planJsonHooks('.cursor/hooks.json', ctx.guard
+                    ? { preToolUse: [{ command: nodeCommand(cwd, shimScriptPath('cursor')) }] }
+                    : {}, { version: 1 });
+                break;
+            }
+            case 'opencode': {
+                if (ctx.guard) {
+                    files.set(join(cwd, '.opencode/plugin/smelt-guard.js'), planFile(cwd, '.opencode/plugin/smelt-guard.js', opencodePluginSource(cwd)));
+                }
+                break;
+            }
+            case 'cline': {
+                if (ctx.guard) {
+                    files.set(join(cwd, '.clinerules/hooks/PreToolUse'), planFile(cwd, '.clinerules/hooks/PreToolUse', clineHookSource(cwd), 0o755));
+                }
+                break;
+            }
+            case 'kilocode': {
+                files.set(join(cwd, spec.instructionFile), planFile(cwd, spec.instructionFile, kilocodeRulesSource(choices.thresholdBytes, budgetBytes)));
+                break;
+            }
+            case 'aider':
+                break; // instruction file only, planned below
+        }
+        if (spec.id !== 'kilocode')
+            planSnippetFile(spec.instructionFile);
+        for (const caveat of spec.caveats)
+            notes.push(`${spec.name}: ${caveat}`);
+    }
+    return { files: [...files.values()], skipped, notes };
+}
+/** Where the installed config points the persistent store, relative to the config file. */
+export const DEFAULT_STORE_DIR = '.smelt/store';
+/**
+ * Existing config re-rendered with the hooks block, other fields carried verbatim —
+ * except that a config with **no** store block gains a directory store. The deny
+ * reasons and the instruction snippet teach `smelt retrieve <hash>`, and retrieval
+ * across processes needs a persistent store (`smelt retrieve` refuses a memory
+ * store, exit 2) — an install whose own guard promises a command the installed
+ * config cannot run would be the exact silent-failure shape this project refuses.
+ * An *explicit* `{"kind":"memory"}` is respected; the guard then conditions its
+ * retrieve promise on the store kind instead (`retrieveSentence` in guard-core).
+ */
+export function renderConfigWithHooks(existing, hooks) {
+    const config = {
+        smeltConfig: CONFIG_VERSION,
+        ...(existing?.defaultBudgetBytes === undefined
+            ? {}
+            : { defaultBudgetBytes: existing.defaultBudgetBytes }),
+        ...(existing?.strategy === undefined ? {} : { strategy: existing.strategy }),
+        store: existing?.store ?? { kind: 'directory', path: DEFAULT_STORE_DIR },
+        hooks,
+    };
+    return `${JSON.stringify(config, null, 2)}\n`;
+}
+/** Everything `remove` would delete or strip, computed against the current disk state. */
+export function planRemove(cwd, harnesses) {
+    const removals = new Map();
+    const planJsonStrip = (name) => {
+        const path = join(cwd, name);
+        const existing = readIfExists(path);
+        if (existing === undefined)
+            return;
+        const stripped = mergeJsonHooks(existing, {});
+        if (stripped === undefined || stripped === existing)
+            return;
+        const remains = JSON.parse(stripped);
+        const empty = typeof remains === 'object' &&
+            remains !== null &&
+            Object.keys(remains).filter((key) => key !== 'version').length ===
+                0;
+        removals.set(path, empty && existing.includes('hooks')
+            ? { name, path, action: 'delete' }
+            : { name, path, action: 'modify', content: stripped });
+    };
+    const planBlockStrip = (name, start, end) => {
+        const path = join(cwd, name);
+        const existing = readIfExists(path);
+        if (existing === undefined || !existing.includes(start))
+            return;
+        const stripped = stripMarkerBlock(existing, start, end);
+        removals.set(path, stripped === undefined
+            ? { name, path, action: 'delete' }
+            : { name, path, action: 'modify', content: stripped });
+    };
+    const planWholeFileDelete = (name) => {
+        const path = join(cwd, name);
+        const existing = readIfExists(path);
+        if (existing === undefined || !existing.includes(OURS_TOKEN))
+            return;
+        removals.set(path, { name, path, action: 'delete' });
+    };
+    for (const spec of harnesses) {
+        switch (spec.id) {
+            case 'claude-code':
+                planJsonStrip('.claude/settings.json');
+                break;
+            case 'codex':
+                planJsonStrip('.codex/hooks.json');
+                planBlockStrip('.codex/config.toml', SNIPPET_START_HASH, SNIPPET_END_HASH);
+                break;
+            case 'gemini':
+                planJsonStrip('.gemini/settings.json');
+                break;
+            case 'grok':
+                planJsonStrip('.grok/hooks.json');
+                break;
+            case 'hermes':
+                planWholeFileDelete('.hermes/hooks.yaml');
+                break;
+            case 'cursor':
+                planJsonStrip('.cursor/hooks.json');
+                break;
+            case 'opencode':
+                planWholeFileDelete('.opencode/plugin/smelt-guard.js');
+                break;
+            case 'cline':
+                planWholeFileDelete('.clinerules/hooks/PreToolUse');
+                break;
+            case 'kilocode':
+            case 'aider':
+                break;
+        }
+        if (spec.id === 'kilocode')
+            planWholeFileDelete(spec.instructionFile);
+        else
+            planBlockStrip(spec.instructionFile, SNIPPET_START_MD, SNIPPET_END_MD);
+    }
+    return [...removals.values()];
+}
+/**
+ * `smelt hooks <install|remove>`, start to finish. The same testability pattern as
+ * `runInit`: a pure function over an input/output pair, exit code returned.
+ */
+export async function runHooks(action, harnessFlag, io) {
+    const rl = createInterface({ input: io.input });
+    const lines = rl[Symbol.asyncIterator]();
+    const ask = async (prompt) => {
+        io.output(prompt);
+        const next = await lines.next();
+        if (next.done === true) {
+            throw new CliUsageError(`${CLI_NAME} hooks: input ended before the wizard finished. ` +
+                `Files already confirmed and written stay; nothing further was written.`);
+        }
+        return next.value.trim();
+    };
+    try {
+        return action === 'install'
+            ? await installFlow(io, ask, harnessFlag)
+            : await removeFlow(io, ask, harnessFlag);
+    }
+    finally {
+        rl.close();
+    }
+}
+function resolveHarnessFlag(flag) {
+    const spec = harnessById(flag);
+    if (spec === undefined) {
+        throw new CliUsageError(`${CLI_NAME} hooks: unknown harness "${flag}". ` +
+            `Known: ${HARNESSES.map((h) => h.id).join(', ')}.`);
+    }
+    return spec;
+}
+function tierLabel(spec) {
+    return `${spec.id.padEnd(12)} ${spec.name.padEnd(14)} [${spec.tier}] — ${TIER_HONESTY[spec.tier]}`;
+}
+async function installFlow(io, ask, harnessFlag) {
+    const home = io.home ?? homedir();
+    const detected = detectedHarnesses(io.cwd, home);
+    io.output(`${CLI_NAME} hooks install — wires the smelt guard into agent-harness hooks.\n` +
+        `Answer \`back\` at any step to return to the previous one. Nothing is written ` +
+        `until you confirm at the end.\n\n`);
+    const choices = {
+        harnesses: harnessFlag !== undefined ? [resolveHarnessFlag(harnessFlag)] : [...detected],
+        ...presetToggles(io.cwd),
+        enforcement: 'deny',
+        thresholdBytes: DEFAULT_THRESHOLD_BYTES,
+    };
+    // With --harness the selection step is skipped, so the tier label — and its one
+    // line of honesty about what the tier means — is printed here instead.
+    if (harnessFlag !== undefined) {
+        for (const spec of choices.harnesses)
+            io.output(`  ${tierLabel(spec)}\n`);
+    }
+    const steps = [
+        async (io_, ask_) => harnessFlag !== undefined ? 'ok' : stepHarnesses(io_, ask_, choices, detected),
+        async (io_, ask_) => stepToggle(io_, ask_, 'PreToolUse size-guard', guardCopy(), choices.guard, (on) => {
+            choices.guard = on;
+        }),
+        async (io_, ask_) => stepToggle(io_, ask_, 'stats on Stop', `\`smelt stats\` runs when a session ends — the honest signal (expansion rate) ` +
+            `surfaced where the turn ends. Observation only; never blocks. Wired for ` +
+            `verified-tier harnesses (Claude Code, Codex).`, choices.statsOnStop, (on) => {
+            choices.statsOnStop = on;
+        }),
+        async (io_, ask_) => stepToggle(io_, ask_, 'repo map on SessionStart', `\`smelt map . --budget …\` runs at session start and its output opens the ` +
+            `context — the agent starts oriented. Costs one map build per session. ` +
+            `Wired for verified-tier harnesses (Claude Code, Codex).`, choices.mapOnStart, (on) => {
+            choices.mapOnStart = on;
+        }),
+        async (io_, ask_) => stepEnforcement(io_, ask_, choices),
+        async (io_, ask_) => stepThreshold(io_, ask_, choices),
+    ];
+    let index = 0;
+    for (;;) {
+        while (index < steps.length) {
+            const outcome = await steps[index](io, ask);
+            if (outcome === 'back') {
+                if (index === 0)
+                    io.output(`This is the first step — there is nothing before it.\n`);
+                else
+                    index -= 1;
+            }
+            else {
+                index += 1;
+            }
+        }
+        if (choices.harnesses.length === 0) {
+            io.output(`No harness selected. Nothing to do; nothing was written.\n`);
+            return 0;
+        }
+        const verdict = await confirmAndInstall(io, ask, choices);
+        if (verdict !== 'back')
+            return 0;
+        index = steps.length - 1;
+    }
+}
+function guardCopy() {
+    return (`Denies raw Reads (and simple \`cat\`s) of files over the size threshold, with a ` +
+        `reason naming the exact \`smelt\` replacement — the model still sees everything: ` +
+        `smelted first, \`smelt retrieve\` for the rest. Windowed reads (offset/limit) ` +
+        `always pass.`);
+}
+async function stepHarnesses(io, ask, choices, detected) {
+    io.output(`\nHarnesses — detected by their config directories (project or home):\n`);
+    for (const spec of HARNESSES) {
+        const mark = detected.includes(spec) ? '*' : ' ';
+        io.output(`  ${mark} ${tierLabel(spec)}\n`);
+    }
+    io.output(`(* = detected here)\n`);
+    for (;;) {
+        const current = choices.harnesses.map((spec) => spec.id).join(',') || '(none)';
+        const answer = await ask(`install for which? (comma-separated ids, Enter = ${current}, or back)\n> `);
+        if (answer === 'back')
+            return 'back';
+        if (answer === '')
+            return 'ok';
+        const ids = answer
+            .split(',')
+            .map((id) => id.trim())
+            .filter((id) => id !== '');
+        const specs = [];
+        let bad;
+        for (const id of ids) {
+            const spec = harnessById(id);
+            if (spec === undefined)
+                bad = id;
+            else if (!specs.includes(spec))
+                specs.push(spec);
+        }
+        if (bad !== undefined) {
+            io.output(`Unknown harness "${bad}". Known: ${HARNESSES.map((h) => h.id).join(', ')}.\n`);
+            continue;
+        }
+        choices.harnesses = specs;
+        return 'ok';
+    }
+}
+async function stepToggle(io, ask, name, copy, current, set) {
+    io.output(`\n${name} — ${copy}\n`);
+    for (;;) {
+        const answer = await ask(`${name}? (on/off) [${current ? 'on' : 'off'}] (or back)> `);
+        if (answer === 'back')
+            return 'back';
+        if (answer === '')
+            return 'ok';
+        if (answer === 'on' || answer === 'off') {
+            set(answer === 'on');
+            return 'ok';
+        }
+        io.output(`on, off, or back.\n`);
+    }
+}
+async function stepEnforcement(io, ask, choices) {
+    io.output(`\nEnforcement — what happens when the guard catches an oversized raw read:\n` +
+        `  1. deny     — refuse with a reason naming the exact replacement command. The\n` +
+        `                transcript stays truthful; the model runs the replacement itself.\n` +
+        `  2. rewrite  — on harnesses whose hooks can modify tool input, substitute the\n` +
+        `                replacement in-flight (grep/cat piped through smelt). Never\n` +
+        `                silent: the substitution is announced in the decision reason\n` +
+        `                where the harness has one, on stderr where it does not.\n` +
+        `                Harnesses that cannot rewrite fall back to deny.\n`);
+    for (;;) {
+        const current = choices.enforcement === 'deny' ? '1' : '2';
+        const answer = await ask(`enforcement (1/2) [${current}] (or back)> `);
+        if (answer === 'back')
+            return 'back';
+        const pick = answer === '' ? current : answer;
+        if (pick === '1' || pick === '2') {
+            choices.enforcement = pick === '1' ? 'deny' : 'rewrite';
+            return 'ok';
+        }
+        io.output(`1 for deny, 2 for rewrite, or back.\n`);
+    }
+}
+async function stepThreshold(io, ask, choices) {
+    io.output(`\nSize threshold — reads at or under this many bytes always pass. The ${String(DEFAULT_THRESHOLD_BYTES)}-byte default comes from the measured validation in ` +
+        `docs/research/2026-09-02-agent-enforcement.md § 5.\n`);
+    for (;;) {
+        const answer = await ask(`threshold in bytes [${String(choices.thresholdBytes)}] (or back)> `);
+        if (answer === 'back')
+            return 'back';
+        if (answer === '')
+            return 'ok';
+        if (/^\d+$/.test(answer) && Number(answer) > 0) {
+            choices.thresholdBytes = Number(answer);
+            return 'ok';
+        }
+        io.output(`A whole number of bytes greater than zero, e.g. 8192.\n`);
+    }
+}
+/** The JSON hook files a re-run reads installed toggles back from, per harness. */
+const TOGGLE_READBACK_FILES = [
+    '.claude/settings.json',
+    '.codex/hooks.json',
+    '.gemini/settings.json',
+    '.grok/hooks.json',
+    '.cursor/hooks.json',
+];
+/** Guard-only files whose presence means the guard toggle was installed. */
+const GUARD_ONLY_FILES = [
+    '.hermes/hooks.yaml',
+    '.opencode/plugin/smelt-guard.js',
+    '.clinerules/hooks/PreToolUse',
+];
+/** The managed events that wire the PreToolUse guard, across harness spellings. */
+const GUARD_EVENTS = ['PreToolUse', 'BeforeTool', 'preToolUse'];
+/**
+ * A re-run reads the toggles back off what is actually installed — every JSON hook
+ * file this installer writes, plus the guard-only shim files — so it edits instead of
+ * resetting. Harnesses that only wire the guard (gemini, grok, cursor, hermes,
+ * opencode, cline) persist no stats/map entries, so after a re-run scoped to them
+ * those toggles read back as off; the defaults below apply only when nothing of
+ * smelt's is installed at all.
+ */
+function presetToggles(cwd) {
+    const defaults = { guard: true, statsOnStop: true, mapOnStart: false };
+    let anyOurs = false;
+    let guard = false;
+    let statsOnStop = false;
+    let mapOnStart = false;
+    for (const name of TOGGLE_READBACK_FILES) {
+        const text = readIfExists(join(cwd, name));
+        if (text === undefined)
+            continue;
+        let hooks;
+        try {
+            const parsed = JSON.parse(text);
+            const hooksValue = typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)
+                ? parsed['hooks']
+                : undefined;
+            hooks =
+                typeof hooksValue === 'object' && hooksValue !== null && !Array.isArray(hooksValue)
+                    ? hooksValue
+                    : undefined;
+        }
+        catch {
+            hooks = undefined;
+        }
+        if (hooks === undefined)
+            continue;
+        const installed = hooks;
+        const hasOurs = (event) => Array.isArray(installed[event]) &&
+            installed[event].some((entry) => isOursEntry(entry));
+        if (!MANAGED_EVENTS.some((event) => hasOurs(event)))
+            continue;
+        anyOurs = true;
+        guard ||= GUARD_EVENTS.some((event) => hasOurs(event));
+        statsOnStop ||= hasOurs('Stop');
+        mapOnStart ||= hasOurs('SessionStart');
+    }
+    for (const name of GUARD_ONLY_FILES) {
+        const text = readIfExists(join(cwd, name));
+        if (text !== undefined && text.includes(OURS_TOKEN)) {
+            anyOurs = true;
+            guard = true;
+        }
+    }
+    return anyOurs ? { guard, statsOnStop, mapOnStart } : defaults;
+}
+const fileLabel = (file) => {
+    if (file.unchanged)
+        return 'unchanged — nothing to write';
+    return file.exists ? 'exists — will ask before overwriting' : 'new';
+};
+async function confirmAndInstall(io, ask, choices) {
+    const plan = planInstall(io.cwd, choices);
+    io.output(`\nAbout to write, into ${io.cwd}:\n` +
+        plan.files.map((file) => `  ${file.name.padEnd(32)} (${fileLabel(file)})\n`).join('') +
+        plan.skipped.map((skip) => `  ${skip.name.padEnd(32)} (SKIPPED: ${skip.why})\n`).join('') +
+        `Nothing has been written yet.\n`);
+    for (;;) {
+        const answer = await ask(`confirm (yes / no / back)> `);
+        if (answer === 'back')
+            return 'back';
+        if (answer === 'no') {
+            io.output(`Nothing was written.\n`);
+            return 'done';
+        }
+        if (answer === 'yes')
+            break;
+        io.output(`yes to write, no to leave everything untouched, back to change a setting.\n`);
+    }
+    for (const file of plan.files) {
+        if (file.unchanged) {
+            io.output(`  ${file.name} — unchanged, not rewritten\n`);
+            continue;
+        }
+        if (file.exists) {
+            // The one hard rule, same as `smelt init`: an existing file is never touched
+            // without an explicit per-file yes — not `y`, not Enter, a literal `yes`.
+            const answer = await ask(`  ${file.name} exists — overwrite it? (yes/no)> `);
+            if (answer !== 'yes') {
+                io.output(`  skipped ${file.name} — the existing file was not touched\n`);
+                continue;
+            }
+        }
+        mkdirSync(dirname(file.path), { recursive: true });
+        writeFileSync(file.path, file.content);
+        if (file.mode !== undefined)
+            chmodSync(file.path, file.mode);
+        io.output(`  wrote ${file.name}\n`);
+    }
+    for (const note of plan.notes)
+        io.output(`note: ${note}\n`);
+    io.output(`Done. Re-run \`${CLI_NAME} hooks install\` to edit toggles; ` +
+        `\`${CLI_NAME} hooks remove\` takes it all back out.\n`);
+    return 'done';
+}
+async function removeFlow(io, ask, harnessFlag) {
+    const harnesses = harnessFlag !== undefined ? [resolveHarnessFlag(harnessFlag)] : [...HARNESSES];
+    const removals = planRemove(io.cwd, harnesses);
+    if (removals.length === 0) {
+        io.output(`${CLI_NAME} hooks remove: nothing of smelt's found to remove in ${io.cwd}.\n`);
+        return 0;
+    }
+    io.output(`${CLI_NAME} hooks remove — takes smelt's hook wiring back out.\n\nPlanned:\n` +
+        removals
+            .map((removal) => `  ${removal.name.padEnd(32)} (${removal.action === 'delete' ? 'delete' : 'remove smelt entries, keep the rest'})\n`)
+            .join('') +
+        `${CONFIG_FILE_NAME} is left untouched — its hooks block is your config now; ` +
+        `edit or remove it there.\nNothing has been changed yet.\n`);
+    for (;;) {
+        const answer = await ask(`confirm (yes / no)> `);
+        if (answer === 'no') {
+            io.output(`Nothing was changed.\n`);
+            return 0;
+        }
+        if (answer === 'yes')
+            break;
+        io.output(`yes to proceed, no to leave everything untouched.\n`);
+    }
+    for (const removal of removals) {
+        const verb = removal.action === 'delete' ? 'delete' : 'modify';
+        const answer = await ask(`  ${removal.name} — ${verb} it? (yes/no)> `);
+        if (answer !== 'yes') {
+            io.output(`  skipped ${removal.name} — not touched\n`);
+            continue;
+        }
+        if (removal.action === 'delete') {
+            unlinkSync(removal.path);
+            io.output(`  deleted ${removal.name}\n`);
+        }
+        else {
+            writeFileSync(removal.path, removal.content ?? '');
+            io.output(`  cleaned ${removal.name}\n`);
+        }
+    }
+    io.output(`Done.\n`);
+    return 0;
+}
+//# sourceMappingURL=hooks.js.map