@smeltjs/core 0.3.0 → 0.5.0

package/dist/cli/hooks.js

@@ -1,13 +1,16 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { join } from 'node:path';
 import { CliUsageError } from '../errors.js';
 import { nodeCommand, portablePath, shimScriptPath, smeltBinPath } from '../harness/paths.js';
 import { hasShim, TIER_HONESTY } from '../harness/profile.js';
-import { GUARD_EVENTS, GUARD_ONLY_FILES, HARNESSES, harnessById, JSON_HOOK_FILES, LIFECYCLE_EVENTS, MANAGED_EVENTS, } from '../harness/registry.js';
+import { GUARD_EVENTS, GUARD_ONLY_FILES, HARNESSES, harnessById, harnessNames, JSON_HOOK_FILES, LIFECYCLE_EVENTS, lifecycleHarnesses, MANAGED_EVENTS, } from '../harness/registry.js';
 import { instructionSnippet, OURS_TOKEN, SNIPPET_END_MD, SNIPPET_START_MD, } from '../harness/snippet.js';
 import { DEFAULT_SUGGESTION_BUDGET_BYTES, DEFAULT_THRESHOLD_BYTES } from '../hooks/guard-core.js';
-import { answerReader, CLI_NAME } from './shell.js';
+import { editJsonProperty, editTopLevelProperty, jsonStyle, stripMarkerBlock, upsertMarkerBlock, } from '../text/json-edit.js';
+import { SETUP_RECIPE } from '../setup/recipe.js';
+import { confirmLoop, confirmYesNo, listPlannedFiles, walkSteps, wizardAsk, writePlannedFile, } from './wizard.js';
+import { CLI_NAME } from './shell.js';
 import { CONFIG_FILE_NAME, CONFIG_VERSION, findConfigFile, parseConfig, renderConfig, } from './config.js';
 export { instructionSnippet, SNIPPET_END_MD, SNIPPET_START_MD };
 /** A harness whose config directory exists in the project or the home directory. */
