peaks-loop 4.1.2 → 4.1.4

package/dist/services/skills/hooks-settings-types.d.ts

@@ -0,0 +1,139 @@
+/**
+ * The public type surface of the hooks settings service.
+ *
+ * Split out of `hooks-settings-service.ts` (file-size cap campaign). The
+ * service re-exports every name declared here, so existing importers keep
+ * using `./hooks-settings-service.js` unchanged.
+ */
+import type { IdeId } from '../ide/ide-types.js';
+import type { HookScope } from '../ide/shared/safe-path.js';
+import type { PeaksHookEntry } from './hooks-codegate-superpowers.js';
+export type HookInstallOptions = {
+    /**
+     * Which IDE's adapter to install for. Defaults to `'claude-code'` for
+     * backward compatibility. The CLI command should resolve this from
+     * `detectIdeFromContext({ env, cwd, parsedStdin })` and pass the result.
+     * Throws if the IDE is not registered in the adapter registry.
+     */
+    readonly ide?: IdeId;
+    /**
+     * Slice #013 (bugfix — peaks hooks install --no-progress): when `true`,
+     * skip emitting the progress-start PreToolUse hook entry while still
+     * installing the gate-enforce entry. The progress-start hook auto-spawns
+     * a new terminal running `peaks progress watch`; with dispatch +
+     * heartbeat (slice #009 + #010) that auto-spawn is dead weight. Default
+     * `false` preserves the pre-slice install shape (both entries). The
+     * sentinel-based install is idempotent: re-running with `skipProgress:
+     * true` over a settings.json that previously had the progress entry
+     * installed will remove that entry. `uninstall` honors the same flag
+     * so it can find and remove both entries when both are present and
+     * only the gate-enforce entry when only the gate-enforce is present.
+     *
+     * Slice #014 (refactor — full removal of legacy progress-start surface):
+     * the field is preserved for API stability, but the underlying
+     * install only ever emits the gate-enforce entry. The progress-start
+     * entry is no longer installed regardless of this flag's value. The
+     * legacy `peaks progress start|watch|close` CLI surface is gone
+     * (replaced by `peaks sub-agent dispatch|heartbeat|share`); the hook
+     * entry would have been pointing at a `peaks progress start` that no
+     * longer exists. The sentinel `peaks progress start` constant is still
+     * exported (some tests + back-compat reads rely on it) but no new
+     * hook entries use it.
+     */
+    readonly skipProgress?: boolean;
+};
+/**
+ * One peaks-managed entry paired with the settings file it is (or will be)
+ * written to.
+ *
+ * `entries` is a flat list of the same matcher/sentinel pairs, which reads as
+ * "written to `settingsPath`" even when the entry is routed to the other file
+ * (see `resolveHookTargets`). This carries the routing explicitly so the
+ * dry-run can name the real target without a real run.
+ */
+export type HookEntryTarget = {
+    matcher: string;
+    sentinel: string;
+    settingsPath: string;
+};
+export type HookInstallPlan = {
+    scope: HookScope;
+    settingsPath: string;
+    exists: boolean;
+    alreadyInstalled: boolean;
+    desiredCommand: string;
+    sentinel: string;
+    matcher: string;
+    /**
+     * Machine-local, gitignored settings file that the gate-enforce entry is
+     * written to instead of `settingsPath`. Undefined when the IDE has no such
+     * file (or the scope is global, where the settings file is already
+     * machine-local). See `resolveHookTargets`.
+     */
+    localSettingsPath?: string;
+    /** Every entry the install writes, paired with its target file. */
+    entryTargets: ReadonlyArray<HookEntryTarget>;
+};
+export type HookInstallResult = HookInstallPlan & {
+    applied: boolean;
+};
+export type HookRemoveResult = {
+    scope: HookScope;
+    settingsPath: string;
+    localSettingsPath?: string;
+    removed: boolean;
+};
+export type HookStatus = {
+    scope: HookScope;
+    settingsPath: string;
+    exists: boolean;
+    localSettingsPath?: string;
+    localExists?: boolean;
+    installed: boolean;
+    /**
+     * Whether this IDE can host a peaks hook AT ALL (`hasHookSpec`).
+     *
+     * `status` answers "what is on disk", and for an IDE with no
+     * `HOOK_COMMAND_BY_IDE` entry the answer is "nothing, and nothing ever will
+     * be" — which is a successful query returning a negative fact, not a failed
+     * one. The exit code says the query succeeded; this field says what it found.
+     * Without it `installed: false` would be indistinguishable from a supported
+     * IDE that simply has no hook installed yet, which is a state the user can
+     * act on.
+     */
+    supportsHooks: boolean;
+};
+export type HookHandler = {
+    type?: string;
+    command?: string;
+};
+export type HookMatcherEntry = {
+    matcher?: string;
+    hooks?: HookHandler[];
+};
+/**
+ * A peaks-managed hook entry set grouped by the settings file that must
+ * carry it.
+ *
+ * Peaks hooks normally land in the adapter's settings file. The gate-enforce
+ * Bash entry is the exception: on Windows its `shell` must be pinned to
+ * `powershell`, because the default Git-Bash shell force-allocates a console
+ * window on every Bash tool call (MSYS2 behaviour — see the 2026-09-10
+ * hook-console finding). A machine-specific value must never be committed
+ * into the SHARED `.claude/settings.json` that a macOS/Linux teammate reads
+ * too, so that entry is materialized into the machine-local file instead.
+ * The routing decision is platform-independent (it keys off the entry's
+ * `machineLocal` flag, not off `process.platform`) so the shared file's
+ * content does not depend on which OS ran the install.
+ */
+export type HookTarget = {
+    settingsPath: string;
+    entries: PeaksHookEntry[];
+    /**
+     * When true this file also receives the third-party PreToolUse gate
+     * exemptions (`EXTERNAL_GATE_EXEMPT_ENV`). Claude Code only — `env` is a
+     * Claude Code settings key — and only ever on a machine-local file, never
+     * on the committed shared one.
+     */
+    envExemptions?: boolean;
+};

