peaks-loop 4.0.46 → 4.0.48

package/dist/services/runtime/vendors/claude-code.js

@@ -23,7 +23,7 @@ export class ClaudeCodeAdapter {
         if (args.force === true)
             argv.push('--force');
         return new Promise((resolveRun) => {
-            const proc = spawn('claude', argv, { stdio: ['ignore', 'pipe', 'pipe'] });
+            const proc = spawn('claude', argv, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
             let stdout = '';
             let stderr = '';
             proc.stdout.on('data', (chunk) => { stdout += chunk.toString('utf8'); });

package/dist/services/runtime/vendors/codex.js

@@ -27,7 +27,7 @@ export class CodexAdapter {
         if (args.force === true)
             argv.push('--force');
         return new Promise((resolveRun) => {
-            const proc = spawn('codex', argv, { stdio: ['ignore', 'pipe', 'pipe'] });
+            const proc = spawn('codex', argv, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
             let stdout = '';
             let stderr = '';
             proc.stdout.on('data', (chunk) => { stdout += chunk.toString('utf8'); });

package/dist/services/runtime/vendors/copilot.js

@@ -24,7 +24,7 @@ export class CopilotAdapter {
         if (args.force === true)
             argv.push('--force');
         return new Promise((resolveRun) => {
-            const proc = spawn('copilot', argv, { stdio: ['ignore', 'pipe', 'pipe'] });
+            const proc = spawn('copilot', argv, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
             let stdout = '';
             let stderr = '';
             proc.stdout.on('data', (chunk) => { stdout += chunk.toString('utf8'); });

package/dist/services/sc/sc-service.js

@@ -60,7 +60,7 @@ function getCurrentCommitHash(workspaceRoot) {
     if (!workspaceRoot)
         return null;
     try {
-        return execFileSync('git', ['rev-parse', 'HEAD'], { cwd: workspaceRoot, encoding: 'utf-8' }).trim();
+        return execFileSync('git', ['rev-parse', 'HEAD'], { cwd: workspaceRoot, encoding: 'utf-8', windowsHide: true }).trim();
     }
     catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
         return null;

package/dist/services/scan/diff-scope-service.js

@@ -119,9 +119,9 @@ function parseRedLineScope(rdBody) {
 }
 function tryGitChangedFiles(projectRoot, baseRef) {
     try {
-        const trackedRaw = execFileSync('git', ['-C', projectRoot, 'diff', '--name-only', baseRef], { encoding: 'utf8' });
+        const trackedRaw = execFileSync('git', ['-C', projectRoot, 'diff', '--name-only', baseRef], { encoding: 'utf8', windowsHide: true });
         const tracked = trackedRaw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-        const untrackedRaw = execFileSync('git', ['-C', projectRoot, 'ls-files', '--others', '--exclude-standard'], { encoding: 'utf8' });
+        const untrackedRaw = execFileSync('git', ['-C', projectRoot, 'ls-files', '--others', '--exclude-standard'], { encoding: 'utf8', windowsHide: true });
         const untracked = untrackedRaw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
         return { ok: true, files: Array.from(new Set([...tracked, ...untracked])) };
     }

package/dist/services/scan/file-size-scan.js

@@ -65,9 +65,9 @@ function getChangedFiles(projectRoot, baseRef) {
         // (--diff-filter=D) are intentionally excluded: they have no on-disk
         // body to count, and a refactor that deletes large files is exactly
         // when the gate should NOT block. Slice #015 fix.
-        const trackedRaw = execFileSync('git', ['-C', projectRoot, 'diff', '--name-only', '--diff-filter=AM', baseRef], { encoding: 'utf8' });
+        const trackedRaw = execFileSync('git', ['-C', projectRoot, 'diff', '--name-only', '--diff-filter=AM', baseRef], { encoding: 'utf8', windowsHide: true });
         const tracked = trackedRaw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-        const untrackedRaw = execFileSync('git', ['-C', projectRoot, 'ls-files', '--others', '--exclude-standard'], { encoding: 'utf8' });
+        const untrackedRaw = execFileSync('git', ['-C', projectRoot, 'ls-files', '--others', '--exclude-standard'], { encoding: 'utf8', windowsHide: true });
         const untracked = untrackedRaw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
         return Array.from(new Set([...tracked, ...untracked]));
     }

package/dist/services/scan/karpathy-service.js

@@ -68,7 +68,7 @@ export async function scanKarpathy(options) {
                 warnings: [
                     `Karpathy review file missing: ${reviewRel}`,
                     'Per karpathy §1 Think Before Coding: state your assumptions. Without a review file, no 5-way fanout evidence is available.',
-                    'Per karpathy §3 Surgical Changes: touch only what the request requires. Create a minimal rd/karpathy-review.md stub before requesting qa-handoff.'
+                    'Per karpathy §3 Surgical Changes: touch only what the request requires. The rd:qa-handoff gate is satisfied by rd/karpathy-review-<rid>.md; this scanner has no rid and reads only the back-compat name rd/karpathy-review.md, so a rid-scoped-only slice still reads as missing here. `peaks request transition --state qa-handoff` is the authoritative gate.'
                 ]
             };
         }
@@ -223,6 +223,6 @@ export function formatKarpathyMarkdown(report, opts = {}) {
     }
     lines.push('### Karpathy-Gate');
     lines.push('');
-    lines.push('Per `andrej-karpathy-skills:karpathy-guidelines` §1 Think Before Coding / §3 Surgical Changes, the hard Karpathy-Gate requires `rd/karpathy-review.md` to be present with all 4 guideline sections before `peaks request transition --state qa-handoff`.');
+    lines.push('Per `andrej-karpathy-skills:karpathy-guidelines` §1 Think Before Coding / §3 Surgical Changes, the hard Karpathy-Gate requires `rd/karpathy-review-<rid>.md` to be present with all 4 guideline sections before `peaks request transition --state qa-handoff`. (`rd/karpathy-review.md` is the accepted back-compat tier, and the only name this scanner probes.)');
     return lines.join('\n');
 }

package/dist/services/scan/orphan-service.js

@@ -233,7 +233,8 @@ function diffVsHead(projectRoot, baseRef) {
     const res = spawnSync('git', args, {
         cwd: projectRoot,
         encoding: 'utf8',
-        timeout: 5000
+        timeout: 5000,
+        windowsHide: true
     });
     if (res.status !== 0 || !res.stdout) {
         return { added: [], removed: [], modified: [] };

package/dist/services/scan/type-sanity-service.js

@@ -39,9 +39,9 @@ function isArtifactWorkspaceFile(filePath) {
 function tryGitDiffFiles(projectRoot, baseRef) {
     try {
         // Combine: tracked changes vs baseRef + untracked files. Use porcelain status for untracked too.
-        const trackedRaw = execFileSync('git', ['-C', projectRoot, 'diff', '--name-only', baseRef], { encoding: 'utf8' });
+        const trackedRaw = execFileSync('git', ['-C', projectRoot, 'diff', '--name-only', baseRef], { encoding: 'utf8', windowsHide: true });
         const tracked = trackedRaw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-        const untrackedRaw = execFileSync('git', ['-C', projectRoot, 'ls-files', '--others', '--exclude-standard'], { encoding: 'utf8' });
+        const untrackedRaw = execFileSync('git', ['-C', projectRoot, 'ls-files', '--others', '--exclude-standard'], { encoding: 'utf8', windowsHide: true });
         const untracked = untrackedRaw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
         const merged = Array.from(new Set([...tracked, ...untracked])).filter((file) => !isArtifactWorkspaceFile(file));
         return { ok: true, files: merged };

package/dist/services/session/session-checkpoint-service.js

@@ -12,6 +12,7 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { join, sep } from 'node:path';
 import { emitObservabilityEvent } from '../observability/observability-service.js';
+import { isUnsafePathInput } from '../../shared/path-safety.js';
 const CHECKPOINTS_DIR = 'checkpoints';
 const CHECKPOINT_FILENAME_EXT = '.json';
 const MAX_CHECKPOINTS = 10;
@@ -76,6 +77,13 @@ function pruneOldest(dir) {
     return removed;
 }
 export function writeCheckpoint(projectRoot, options) {
+    // Sid axis, placed before the first read and the first `mkdir`. Both
+    // `peaks session checkpoint --session-id` and `peaks compact force
+    // --session-id` reach this same function, so one guard closes both measured
+    // surfaces — they were never two joins.
+    if (isUnsafePathInput(options.sessionId)) {
+        throw new Error(`Invalid session id: ${options.sessionId} (must be a single path segment)`);
+    }
     const now = (options.now ?? (() => new Date()))();
     const createdAt = now.toISOString();
     const lastActivity = readSessionLastActivity(projectRoot, options.sessionId) || createdAt;

package/dist/services/skill/resume-detector.js

@@ -32,6 +32,7 @@
  */
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { readArtifactState } from '../artifacts/request-artifact-state-helpers.js';
 const MID_IMPL_RD_STATES = new Set([
     'spec-locked',
     'implemented',
@@ -192,13 +193,21 @@ function classifyTerminalGates(sessionDir, ctx) {
     // RD qa-handoff → deepest gate is C. If the review artifacts are
     // missing the state is inconsistent; fall back to rd-review-fanout.
     if (ctx.primaryRd !== null && ctx.primaryRd.state === 'qa-handoff') {
-        const codeReviewPath = join(sessionDir, 'rd', 'code-review.md');
-        const securityReviewPath = join(sessionDir, 'rd', 'security-review.md');
+        // Slice `2026-09-14-audit-artifact-rid-scoping`: the fan-out evidence
+        // filenames carry the rid. Probe the canonical rid-scoped name first and
+        // the pre-rid names behind it — the same order the transition gate
+        // resolves in, so an inconsistent-looking slice here means the fan-out
+        // never ran, not that it wrote to a name this reader does not know.
+        const rid = ridOf(ctx.primaryRd.filename);
         const missing = [];
-        if (!existsSync(codeReviewPath))
-            missing.push('rd/code-review.md');
-        if (!existsSync(securityReviewPath))
-            missing.push('rd/security-review.md');
+        const codeReviewCandidates = [`rd/code-review-${rid}.md`, 'rd/code-review.md'];
+        const securityCandidates = [`audit/security-${rid}.md`, 'audit/security.md', 'rd/security-review.md'];
+        if (!codeReviewCandidates.some((rel) => existsSync(join(sessionDir, rel)))) {
+            missing.push(codeReviewCandidates[0]);
+        }
+        if (!securityCandidates.some((rel) => existsSync(join(sessionDir, rel)))) {
+            missing.push(securityCandidates[0]);
+        }
         if (missing.length > 0) {
             return {
                 kind: 'resume',
@@ -317,12 +326,21 @@ function readRequestStates(sessionDir, role) {
         };
     });
 }
+/** Empty string (not 'unknown') when the artifact has no state line — `primaryPrd.state.length > 0` below depends on that. */
 function extractState(content) {
-    const match = /^-\s*state:\s*(\S+)|^state:\s*(\S+)/m.exec(content);
-    if (match === null)
-        return '';
-    const captured = match[1] ?? match[2] ?? '';
-    return captured.trim();
+    return readArtifactState(content) ?? '';
+}
+/**
+ * The `<rid>` embedded in a request filename: drop the `.md` suffix and the
+ * zero-padded `NNN-` prefix `request init` writes.
+ *
+ * Uses the same `^0\d{2}-` rule as the request loader
+ * (`request-artifact-service.ts`: "Only strip 3-digit zero-padded prefixes").
+ * A looser `^\d+-` would eat the leading year of every real rid, which is
+ * itself date-shaped (`2026-09-14-<slug>`).
+ */
+function ridOf(filename) {
+    return filename.replace(/^0\d{2}-/, '').replace(/\.md$/, '');
 }
 function hasAbandonedTransitionNote(content) {
     return /user-requested-abandon/.test(content);

package/dist/services/skillhub/tar-runtime.js

@@ -62,6 +62,7 @@ export function runTar(args) {
     try {
         execFileSync(cmd, args, {
             stdio: ["ignore", "ignore", "pipe"],
+            windowsHide: true,
             // Surface stderr text rather than dumping a Buffer at the caller.
             // execFileSync with stdio: ["ignore","ignore","pipe"] captures the
             // stderr stream into the Error's `.stderr` Buffer when the child

package/dist/services/skills/hooks-codegate-superpowers.d.ts

@@ -39,8 +39,22 @@ interface ResolvedHookSpec {
  * cannot help; pinning the hook's `shell` is the only lever the hook schema
  * offers. The platform-neutral default (`undefined` → omit the key) is kept
  * everywhere else.
+ *
+ * Scope note: this is applied to the `Bash`-matcher handlers only. The three
+ * `SessionStart` entries are deliberately NOT pinned, and not because the
+ * mechanism is believed absent there — see the block comment in
+ * `resolveHookEntries` for what is and is not established, and for why adding
+ * the pin in place would break every non-Windows teammate.
  */
 export declare function resolveHookShell(platform?: NodeJS.Platform): string | undefined;
+/**
+ * True when the IDE is tabled in `HOOK_COMMAND_BY_IDE`, i.e. peaks can write a
+ * hook entry for it. `qoder` / `tongyi-lingma` / `zcode` are reserved adapter
+ * ids the registry knows but this table does not, so no hook can exist for
+ * them — which makes "uninstall" a no-op (nothing was ever installed) while
+ * "install" remains a hard failure.
+ */
+export declare function hasHookSpec(ide: IdeId): boolean;
 export declare function resolveHookSpec(ide: IdeId): ResolvedHookSpec;
 /** A typed descriptor for a single peaks-managed hook entry. */
 export type PeaksHookEntry = {

package/dist/services/skills/hooks-codegate-superpowers.js

@@ -8,7 +8,7 @@
  * type contract re-exported by the caller.
  */
 import { getAdapter } from '../ide/ide-registry.js';
-import { HOOK_OUTER_CACHE_COMMAND, HOOK_OUTER_CACHE_EVENT, HOOK_OUTER_CACHE_SENTINEL, HOOK_WORKSPACE_INIT_COMMAND, HOOK_WORKSPACE_INIT_EVENT, HOOK_WORKSPACE_INIT_SENTINEL } from './session-start-hook-constants.js';
+import { HOOK_COMPACT_SETTLE_COMMAND, HOOK_COMPACT_SETTLE_EVENT, HOOK_COMPACT_SETTLE_MATCHER, HOOK_COMPACT_SETTLE_SENTINEL, HOOK_OUTER_CACHE_COMMAND, HOOK_OUTER_CACHE_EVENT, HOOK_OUTER_CACHE_SENTINEL, HOOK_POST_COMPACT_REINJECT_COMMAND, HOOK_POST_COMPACT_REINJECT_EVENT, HOOK_POST_COMPACT_REINJECT_MATCHER, HOOK_POST_COMPACT_REINJECT_SENTINEL, HOOK_WORKSPACE_INIT_COMMAND, HOOK_WORKSPACE_INIT_EVENT, HOOK_WORKSPACE_INIT_SENTINEL } from './session-start-hook-constants.js';
 /** Sentinel substring identifying a Claude-Code gate-enforce hook entry. */
 export const HOOK_ENFORCE_SENTINEL = 'peaks gate enforce';
 /**
@@ -20,6 +20,12 @@ export const HOOK_ENFORCE_SENTINEL = 'peaks gate enforce';
  * cannot help; pinning the hook's `shell` is the only lever the hook schema
  * offers. The platform-neutral default (`undefined` → omit the key) is kept
  * everywhere else.
+ *
+ * Scope note: this is applied to the `Bash`-matcher handlers only. The three
+ * `SessionStart` entries are deliberately NOT pinned, and not because the
+ * mechanism is believed absent there — see the block comment in
+ * `resolveHookEntries` for what is and is not established, and for why adding
+ * the pin in place would break every non-Windows teammate.
  */
 export function resolveHookShell(platform = process.platform) {
     return platform === 'win32' ? 'powershell' : undefined;
@@ -45,6 +51,16 @@ const HOOK_COMMAND_BY_IDE = {
     // registered. When a slice adds them, add a HOOK_COMMAND_BY_IDE entry
     // here — the function below fail-closes on missing entries.
 };
+/**
+ * True when the IDE is tabled in `HOOK_COMMAND_BY_IDE`, i.e. peaks can write a
+ * hook entry for it. `qoder` / `tongyi-lingma` / `zcode` are reserved adapter
+ * ids the registry knows but this table does not, so no hook can exist for
+ * them — which makes "uninstall" a no-op (nothing was ever installed) while
+ * "install" remains a hard failure.
+ */
+export function hasHookSpec(ide) {
+    return HOOK_COMMAND_BY_IDE[ide] !== undefined;
+}
 export function resolveHookSpec(ide) {
     // getAdapter throws on unregistered IDEs — the registry is the source of truth.
     const adapter = getAdapter(ide);
@@ -53,7 +69,12 @@ export function resolveHookSpec(ide) {
         // Defensive fallback: if an adapter is added to the registry without a
         // HOOK_COMMAND_BY_IDE entry, fail-closed with a clear error instead of
         // silently writing a Claude-shaped entry to a non-Claude settings.json.
-        throw new Error(`peaks hooks install: unsupported IDE '${ide}' (no HOOK_COMMAND_BY_IDE entry; add one to hooks-settings-service.ts)`);
+        //
+        // Caller-neutral on purpose: this one resolver backs install, status,
+        // uninstall and the dry-run plan, so the message names neither a verb
+        // (naming the install verb made an uninstall failure read as an install
+        // failure) nor a file that is not the table.
+        throw new Error(`unsupported IDE '${ide}': no HOOK_COMMAND_BY_IDE entry (add one in hooks-codegate-superpowers.ts)`);
     }
     const isClaudeCode = ide === 'claude-code';
     // Claude Code's gate hook must emit its structured decision as JSON:
@@ -97,6 +118,37 @@ export function resolveHookEntries(ide, _skipProgress = false) {
             ...(spec.hookEnforceShell !== undefined ? { shell: spec.hookEnforceShell } : {})
         }
     ];
+    // ── Why the three SessionStart entries below carry NO `shell` pin ─────────
+    //
+    // The gate-enforce entry above is shell-pinned on Windows (see
+    // `resolveHookShell`) because Claude Code runs a shell-form hook command
+    // through a shell that defaults to bash — Git Bash / MSYS2 on Windows — and
+    // MSYS2 bash force-allocates its own console window. That reason is a
+    // property of the hook RUNNER's shell resolution, not of the `PreToolUse`
+    // event: nothing in it exempts `SessionStart`, so the same command-form
+    // entry on this event goes through the same shell. The pin was applied only
+    // to the `Bash`-matcher handlers because those were the ones the reporter
+    // could see (they run on EVERY Bash tool call); these three run once per
+    // session, so a window here — if there is one — is a single flash rather
+    // than a per-tool-call nuisance. That is a difference in frequency, not
+    // evidence that the window does not appear, and no A/B measurement on this
+    // event exists.
+    //
+    // The pin is nonetheless NOT applied here, and adding it would be a defect
+    // rather than a fix: `shell: "powershell"` resolves to `pwsh`, these entries
+    // are written to the COMMITTED `.claude/settings.json`, and a macOS / Linux
+    // teammate reading that file has no `pwsh` — the exact cross-platform damage
+    // the machine-local split exists to prevent (see the gate-enforce entry's
+    // `machineLocal` flag, and commit 4637baa8's rationale).
+    //
+    // A correct fix therefore has to move these three entries to the
+    // machine-local file as well, which changes where a fresh clone gets its
+    // SessionStart hooks: today they arrive with the repository, after such a
+    // change they would require `peaks hooks install` / `peaks workspace init`.
+    // That is a product-shape decision, not a leftover; it is recorded here so
+    // that whoever makes it starts from the reason the pin is absent instead of
+    // re-deriving it — or, worse, adding the pin in place and breaking every
+    // non-Windows teammate.
     if (ide === 'claude-code') {
         entries.push({
             sentinel: HOOK_OUTER_CACHE_SENTINEL,
@@ -129,6 +181,41 @@ export function resolveHookEntries(ide, _skipProgress = false) {
             command: HOOK_CODE_GATE_COMMAND,
             event: HOOK_CODE_GATE_EVENT
         });
+        // rid 2026-09-13-a2-post-compact-reinject: the post-compaction
+        // engineering-state re-injection. A THIRD SessionStart entry, on a
+        // DIFFERENT matcher (`compact`) than the outer-cache and primer entries
+        // (matcher `''`, i.e. every source). The matcher is what scopes it: the
+        // card belongs in the context after a compaction emptied it, not on a
+        // fresh `startup` where the dispatch context is still present.
+        //
+        // It rides this table rather than a bespoke installer so install,
+        // status, uninstall, the dry-run plan and the workspace-init drift
+        // comparator all see it as one more peaks-managed entry — the same
+        // contract the other two SessionStart entries have.
+        entries.push({
+            sentinel: HOOK_POST_COMPACT_REINJECT_SENTINEL,
+            matcher: HOOK_POST_COMPACT_REINJECT_MATCHER,
+            command: HOOK_POST_COMPACT_REINJECT_COMMAND,
+            event: HOOK_POST_COMPACT_REINJECT_EVENT
+        });
+        // rid 2026-09-13-compact-event-settle: the harness's OWN "a compaction
+        // completed" event, which is the only signal that settles a compact as a
+        // FACT rather than as an inference from a ratio that fell.
+        //
+        // No `machineLocal` flag, so this lands in the shared, committed
+        // `.claude/settings.json` — the same file as the three SessionStart entries
+        // above, and NOT the machine-local file the workspace-init materializer
+        // owns. That routing IS the answer to "who owns the `hooks` key for this
+        // entry": the only writer that could delete it is the one that installed
+        // it. See `session-start-hook-constants.ts` for why it also carries no
+        // `shell` pin, and `mergeHooksTree` for the second line of defence if it
+        // ever moves.
+        entries.push({
+            sentinel: HOOK_COMPACT_SETTLE_SENTINEL,
+            matcher: HOOK_COMPACT_SETTLE_MATCHER,
+            command: HOOK_COMPACT_SETTLE_COMMAND,
+            event: HOOK_COMPACT_SETTLE_EVENT
+        });
     }
     return entries;
 }
@@ -154,7 +241,16 @@ export function resolveLegacySentinels(ide) {
         // the gate-enforce entry, and so hand-added entries matching this
         // sentinel are recognized as peaks-managed (not stripped as
         // non-Peaks).
-        return [...base, HOOK_OUTER_CACHE_SENTINEL, HOOK_WORKSPACE_INIT_SENTINEL];
+        // rid 2026-09-13-a2-post-compact-reinject: the post-compact re-injection
+        // sentinel joins the same set, so uninstall strips it (and status counts
+        // it) exactly like the other two SessionStart entries. Without this the
+        // entry would be unremovable by `peaks hooks uninstall` — the rollback
+        // path T2 requires.
+        // rid 2026-09-13-compact-event-settle: the PostCompact settle sentinel joins
+        // too — same rollback argument as the reinject entry above. A hook that
+        // `peaks hooks uninstall` cannot remove is a hook the user cannot get rid
+        // of, and this one fires on every compaction.
+        return [...base, HOOK_OUTER_CACHE_SENTINEL, HOOK_WORKSPACE_INIT_SENTINEL, HOOK_POST_COMPACT_REINJECT_SENTINEL, HOOK_COMPACT_SETTLE_SENTINEL];
     }
     return base;
 }

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

@@ -116,6 +116,18 @@ export type HookStatus = {
     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;
 };
 /**
  * Slice #014: read the *actually-installed* peaks-managed hook entries

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

@@ -4,7 +4,7 @@ import { join, resolve } from 'node:path';
 import { assertSafeSettingsFile } from '../ide/shared/safe-path.js';
 import { atomicWriteJson, readJsonObjectFile } from '../ide/shared/atomic-json.js';
 import { getAdapter } from '../ide/ide-registry.js';
-import { resolveHookSpec, resolveHookEntries, resolveLegacySentinels, SUPERPOWERS_DENIED_SKILLS, formatSuperpowersDenyEntry, SUPERPOWERS_DENY_SENTINELS, hasExternalGateExemptions, withExternalGateExemptions, withoutExternalGateExemptions } from './hooks-codegate-superpowers.js';
+import { resolveHookSpec, resolveHookEntries, hasHookSpec, resolveLegacySentinels, SUPERPOWERS_DENIED_SKILLS, formatSuperpowersDenyEntry, SUPERPOWERS_DENY_SENTINELS, hasExternalGateExemptions, withExternalGateExemptions, withoutExternalGateExemptions } from './hooks-codegate-superpowers.js';
 export { HOOK_ENFORCE_SENTINEL, HOOK_CODE_GATE_SENTINEL, HOOK_CODE_GATE_MATCHER, HOOK_CODE_GATE_EVENT, HOOK_CODE_GATE_COMMAND, SUPERPOWERS_DENIED_SKILLS } from './hooks-codegate-superpowers.js';
 // --- Module-level defaults (claude-code) -----------------------------------
 // These exports remain for backward compat — tests and downstream callers
@@ -44,25 +44,49 @@ function assertSafeSettingsPathCompat(scope, ide, root, settingsPath) {
         throw new Error(`settings path drift: ${expected} vs ${settingsPath}`);
     }
 }
-/** Machine-local sibling of the adapter's settings file (Claude Code convention). */
-const LOCAL_SETTINGS_FILE_NAME = 'settings.local.json';
-/** IDEs whose hook settings have a machine-local, gitignored sibling file. */
-const IDES_WITH_LOCAL_SETTINGS = new Set(['claude-code']);
 /**
  * Resolve the machine-local settings file an IDE may carry (e.g. Claude
  * Code's `.claude/settings.local.json`), or `undefined` when there is none.
  *
+ * B3(b) 2026-09-13: the machine-local layer is an adapter-DECLARED capability,
+ * not a name list. It used to be two hardcoded facts here — a `Set(['claude-code'])`
+ * membership test and the filename literal `'settings.local.json'` — i.e. a
+ * module that routes per-IDE was itself naming one IDE and one IDE's file.
+ * Both now read off the adapter that owns them
+ * (`IdeSettingsLocation.localSettingsFileName`), exactly as
+ * `auto-compact-dispatcher.ts` already did for the same field.
+ *
+ * Behaviour is UNCHANGED, and that was verified rather than assumed: over all
+ * nine registered `IdeId`s, `IDES_WITH_LOCAL_SETTINGS.has(id)` was `true` for
+ * exactly the ids whose adapter declares `localSettingsFileName` (claude-code
+ * alone, `'settings.local.json'`). So the set was an exact duplicate of a
+ * declaration the adapters already carried, not an independent policy — and
+ * a new adapter that declares the field now gets this path for free instead
+ * of being silently denied it.
+ *
+ * This ALSO removes a live instance of the vendor guard's limit 1 (indirect
+ * identity: `SET.has(ide)`), which no AST check over comparisons or literals
+ * can see. The guard's header named this exact line as the example.
+ *
  * Global scope resolves to `undefined`: the global settings file
  * (`~/.claude/settings.json`) is already machine-local, so nothing needs
  * relocating there.
  */
 function resolveLocalSettingsPath(scope, ide, projectRoot) {
-    if (scope === 'global' || !IDES_WITH_LOCAL_SETTINGS.has(ide))
+    if (scope === 'global')
         return undefined;
-    const root = resolveSettingsRoot(scope, projectRoot);
     const adapter = getAdapter(ide);
-    assertSafeSettingsFile(scope, root, adapter.settings.dirName, LOCAL_SETTINGS_FILE_NAME);
-    return join(root, adapter.settings.dirName, LOCAL_SETTINGS_FILE_NAME);
+    const localFileName = adapter.settings.localSettingsFileName;
+    // `undefined` = this IDE has no machine-local layer. Note the order: a
+    // caller reaching here with an id the registry does not know still throws
+    // from `getAdapter` above, exactly as it did before — every path into this
+    // function already called `getAdapter(ide)` via `resolveSettingsPath`, so
+    // no new throw path is introduced.
+    if (localFileName === undefined)
+        return undefined;
+    const root = resolveSettingsRoot(scope, projectRoot);
+    assertSafeSettingsFile(scope, root, adapter.settings.dirName, localFileName);
+    return join(root, adapter.settings.dirName, localFileName);
 }
 function resolveHookTargets(scope, ide, projectRoot) {
     const sharedPath = resolveSettingsPath(scope, ide, projectRoot);
@@ -298,10 +322,20 @@ function shapeMatchesDesired(settings, entries, allPeaksSentinels) {
                 return false;
             }
         }
-        // (b) every desired entry must be on disk.
-        for (const sentinel of desiredSentinels) {
-            const has = peaksPresent.some((entry) => (entry.hooks ?? []).some((h) => String(h.command ?? '').includes(sentinel)));
-            if (!has)
+        // (b) every desired entry must be on disk AND carry the matcher it declares.
+        //     Presence alone cannot see a WRONG matcher, and a wrong matcher is not
+        //     cosmetic: `''` and `Bash|Task` route the same command to different
+        //     tool sets, so the entry is present while the hook never fires on the
+        //     tools it was installed for. Measured (rid `2026-09-13-compact-event-settle`,
+        //     residual R2): a `PostCompact` entry hand-corrupted to matcher
+        //     `auto|manual` survived `peaks hooks install` unchanged, and the
+        //     installer was structurally unable to repair it.
+        //     An absent matcher reads as `''` — the form Claude Code takes as "every
+        //     source" — so a file written before matchers were explicit converges
+        //     once instead of churning on every install.
+        for (const desired of entries.filter((e) => e.event === eventKey)) {
+            const onDisk = peaksPresent.find((entry) => (entry.hooks ?? []).some((h) => String(h.command ?? '').includes(desired.sentinel)));
+            if (onDisk === undefined || (onDisk.matcher ?? '') !== desired.matcher)
                 return false;
         }
     }
@@ -453,6 +487,24 @@ export function removeHookInstall(scope, projectRoot, options) {
     const root = resolveSettingsRoot(scope, projectRoot);
     const settingsPath = resolveSettingsPath(scope, ide, projectRoot);
     assertSafeSettingsPathCompat(scope, ide, root, settingsPath);
+    // An IDE with no HOOK_COMMAND_BY_IDE entry can never carry a peaks hook, so
+    // "remove it" is already true. That is a no-op success, not a failure: the
+    // post-condition the caller asked for holds. This stays asymmetric with
+    // `applyHookInstall`, which still fails closed for the same IDEs — reporting
+    // a successful install there would claim an enforcement that cannot exist.
+    //
+    // `resolveHookTargets` below is what throws for these IDEs, so the check has
+    // to come first. Note `resolveSettingsPath` above still runs: an IDE the
+    // adapter registry does not know at all remains a hard error.
+    if (!hasHookSpec(ide)) {
+        const localSettingsPath = resolveLocalSettingsPath(scope, ide, projectRoot);
+        return {
+            scope,
+            settingsPath,
+            removed: false,
+            ...(localSettingsPath !== undefined && localSettingsPath !== settingsPath ? { localSettingsPath } : {})
+        };
+    }
     const targets = resolveHookTargets(scope, ide, projectRoot);
     const localTarget = targets.find((t) => t.settingsPath !== settingsPath);
     const present = targets.filter((t) => existsSync(t.settingsPath));
@@ -528,6 +580,30 @@ export function readHookStatus(scope, projectRoot, options) {
     const root = resolveSettingsRoot(scope, projectRoot);
     const settingsPath = resolveSettingsPath(scope, ide, projectRoot);
     assertSafeSettingsPathCompat(scope, ide, root, settingsPath);
+    // An IDE with no HOOK_COMMAND_BY_IDE entry has no hook on disk and can never
+    // have one, so "what is installed?" has a definite answer: nothing. That is a
+    // no-op success, exactly like `removeHookInstall` — the query ran, the disk
+    // was read, and the honest reply is `supportsHooks: false, installed: false`.
+    // This stays asymmetric with `applyHookInstall`, which still fails closed for
+    // the same IDEs: reporting a successful INSTALL would claim an enforcement
+    // that cannot exist, whereas reporting a successful STATUS claims nothing.
+    //
+    // `resolveHookTargets` below is what throws for these IDEs, so the check has
+    // to come first. `resolveSettingsPath` above still runs: an IDE the adapter
+    // registry does not know at all remains a hard error.
+    if (!hasHookSpec(ide)) {
+        const localSettingsPath = resolveLocalSettingsPath(scope, ide, projectRoot);
+        return {
+            scope,
+            settingsPath,
+            exists: existsSync(settingsPath),
+            ...(localSettingsPath !== undefined && localSettingsPath !== settingsPath
+                ? { localSettingsPath, localExists: existsSync(localSettingsPath) }
+                : {}),
+            installed: false,
+            supportsHooks: false
+        };
+    }
     const targets = resolveHookTargets(scope, ide, projectRoot);
     const exists = existsSync(settingsPath);
     const localTarget = targets.find((t) => t.settingsPath !== settingsPath);
@@ -541,7 +617,8 @@ export function readHookStatus(scope, projectRoot, options) {
         installed: targets.some((t) => {
             const settings = readSettingsFile(t.settingsPath);
             return Object.keys(settings).length > 0 && isInstalledForEntries(settings, t.entries);
-        })
+        }),
+        supportsHooks: true
     };
 }
 /**