@@ -40,15 +43,26 @@ function shimCommand(profile, cwd) {
 }
 /**
  * One harness's hook entries: the guard under each matcher its schema spells, plus
- * the two session-lifecycle hooks for the harnesses whose schema carries them. Every
+ * the session-lifecycle hooks for the harnesses whose schema carries them. Every
  * toggle the wizard offers is a key that is present or absent here — an absent key is
  * how a re-run turns a toggle *off*, because the merge deletes what it no longer sees.
+ *
+ * The two `SessionStart` toggles — the opening map and the instruction-file lint —
+ * are **concatenated into one array**, not spread as two objects. Spreading would put
+ * the same computed key twice in one literal, and the second would silently replace
+ * the first: turning the lint on would turn the map off, with no error anywhere. It is
+ * the shape of bug this file exists to refuse, one layer up from the config it writes.
  */
 function jsonHookEvents(step, ctx, command) {
     // 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}`;
+    const map = `${nodeCommand(ctx.cwd, smeltBinPath(), `${MAP_ON_START_ARGS} --budget ${String(ctx.budgetBytes)} --cache .smelt/tags`)} 2>/dev/null || true # ${OURS_TOKEN}`;
+    const lint = `${nodeCommand(ctx.cwd, smeltBinPath(), AGENTS_LINT_ARGS)} 2>/dev/null || true # ${OURS_TOKEN}`;
+    const sessionStart = [
+        ...(ctx.mapOnStart ? [commandEntry(SESSION_START_MATCHER, map)] : []),
+        ...(ctx.lintOnStart ? [commandEntry(SESSION_START_MATCHER, lint)] : []),
+    ];
     return {
         ...(ctx.guard
             ? {
@@ -58,11 +72,20 @@ function jsonHookEvents(step, ctx, command) {
         ...(step.lifecycle && ctx.statsOnStop
             ? { [LIFECYCLE_EVENTS.stats]: [commandEntry(undefined, stats)] }
             : {}),
-        ...(step.lifecycle && ctx.mapOnStart
-            ? { [LIFECYCLE_EVENTS.map]: [commandEntry('startup|resume|clear|compact', map)] }
-            : {}),
+        ...(step.lifecycle && sessionStart.length > 0 ? { [LIFECYCLE_EVENTS.map]: sessionStart } : {}),
     };
 }
+/** The matcher both `SessionStart` entries fire under — a session opening, however. */
+const SESSION_START_MATCHER = 'startup|resume|clear|compact';
+/**
+ * The two `SessionStart` commands' distinguishing arguments, and **the substrings a
+ * re-run recognises each entry by**. Spelled once so the writer and the reader cannot
+ * drift: `presetToggles` tells the two entries apart by the command each one runs, and
+ * a wizard that wrote `agents lint .` while its reader looked for `agents lint` would
+ * read every re-run's lint toggle back as off and quietly delete it.
+ */
+const MAP_ON_START_ARGS = 'map .';
+export const AGENTS_LINT_ARGS = 'agents lint .';
 /**
  * True for a hook entry this installer wrote. Matched on the shim script paths and the
  * `smelt:hooks` token the stats/map commands carry — never on a substring as generic
@@ -128,176 +151,23 @@ export function mergeJsonHooks(existingText, events, shape = {}) {
     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] ?? '  ';
+    // The style is read once, off the original: a second edit must match the first.
+    const style = jsonStyle(existingText);
     let text = existingText;
     if (hooksChanged) {
-        const scan = scanJsonTopLevel(text);
+        text = editTopLevelProperty(text, 'hooks', mergedHooks, style);
         /* v8 ignore next -- unreachable: JSON.parse accepted the same text above */
-        if (scan === undefined)
+        if (text === 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);
+        text = editTopLevelProperty(text, 'version', shape.version, style);
         /* v8 ignore next -- unreachable: every splice above keeps the text valid JSON */
-        if (scan === undefined)
+        if (text === 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;
-}
 function planFile(cwd, name, content, mode) {
     const path = join(cwd, name);
     const exists = existsSync(path);
@@ -341,13 +211,15 @@ export function planInstall(cwd, choices) {
     });
     const ctx = {
         cwd,
+        ...(choices.writtenBy === undefined ? {} : { writtenBy: choices.writtenBy }),
         guard: choices.guard,
         statsOnStop: choices.statsOnStop,
         mapOnStart: choices.mapOnStart,
+        lintOnStart: choices.lintOnStart,
         thresholdBytes: choices.thresholdBytes,
         budgetBytes,
     };
-    const snippet = instructionSnippet(choices.thresholdBytes, budgetBytes);
+    const snippet = instructionSnippet(choices.thresholdBytes, budgetBytes, choices.writtenBy);
     const planJsonHooks = (name, events, shape = {}) => {
         const path = join(cwd, name);
         // Nothing to install and nothing to strip: don't create an empty hooks file.
@@ -393,6 +265,21 @@ export function planInstall(cwd, choices) {
                         break;
                     files.set(join(cwd, step.file), planFile(cwd, step.file, step.content(ctx), step.mode));
                     break;
+                case 'mcp-registration': {
+                    // Byte-faithful beside whatever servers the user already registered —
+                    // sibling entries, key order and indentation all ride through.
+                    const existing = readIfExists(join(cwd, step.file));
+                    const merged = editJsonProperty(existing ?? '{}', step.path, step.entry(ctx), existing === undefined ? undefined : jsonStyle(existing));
+                    if (merged === undefined) {
+                        skipped.push({
+                            name: step.file,
+                            why: 'exists but is not a JSON object — fix or remove it, then re-run',
+                        });
+                        break;
+                    }
+                    files.set(join(cwd, step.file), planFile(cwd, step.file, merged));
+                    break;
+                }
             }
         }
         if (profile.instructions === 'snippet') {
@@ -407,7 +294,7 @@ export function planInstall(cwd, choices) {
     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';
+export const DEFAULT_STORE_DIR = SETUP_RECIPE.store.defaultDir;
 /**
  * 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
@@ -421,14 +308,18 @@ export const DEFAULT_STORE_DIR = '.smelt/store';
  * That store injection is this verb's **policy**, which is why it lives here; the
  * bytes are written by `renderConfig` in `config.ts`, the one writer, so a key added
  * to the schema reaches this file and `init`'s together or not at all.
+ *
+ * "Carried verbatim" is spelled as a spread rather than as a list of the fields to
+ * copy, and that is load-bearing: the list version silently dropped every key nobody
+ * remembered to add to it — `agents` was added to the schema and this function kept
+ * writing configs without it, which is a setting the user believed was in force,
+ * caught by `test/guards/config-writer.test.ts`. Only the two fields this verb
+ * actually decides are named.
  */
 export function renderConfigWithHooks(existing, hooks) {
     return renderConfig({
+        ...existing,
         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,
     });
@@ -475,6 +366,30 @@ export function planRemove(cwd, harnesses) {
             return;
         removals.set(path, { name, path, action: 'delete' });
     };
+    /**
+     * The registration comes back out the way it went in: the server entry lifted,
+     * byte-faithfully, from its container. A container this install created — empty
+     * once the entry is gone — is removed with it, so a file that never carried the
+     * key round-trips to byte-identical; one that carries other servers keeps them.
+     */
+    const planMcpStrip = (name, keys) => {
+        const path = join(cwd, name);
+        const existing = readIfExists(path);
+        if (existing === undefined)
+            return;
+        const removed = editJsonProperty(existing, keys, undefined);
+        if (removed === undefined || removed === existing)
+            return;
+        let remains;
+        try {
+            remains = JSON.parse(removed);
+        }
+        catch {
+            return; // unreachable — the editor only returns parseable text; refuse to guess
+        }
+        const empty = typeof remains === 'object' && remains !== null && Object.keys(remains).length === 0;
+        removals.set(path, empty ? { name, path, action: 'delete' } : { name, path, action: 'modify', content: removed });
+    };
     for (const profile of harnesses) {
         for (const step of profile.install) {
             switch (step.kind) {
@@ -487,6 +402,9 @@ export function planRemove(cwd, harnesses) {
                 case 'own-file':
                     planWholeFileDelete(step.file);
                     break;
+                case 'mcp-registration':
+                    planMcpStrip(step.file, step.path);
+                    break;
             }
         }
         if (profile.instructions === 'snippet') {
@@ -500,27 +418,20 @@ export function planRemove(cwd, harnesses) {
 }
 /**
  * `smelt hooks <install|remove>`, start to finish. The same testability pattern as
- * `runInit`: a pure function over an input/output pair, exit code returned.
+ * `runInit`: a pure function over an input/output pair, exit code returned. The ask
+ * adapter, the step machine and the confirms are the wizard kit's (`cli/wizard.ts`) —
+ * this file holds what is hooks' own: the steps, the plan, the per-file consent.
  */
 export async function runHooks(action, harnessFlag, io) {
-    // Same adapter, same reason, as `runInit` — see the note on `answerReader`.
-    const lines = answerReader(io.input);
-    const ask = async (prompt) => {
-        io.output(prompt);
-        const next = await lines.next();
-        if (next === undefined) {
-            throw new CliUsageError(`${CLI_NAME} hooks: input ended before the wizard finished. ` +
-                `Files already confirmed and written stay; nothing further was written.`);
-        }
-        return next.trim();
-    };
+    const wizard = wizardAsk(io.input, io.output, `${CLI_NAME} hooks: input ended before the wizard finished. ` +
+        `Files already confirmed and written stay; nothing further was written.`);
     try {
         return action === 'install'
-            ? await installFlow(io, ask, harnessFlag)
-            : await removeFlow(io, ask, harnessFlag);
+            ? await installFlow(io, wizard.ask, harnessFlag)
+            : await removeFlow(io, wizard.ask, harnessFlag);
     }
     finally {
-        await lines.release();
+        await wizard.release();
     }
 }
 function resolveHarnessFlag(flag) {
@@ -542,6 +453,7 @@ async function installFlow(io, ask, harnessFlag) {
         `until you confirm at the end.\n\n`);
     const choices = {
         harnesses: harnessFlag !== undefined ? [resolveHarnessFlag(harnessFlag)] : [...detected],
+        ...(io.version === undefined ? {} : { writtenBy: io.version }),
         ...presetToggles(io.cwd),
         enforcement: 'deny',
         thresholdBytes: DEFAULT_THRESHOLD_BYTES,
@@ -558,32 +470,30 @@ async function installFlow(io, ask, harnessFlag) {
             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) => {
+            `surfaced where the turn ends. Observation only; never blocks. Wired for the ` +
+            `harnesses whose hooks carry session events (${harnessNames(lifecycleHarnesses())}).`, 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) => {
+            `Wired for the harnesses whose hooks carry session events ` +
+            `(${harnessNames(lifecycleHarnesses())}).`, choices.mapOnStart, (on) => {
             choices.mapOnStart = on;
         }),
+        async (io_, ask_) => stepToggle(io_, ask_, 'instruction-file lint on SessionStart', `\`smelt agents lint .\` runs at session start and reports on the AGENTS.md, ` +
+            `CLAUDE.md and GEMINI.md this session is about to load on every request — ` +
+            `bytes per level, and any path or link in them that no longer resolves. ` +
+            `Advisory: it never blocks, and it exits 0 unless you set ` +
+            `agents.budgetBytes in ${CONFIG_FILE_NAME}. Wired for verified-tier ` +
+            `harnesses (Claude Code, Codex).`, choices.lintOnStart, (on) => {
+            choices.lintOnStart = on;
+        }),
         async (io_, ask_) => stepEnforcement(io_, ask_, choices),
         async (io_, ask_) => stepThreshold(io_, ask_, choices),
     ];
-    let index = 0;
+    const machine = steps.map((step) => (a) => step(io, a));
     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;
-            }
-        }
+        await walkSteps(machine, ask, io.output);
         if (choices.harnesses.length === 0) {
             io.output(`No harness selected. Nothing to do; nothing was written.\n`);
             return 0;
@@ -591,7 +501,7 @@ async function installFlow(io, ask, harnessFlag) {
         const verdict = await confirmAndInstall(io, ask, choices);
         if (verdict !== 'back')
             return 0;
-        index = steps.length - 1;
+        await walkSteps(machine, ask, io.output, machine.length - 1);
     }
 }
 function guardCopy() {
@@ -695,13 +605,50 @@ async function stepThreshold(io, ask, choices) {
  * (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.
+ *
+ * The two `SessionStart` toggles share one event, so they are told apart by **the
+ * command each entry runs**, not by the key it sits under. Reading `SessionStart` as
+ * one boolean would make a re-run with the map on and the lint off write both back —
+ * or neither — which is a toggle the user believed they had set.
+ *
+ * Exported for `smelt setup`, which applies the preset's *current* state the same way
+ * — read off what is installed — rather than keeping a second copy of the defaults.
  */
-function presetToggles(cwd) {
-    const defaults = { guard: true, statsOnStop: true, mapOnStart: false };
+/**
+ * Whether a JSON hook file's text carries entries of ours — the **one** predicate for
+ * this fact, shared by the readers (`smelt doctor`, `smelt setup`'s repair policy) and
+ * backed by the same `isOursEntry` the writer's strip-merge uses. The guard command
+ * itself carries only the shim path (no token), so a text-level `OURS_TOKEN` search
+ * would miss a guard-only install — the exact drift this exists to prevent.
+ */
+export function jsonHooksContainOurs(text) {
+    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)
+        return false;
+    return MANAGED_EVENTS.some((event) => Array.isArray(hooks[event])
+        ? hooks[event].some((entry) => isOursEntry(entry))
+        : false);
+}
+export function presetToggles(cwd) {
+    const defaults = { guard: true, statsOnStop: true, mapOnStart: false, lintOnStart: false };
     let anyOurs = false;
     let guard = false;
     let statsOnStop = false;
     let mapOnStart = false;
+    let lintOnStart = false;
     for (const name of JSON_HOOK_FILES) {
         const text = readIfExists(join(cwd, name));
         if (text === undefined)
@@ -723,14 +670,19 @@ function presetToggles(cwd) {
         if (hooks === undefined)
             continue;
         const installed = hooks;
-        const hasOurs = (event) => Array.isArray(installed[event]) &&
-            installed[event].some((entry) => isOursEntry(entry));
+        const oursUnder = (event) => Array.isArray(installed[event])
+            ? installed[event].filter((entry) => isOursEntry(entry))
+            : [];
+        const hasOurs = (event) => oursUnder(event).length > 0;
+        /** One of ours under `event` whose command carries `needle`. */
+        const hasOursRunning = (event, needle) => oursUnder(event).some((entry) => (JSON.stringify(entry) ?? '').includes(needle));
         if (!MANAGED_EVENTS.some((event) => hasOurs(event)))
             continue;
         anyOurs = true;
         guard ||= GUARD_EVENTS.some((event) => hasOurs(event));
-        statsOnStop ||= hasOurs('Stop');
-        mapOnStart ||= hasOurs('SessionStart');
+        statsOnStop ||= hasOurs(LIFECYCLE_EVENTS.stats);
+        mapOnStart ||= hasOursRunning(LIFECYCLE_EVENTS.map, MAP_ON_START_ARGS);
+        lintOnStart ||= hasOursRunning(LIFECYCLE_EVENTS.lint, AGENTS_LINT_ARGS);
     }
     for (const name of GUARD_ONLY_FILES) {
         const text = readIfExists(join(cwd, name));
@@ -739,7 +691,7 @@ function presetToggles(cwd) {
             guard = true;
         }
     }
-    return anyOurs ? { guard, statsOnStop, mapOnStart } : defaults;
+    return anyOurs ? { guard, statsOnStop, mapOnStart, lintOnStart } : defaults;
 }
 const fileLabel = (file) => {
     if (file.unchanged)
@@ -748,21 +700,15 @@ const fileLabel = (file) => {
 };
 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`);
+    io.output(`\nAbout to write, into ${io.cwd}:\n`);
+    listPlannedFiles(io.output, plan.files, plan.skipped, fileLabel);
+    io.output(`Nothing has been written yet.\n`);
+    const confirmed = await confirmLoop(ask, 'yes to write, no to leave everything untouched, back to change a setting.');
+    if (confirmed === 'back')
+        return 'back';
+    if (confirmed === 'no') {
+        io.output(`Nothing was written.\n`);
+        return 'done';
     }
     for (const file of plan.files) {
         if (file.unchanged) {
@@ -778,10 +724,7 @@ async function confirmAndInstall(io, ask, choices) {
                 continue;
             }
         }
-        mkdirSync(dirname(file.path), { recursive: true });
-        writeFileSync(file.path, file.content);
-        if (file.mode !== undefined)
-            chmodSync(file.path, file.mode);
+        writePlannedFile(file);
         io.output(`  wrote ${file.name}\n`);
     }
     for (const note of plan.notes)
@@ -803,15 +746,9 @@ async function removeFlow(io, ask, harnessFlag) {
             .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`);
+    if ((await confirmYesNo(ask, 'yes to proceed, no to leave everything untouched.')) === 'no') {
+        io.output(`Nothing was changed.\n`);
+        return 0;
     }
     for (const removal of removals) {
         const verb = removal.action === 'delete' ? 'delete' : 'modify';