package/dist/services/skills/hooks-settings-types.js

@@ -0,0 +1 @@
+export {};

package/dist/services/workspace/claude-settings-template-merge.d.ts

@@ -0,0 +1,89 @@
+/**
+ * `claude-settings-template-merge.ts` — the comparison and the merge that decide
+ * whether an on-disk settings file still declares what the template declares, and
+ * that carry every entry the template does not declare across untouched.
+ *
+ * Split out of `claude-settings-template.ts` (475 raw lines against the 300 cap)
+ * when the two layer-B feedback hook entries had to be added to the template: that
+ * file now holds the template's own shape, and this one holds the merge machinery.
+ * The bodies moved verbatim; the three non-null assertions became the explicit
+ * `undefined` checks they already were in effect, so this module is clean at birth.
+ * `claude-settings-template.ts` re-exports every symbol below, so it stays the
+ * single public entry point for this concern.
+ */
+/**
+ * Compare two serialized template strings: does the on-disk file already
+ * declare every entry the generated tree declares?
+ *
+ * This comparator answers "is each entry the GENERATED tree declares present
+ * on disk?", NOT "are the two `hooks` trees identical". Extra on-disk entries
+ * are IGNORED, so an entry another writer put in this file never makes it look
+ * drifted.
+ *
+ * That is the deliberate other half of the entry-level merge in
+ * `mergeTemplateOwnedHooks` / `workspace-claude-settings-materializer.ts`.
+ * `.claude/settings.local.json` has a SECOND writer of `hooks.PreToolUse`:
+ * `installAutoCompactHook` appends a `Bash|Task` entry. Under the previous
+ * exact-tree rule the merged file carried 4 entries against a 3-entry
+ * generated tree, so every `peaks workspace init` answered "drifted",
+ * rewrote, and reported `refreshed` forever — precisely the state whole-key
+ * ownership existed to prevent, and the reason the merge could not ship alone.
+ *
+ * Matching is order-insensitive AND multiset-aware: the template declares TWO
+ * `Bash` entries, and each must have its own counterpart on disk, so a file
+ * carrying only one of them is still reported as drifted (the previous
+ * index-by-index loop had the same property; it is load-bearing, not a
+ * detail).
+ *
+ * Returns `true` iff both strings parse to objects whose `hooks.PreToolUse`
+ * arrays satisfy that containment, the on-disk file carries NO entry this
+ * template has retired (`isRetiredTemplateEntry`), AND the on-disk `env`
+ * already carries every exemption the template declares (extra on-disk keys
+ * and extra globs are allowed — a user may exempt other trees, and a
+ * requirement the file already exceeds must not re-trigger a write).
+ *
+ * Returns `false` on any `JSON.parse` error, shape mismatch, or
+ * missing `hooks.PreToolUse`. Whitespace and key order do NOT affect
+ * the result — the comparison is on the parsed AST, not on bytes.
+ *
+ * This is the comparator `initWorkspace` uses to decide whether to
+ * refresh a stale `.peaks/.claude-settings-template.json` on disk.
+ */
+export declare function templateContentMatches(generated: string, onDisk: string): boolean;
+/**
+ * Merge the on-disk `hooks.PreToolUse` list with the template's.
+ *
+ * the entries IT DECLARES — and nothing else. Every other on-disk entry is
+ * carried across verbatim, whatever its matcher, because the template has no
+ * opinion about it:
+ *
+ *   - a `matcher` the template does not declare (`Bash|Task`, the auto-compact
+ *     hook `installAutoCompactHook` appends) is never touched;
+ *   - surplus entries BEYOND the template's count for a declared matcher (a
+ *     user's own `Bash` hook) are surplus too, and survive;
+ *   - an on-disk entry that fills a declared slot is REPLACED by the template's
+ *     entry for it. That is what makes a hand-edited (or older-release) entry
+ *     self-heal instead of lingering next to a correct copy of itself.
+ *
+ * Slot counting is per `matcher` and positional within it: the template
+ * declares TWO `Bash` entries, so the first two on-disk `Bash` entries are
+ * theirs and a third is the user's. The template's entries are emitted first,
+ * in template order, then the preserved ones in their on-disk order — which is
+ * a fixed point: re-merging the result yields the result (the template's own
+ * entries are encountered first and refill their own slots).
+ *
+ * Non-conforming entries (no string `matcher`, no `hooks` array) are preserved
+ * rather than dropped: guessing at their shape is how a user's entry gets
+ * deleted.
+ *
+ * ONE exception to "preserve what I do not declare": an entry this template
+ * used to declare and RETIRED (TEMPLATE_VERSION 1.8.0's `Write|Edit|MultiEdit`
+ * gate — see `isRetiredTemplateEntry`) is dropped rather than preserved.
+ * Declaring less cannot retire an entry on its own, because preserving
+ * undeclared entries is exactly what this function does; without the drop, a
+ * pre-1.8.0 install would keep the no-op handler and its version-pinned script
+ * path forever. The predicate is narrow enough that only the exact command
+ * this template emitted matches.
+ */
+export declare function mergeTemplateOwnedHooks(onDisk: ReadonlyArray<unknown>, template: ReadonlyArray<unknown>): unknown[];
+export declare function isRetiredTemplateEntry(entry: unknown): boolean;

package/dist/services/workspace/claude-settings-template-merge.js

@@ -0,0 +1,243 @@
+/**
+ * `claude-settings-template-merge.ts` — the comparison and the merge that decide
+ * whether an on-disk settings file still declares what the template declares, and
+ * that carry every entry the template does not declare across untouched.
+ *
+ * Split out of `claude-settings-template.ts` (475 raw lines against the 300 cap)
+ * when the two layer-B feedback hook entries had to be added to the template: that
+ * file now holds the template's own shape, and this one holds the merge machinery.
+ * The bodies moved verbatim; the three non-null assertions became the explicit
+ * `undefined` checks they already were in effect, so this module is clean at birth.
+ * `claude-settings-template.ts` re-exports every symbol below, so it stays the
+ * single public entry point for this concern.
+ */
+import { hasExternalGateExemptions } from '../skills/hooks-codegate-superpowers.js';
+/**
+ * Compare two serialized template strings: does the on-disk file already
+ * declare every entry the generated tree declares?
+ *
+ * This comparator answers "is each entry the GENERATED tree declares present
+ * on disk?", NOT "are the two `hooks` trees identical". Extra on-disk entries
+ * are IGNORED, so an entry another writer put in this file never makes it look
+ * drifted.
+ *
+ * That is the deliberate other half of the entry-level merge in
+ * `mergeTemplateOwnedHooks` / `workspace-claude-settings-materializer.ts`.
+ * `.claude/settings.local.json` has a SECOND writer of `hooks.PreToolUse`:
+ * `installAutoCompactHook` appends a `Bash|Task` entry. Under the previous
+ * exact-tree rule the merged file carried 4 entries against a 3-entry
+ * generated tree, so every `peaks workspace init` answered "drifted",
+ * rewrote, and reported `refreshed` forever — precisely the state whole-key
+ * ownership existed to prevent, and the reason the merge could not ship alone.
+ *
+ * Matching is order-insensitive AND multiset-aware: the template declares TWO
+ * `Bash` entries, and each must have its own counterpart on disk, so a file
+ * carrying only one of them is still reported as drifted (the previous
+ * index-by-index loop had the same property; it is load-bearing, not a
+ * detail).
+ *
+ * Returns `true` iff both strings parse to objects whose `hooks.PreToolUse`
+ * arrays satisfy that containment, the on-disk file carries NO entry this
+ * template has retired (`isRetiredTemplateEntry`), AND the on-disk `env`
+ * already carries every exemption the template declares (extra on-disk keys
+ * and extra globs are allowed — a user may exempt other trees, and a
+ * requirement the file already exceeds must not re-trigger a write).
+ *
+ * Returns `false` on any `JSON.parse` error, shape mismatch, or
+ * missing `hooks.PreToolUse`. Whitespace and key order do NOT affect
+ * the result — the comparison is on the parsed AST, not on bytes.
+ *
+ * This is the comparator `initWorkspace` uses to decide whether to
+ * refresh a stale `.peaks/.claude-settings-template.json` on disk.
+ */
+export function templateContentMatches(generated, onDisk) {
+    let parsedGenerated;
+    let parsedOnDisk;
+    try {
+        parsedGenerated = JSON.parse(generated);
+    }
+    catch {
+        return false;
+    }
+    try {
+        parsedOnDisk = JSON.parse(onDisk);
+    }
+    catch {
+        return false;
+    }
+    if (!isTemplateShape(parsedGenerated) || !isTemplateShape(parsedOnDisk)) {
+        return false;
+    }
+    // Multiset containment: consume one on-disk entry per generated entry so a
+    // file holding a single copy of a doubly-declared entry still fails.
+    const unmatched = [...parsedOnDisk.hooks.PreToolUse];
+    for (const required of parsedGenerated.hooks.PreToolUse) {
+        const at = unmatched.findIndex((candidate) => sameEntry(required, candidate));
+        if (at === -1) {
+            return false;
+        }
+        unmatched.splice(at, 1);
+    }
+    // A RETIRED entry on disk is drift, and this clause is what makes the
+    // retirement in `mergeTemplateOwnedHooks` reach an installed file at all.
+    //
+    // Containment alone cannot express it: a file still carrying
+    // `Write|Edit|MultiEdit` declares every entry the template declares, so
+    // `templateContentMatches` answered "current", no rewrite ran, and the merge
+    // never got the chance to drop it. Measured on a throwaway project root
+    // before this clause existed — init against the rebuilt CLI reported
+    // `already-current` and the retired entry survived verbatim. Declaring less
+    // is not a retirement; the comparator has to say so.
+    //
+    // One extra rewrite per affected install, then the fixed point holds: the
+    // merge emits no retired entry, so the next comparison finds none and
+    // answers `current`.
+    if (parsedOnDisk.hooks.PreToolUse.some((entry) => isRetiredTemplateEntry(entry))) {
+        return false;
+    }
+    // A project installed by a release that predates a template-declared
+    // exemption still needs the refresh this comparator gates — otherwise the
+    // entry would only ever appear on a machine that re-ran `peaks hooks
+    // install`. `hasExternalGateExemptions` is the same predicate the installer
+    // uses, so the two writers cannot drift apart.
+    return hasExternalGateExemptions({ env: parsedOnDisk.env });
+}
+/**
+ * Merge the on-disk `hooks.PreToolUse` list with the template's.
+ *
+ * the entries IT DECLARES — and nothing else. Every other on-disk entry is
+ * carried across verbatim, whatever its matcher, because the template has no
+ * opinion about it:
+ *
+ *   - a `matcher` the template does not declare (`Bash|Task`, the auto-compact
+ *     hook `installAutoCompactHook` appends) is never touched;
+ *   - surplus entries BEYOND the template's count for a declared matcher (a
+ *     user's own `Bash` hook) are surplus too, and survive;
+ *   - an on-disk entry that fills a declared slot is REPLACED by the template's
+ *     entry for it. That is what makes a hand-edited (or older-release) entry
+ *     self-heal instead of lingering next to a correct copy of itself.
+ *
+ * Slot counting is per `matcher` and positional within it: the template
+ * declares TWO `Bash` entries, so the first two on-disk `Bash` entries are
+ * theirs and a third is the user's. The template's entries are emitted first,
+ * in template order, then the preserved ones in their on-disk order — which is
+ * a fixed point: re-merging the result yields the result (the template's own
+ * entries are encountered first and refill their own slots).
+ *
+ * Non-conforming entries (no string `matcher`, no `hooks` array) are preserved
+ * rather than dropped: guessing at their shape is how a user's entry gets
+ * deleted.
+ *
+ * ONE exception to "preserve what I do not declare": an entry this template
+ * used to declare and RETIRED (TEMPLATE_VERSION 1.8.0's `Write|Edit|MultiEdit`
+ * gate — see `isRetiredTemplateEntry`) is dropped rather than preserved.
+ * Declaring less cannot retire an entry on its own, because preserving
+ * undeclared entries is exactly what this function does; without the drop, a
+ * pre-1.8.0 install would keep the no-op handler and its version-pinned script
+ * path forever. The predicate is narrow enough that only the exact command
+ * this template emitted matches.
+ */
+export function mergeTemplateOwnedHooks(onDisk, template) {
+    const slots = new Map();
+    for (const entry of template) {
+        if (!isPreToolUseEntry(entry))
+            continue;
+        slots.set(entry.matcher, (slots.get(entry.matcher) ?? 0) + 1);
+    }
+    const taken = new Map();
+    const preserved = [];
+    for (const entry of onDisk) {
+        // Retired by this template — dropped, not carried across.
+        if (isRetiredTemplateEntry(entry)) {
+            continue;
+        }
+        // Unowned by construction: not a shape the template could have declared.
+        if (!isPreToolUseEntry(entry)) {
+            preserved.push(entry);
+            continue;
+        }
+        const declared = slots.get(entry.matcher) ?? 0;
+        const used = taken.get(entry.matcher) ?? 0;
+        if (used >= declared) {
+            preserved.push(entry);
+            continue;
+        }
+        taken.set(entry.matcher, used + 1);
+    }
+    return [...template, ...preserved];
+}
+/** Structural equality of two `PreToolUse` entries. */
+function sameEntry(a, b) {
+    return a.matcher === b.matcher && sameHooksArray(a.hooks, b.hooks);
+}
+function isPreToolUseEntry(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const candidate = value;
+    return typeof candidate.matcher === 'string' && Array.isArray(candidate.hooks);
+}
+function isTemplateShape(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const candidate = value;
+    if (typeof candidate.hooks !== 'object' || candidate.hooks === null) {
+        return false;
+    }
+    const hooksObj = candidate.hooks;
+    return Array.isArray(hooksObj.PreToolUse);
+}
+function sameHooksArray(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; i += 1) {
+        const ha = a[i];
+        const hb = b[i];
+        if (ha === undefined || hb === undefined) {
+            return false;
+        }
+        // `shell` participates in the comparison: it is machine-specific (see
+        // `resolveHookShell`), so a file written on one platform must be
+        // recognized as drifted on the other instead of silently kept.
+        if (ha.type !== hb.type || ha.command !== hb.command || ha.shell !== hb.shell) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * The retired `Write|Edit|MultiEdit` gate entry, as an on-disk file written by
+ * a pre-1.8.0 release holds it.
+ *
+ * TEMPLATE_VERSION 1.8.0 stopped emitting this entry. Declaring less is not
+ * enough on its own: `mergeTemplateOwnedHooks` preserves every on-disk entry
+ * the template does not declare — that is the whole point of the entry-level
+ * ownership rule (it is what keeps `installAutoCompactHook`'s `Bash|Task`
+ * entry alive) — so a project installed by an earlier release would keep the
+ * no-op handler, and its `node "C:/…/nvm/v24.14.0/…"` path, forever. This
+ * predicate is the retirement: `mergeTemplateOwnedHooks` drops a match.
+ *
+ * Deliberately narrow. It matches the exact command shape this template used
+ * to emit — one handler, `node "<…>/services/hooks/write-gate.js"` — under the
+ * exact legacy matcher spelling, so a user's OWN `Write|Edit|MultiEdit` entry
+ * (a different command, or more than one handler) is preserved like any other
+ * entry the template does not declare. A looser "drop anything on this
+ * matcher" rule would delete a user's hook, which is the failure the ownership
+ * rule exists to prevent.
+ */
+const RETIRED_WRITE_GATE_MATCHER = 'Write|Edit|MultiEdit';
+const RETIRED_WRITE_GATE_COMMAND = /^node "[^"]*\/services\/hooks\/write-gate\.js"$/;
+export function isRetiredTemplateEntry(entry) {
+    if (!isPreToolUseEntry(entry))
+        return false;
+    if (entry.matcher !== RETIRED_WRITE_GATE_MATCHER)
+        return false;
+    if (entry.hooks.length !== 1)
+        return false;
+    const [handler] = entry.hooks;
+    if (handler === undefined)
+        return false;
+    return handler.type === 'command' && RETIRED_WRITE_GATE_COMMAND.test(handler.command);
+}

package/dist/services/workspace/claude-settings-template.d.ts

@@ -23,10 +23,11 @@
  * it can be unit-tested in isolation and so the on-disk file matches
  * the in-memory template byte-for-byte.
  *
- * Two `Bash` matchers are emitted (the Step 0.8 mechanical gate and the
- * SOP gate-enforce handler). No `Write|Edit|MultiEdit` entry is emitted:
- * that matcher's gate is `peaks code-gate --json`, installed into the
- * committed `.claude/settings.json` by `peaks hooks install`.
+ * Four `Bash` matchers are emitted: the Step 0.8 mechanical gate, the SOP
+ * gate-enforce handler, and the two layer-B feedback hooks. No
+ * `Write|Edit|MultiEdit` entry is emitted: that matcher's gate is
+ * `peaks code-gate --json`, installed into the committed
+ * `.claude/settings.json` by `peaks hooks install`.
  *
  * The previous `Bash` matcher (which whitelisted a fixed `peaks
  * <subcommand>` prefix) was removed in TEMPLATE_VERSION 1.2.0. The
@@ -40,6 +41,14 @@
  * consumer project's `.claude/settings.json` and which exits 0
  * silently for any command not guarded by a registered SOP gate.
  */
+/**
+ * The comparison and the entry-level merge live in
+ * `claude-settings-template-merge.ts` — they were two thirds of this file's
+ * bytes and none of its template shape. Re-exported here so this module stays
+ * the single public entry point for the template concern: no caller has to
+ * know which half a symbol lives in.
+ */
+export { isRetiredTemplateEntry, mergeTemplateOwnedHooks, templateContentMatches } from './claude-settings-template-merge.js';
 export declare const CLAUDE_SETTINGS_LOCAL_FILENAME = ".claude/settings.local.json";
 /**
  * Informational version of the offline template shape. Bumped when the
@@ -97,84 +106,17 @@ export declare const CLAUDE_SETTINGS_LOCAL_FILENAME = ".claude/settings.local.js
  *           `mergeTemplateOwnedHooks` drops the retired entry from
  *           existing on-disk files, so an earlier install converges
  *           instead of keeping a no-op with a stale absolute path.
+ *   1.9.0 — added the two layer-B feedback hook entries
+ *           (`pre-tool-peaks-current-directory-scope.sh` and
+ *           `pre-tool-piping-a-test-run-reports-the-pipes-exit-code.sh`),
+ *           pinned to `shell: bash`. Until now their registration existed only
+ *           in the generated copies on the machine that hand-wrote them: a
+ *           fresh clone got the two scripts and no registration, so the
+ *           promotion they carry was true only locally. See
+ *           `buildFeedbackHookHandler` for why the pin is `bash` and not the
+ *           `powershell` its three siblings take.
  */
-export declare const TEMPLATE_VERSION = "1.8.0";
-/**
- * Compare two serialized template strings: does the on-disk file already
- * declare every entry the generated tree declares?
- *
- * This comparator answers "is each entry the GENERATED tree declares present
- * on disk?", NOT "are the two `hooks` trees identical". Extra on-disk entries
- * are IGNORED, so an entry another writer put in this file never makes it look
- * drifted.
- *
- * That is the deliberate other half of the entry-level merge in
- * `mergeTemplateOwnedHooks` / `workspace-claude-settings-materializer.ts`.
- * `.claude/settings.local.json` has a SECOND writer of `hooks.PreToolUse`:
- * `installAutoCompactHook` appends a `Bash|Task` entry. Under the previous
- * exact-tree rule the merged file carried 4 entries against a 3-entry
- * generated tree, so every `peaks workspace init` answered "drifted",
- * rewrote, and reported `refreshed` forever — precisely the state whole-key
- * ownership existed to prevent, and the reason the merge could not ship alone.
- *
- * Matching is order-insensitive AND multiset-aware: the template declares TWO
- * `Bash` entries, and each must have its own counterpart on disk, so a file
- * carrying only one of them is still reported as drifted (the previous
- * index-by-index loop had the same property; it is load-bearing, not a
- * detail).
- *
- * Returns `true` iff both strings parse to objects whose `hooks.PreToolUse`
- * arrays satisfy that containment, the on-disk file carries NO entry this
- * template has retired (`isRetiredTemplateEntry`), AND the on-disk `env`
- * already carries every exemption the template declares (extra on-disk keys
- * and extra globs are allowed — a user may exempt other trees, and a
- * requirement the file already exceeds must not re-trigger a write).
- *
- * Returns `false` on any `JSON.parse` error, shape mismatch, or
- * missing `hooks.PreToolUse`. Whitespace and key order do NOT affect
- * the result — the comparison is on the parsed AST, not on bytes.
- *
- * This is the comparator `initWorkspace` uses to decide whether to
- * refresh a stale `.peaks/.claude-settings-template.json` on disk.
- */
-export declare function templateContentMatches(generated: string, onDisk: string): boolean;
-/**
- * Merge the on-disk `hooks.PreToolUse` list with the template's.
- *
- * the entries IT DECLARES — and nothing else. Every other on-disk entry is
- * carried across verbatim, whatever its matcher, because the template has no
- * opinion about it:
- *
- *   - a `matcher` the template does not declare (`Bash|Task`, the auto-compact
- *     hook `installAutoCompactHook` appends) is never touched;
- *   - surplus entries BEYOND the template's count for a declared matcher (a
- *     user's own `Bash` hook) are surplus too, and survive;
- *   - an on-disk entry that fills a declared slot is REPLACED by the template's
- *     entry for it. That is what makes a hand-edited (or older-release) entry
- *     self-heal instead of lingering next to a correct copy of itself.
- *
- * Slot counting is per `matcher` and positional within it: the template
- * declares TWO `Bash` entries, so the first two on-disk `Bash` entries are
- * theirs and a third is the user's. The template's entries are emitted first,
- * in template order, then the preserved ones in their on-disk order — which is
- * a fixed point: re-merging the result yields the result (the template's own
- * entries are encountered first and refill their own slots).
- *
- * Non-conforming entries (no string `matcher`, no `hooks` array) are preserved
- * rather than dropped: guessing at their shape is how a user's entry gets
- * deleted.
- *
- * ONE exception to "preserve what I do not declare": an entry this template
- * used to declare and RETIRED (TEMPLATE_VERSION 1.8.0's `Write|Edit|MultiEdit`
- * gate — see `isRetiredTemplateEntry`) is dropped rather than preserved.
- * Declaring less cannot retire an entry on its own, because preserving
- * undeclared entries is exactly what this function does; without the drop, a
- * pre-1.8.0 install would keep the no-op handler and its version-pinned script
- * path forever. The predicate is narrow enough that only the exact command
- * this template emitted matches.
- */
-export declare function mergeTemplateOwnedHooks(onDisk: ReadonlyArray<unknown>, template: ReadonlyArray<unknown>): unknown[];
-export declare function isRetiredTemplateEntry(entry: unknown): boolean;
+export declare const TEMPLATE_VERSION = "1.9.0";
 type ClaudeHookCommand = {
     type: 'command';
     command: string;
@@ -203,11 +145,11 @@ type ClaudeSettingsLocal = {
  * forcing gate is a core feature that PreToolUse hooks can short-
  * circuit but that the `permissions` block cannot.
  *
- * As of TEMPLATE_VERSION 1.8.0 the template emits the two `Bash` matchers
- * only. The `Write|Edit|MultiEdit` fact-forcing bypass is no longer a hook:
- * it is the `env` exemption above, and that matcher's gate
- * (`peaks code-gate --json`) is installed into the committed
- * `.claude/settings.json` by `peaks hooks install`.
+ * As of TEMPLATE_VERSION 1.9.0 the template emits four `Bash` matchers: the
+ * two above, plus one per layer-B feedback hook (`FEEDBACK_HOOK_SCRIPTS`). The
+ * `Write|Edit|MultiEdit` fact-forcing bypass is no longer a hook: it is the
+ * `env` exemption above, and that matcher's gate (`peaks code-gate --json`) is
+ * installed into the committed `.claude/settings.json` by `peaks hooks
+ * install`.
  */
 export declare function buildClaudeSettingsLocalJson(): ClaudeSettingsLocal;
-export {};