peaks-loop 4.0.45 → 4.0.47

package/dist/services/compact-history/compact-history-service.js

@@ -12,6 +12,55 @@
 // read.
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
+/**
+ * Pair each dispatched compact with the measurement that followed it. Pure;
+ * tolerates a file written by an earlier release (no `windowTokens`, no
+ * `kind`) — those rows produce a pair with a null window rather than an
+ * error, because the history file is append-only and never rewritten.
+ */
+export function computeWindowCalibration(events) {
+    const pairs = [];
+    for (const event of events) {
+        const kind = event.kind ?? 'dispatch';
+        if (kind === 'observed') {
+            // Attach to the most recent dispatch still waiting for a measurement.
+            for (let i = pairs.length - 1; i >= 0; i -= 1) {
+                const candidate = pairs[i];
+                if (candidate.observedRatio !== null || typeof event.afterRatio !== 'number')
+                    continue;
+                const observedTokens = candidate.windowTokens === null ? null : event.afterRatio * candidate.windowTokens;
+                pairs[i] = {
+                    ...candidate,
+                    observedRatio: event.afterRatio,
+                    observedTokens,
+                    driftTokens: observedTokens === null || candidate.requestedTokens === null
+                        ? null
+                        : observedTokens - candidate.requestedTokens,
+                    measured: true
+                };
+                break;
+            }
+            continue;
+        }
+        const windowTokens = typeof event.windowTokens === 'number' ? event.windowTokens : null;
+        pairs.push({
+            dispatchedAt: event.ts,
+            windowTokens,
+            windowSource: event.windowSource ?? null,
+            requestedRatio: event.beforeRatio,
+            requestedTokens: windowTokens === null ? null : event.beforeRatio * windowTokens,
+            observedRatio: null,
+            observedTokens: null,
+            driftTokens: null,
+            measured: false
+        });
+    }
+    return {
+        pairs,
+        unmeasured: pairs.filter((p) => !p.measured).length,
+        lastWindowTokens: pairs.length === 0 ? null : pairs[pairs.length - 1].windowTokens
+    };
+}
 export function readCompactHistory(input) {
     const path = join(input.projectRoot, '.peaks', '_runtime', input.sessionId, 'compact-history.jsonl');
     if (!existsSync(path)) {

package/dist/services/compact-statusline/compact-lifecycle-store.d.ts

@@ -1,4 +1,12 @@
-export type CompactLifecycleStage = 'queued' | 'preparing' | 'compacting' | 'verifying' | 'completed' | 'failed';
+export type CompactLifecycleStage = 'queued' | 'preparing' | 'compacting'
+/**
+ * Slice 2026-09-12-compact-band-policy: a compact trigger was
+ * REGISTERED but no compaction has started — e.g. claude-code's
+ * `ide-native` pathway only installs the PreToolUse hook, which
+ * compacts in-band at ratio ≥ 0.95. In the 0.80–0.95 band nothing
+ * is in flight, so claiming `compacting` was a false heartbeat.
+ */
+ | 'armed' | 'verifying' | 'completed' | 'failed';
 export interface CompactLifecycleRecord {
     readonly schemaVersion: 1;
     readonly runId: string;
@@ -49,7 +57,8 @@ export declare function writeCompactLifecycle(input: {
  * Return kinds:
  *   - `missing`  — no record has ever been written for this session
  *   - `valid`    — record parsed and validated; stage is terminal
- *                  (completed/failed) OR is active but still fresh
+ *                  (completed/failed), resting (`armed`) OR is active
+ *                  but still fresh
  *   - `invalid`  — file exists but is malformed / wrong schema / out
  *                  of range. `reason` is a single-line English message
  *                  (no CLI verbs, no stack traces). The caller MUST

package/dist/services/compact-statusline/compact-lifecycle-store.js

@@ -19,11 +19,27 @@
 // compacting / verifying) is `stalled` when (nowMs - updatedAt) >
 // staleAfterMs. Terminal stages (`completed`, `failed`) NEVER go
 // stalled — the record is the historical answer, not a heartbeat.
+//
+// Slice 2026-09-12-compact-band-policy (defect B): `armed` is a third
+// category — a RESTING stage. It records a fact ("we registered a
+// compact trigger") that stays true until a measurement supersedes it;
+// no heartbeat was ever promised, so waiting in it is NORMAL and it
+// must never be reported as `stalled`. Only `compacting` means "a
+// compaction should be in flight right now", which is the only state
+// where a missing heartbeat is real evidence of a stall.
 import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { getSessionDir } from '../session/getSessionDir.js';
 const LIFECYCLE_FILENAME = 'compact-lifecycle.json';
 const ERROR_SUMMARY_MAX = 160;
+/**
+ * Stages that promise a heartbeat: each one is only written while the
+ * dispatching process (or the IDE it armed) is expected to make
+ * progress, so a stale `updatedAt` is real evidence of a stall.
+ *
+ * `armed` is deliberately NOT here — see the header. It is a resting
+ * state, not a heartbeat.
+ */
 const ACTIVE_STAGES = [
     'queued',
     'preparing',
@@ -34,6 +50,7 @@ const ALL_STAGES = [
     'queued',
     'preparing',
     'compacting',
+    'armed',
     'verifying',
     'completed',
     'failed',
@@ -169,7 +186,8 @@ export function writeCompactLifecycle(input) {
  * Return kinds:
  *   - `missing`  — no record has ever been written for this session
  *   - `valid`    — record parsed and validated; stage is terminal
- *                  (completed/failed) OR is active but still fresh
+ *                  (completed/failed), resting (`armed`) OR is active
+ *                  but still fresh
  *   - `invalid`  — file exists but is malformed / wrong schema / out
  *                  of range. `reason` is a single-line English message
  *                  (no CLI verbs, no stack traces). The caller MUST

package/dist/services/compact-statusline/compact-statusline-service.d.ts

@@ -1,5 +1,5 @@
 import { type CompactLifecycleStage } from './compact-lifecycle-store.js';
-export type CompactDisplayKind = 'none' | 'queued' | 'preparing' | 'compacting' | 'verifying' | 'completed' | 'failed' | 'stalled' | 'invalid';
+export type CompactDisplayKind = 'none' | 'queued' | 'preparing' | 'compacting' | 'verifying' | 'completed' | 'failed' | 'stalled' | 'invalid' | 'armed';
 export interface CompactStatuslineState {
     readonly kind: CompactDisplayKind;
     readonly filledCells: 0 | 2 | 4 | 6 | 8;

package/dist/services/compact-statusline/compact-statusline-service.js

@@ -28,6 +28,9 @@
 //   none       → 0 cells
 //   invalid    → 0 cells (no false reassurance)
 //   stalled    → keep the active stage's cell
+//   armed      → NO bar at all (slice 2026-09-12-compact-band-policy):
+//                a registered-but-idle trigger has no progress to
+//                report, and a bar would imply one.
 //
 // Render contract: the rendered label is a fixed-width 8-cell bar
 // (`[████░░░░]` filled from the left). NO `?` characters. NO guessed
@@ -36,6 +39,7 @@
 // measurement" hint.
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { getSessionDir } from '../session/getSessionDir.js';
+import { AUTO_COMPACT_RED_LINE_RATIO } from '../context/auto-compact-types.js';
 import { readCompactLifecycle, } from './compact-lifecycle-store.js';
 /**
  * Concrete first-version stale timeout. Adjustable after real timing
@@ -70,6 +74,8 @@ const CELL_BY_STAGE = new Map([
     ['verifying', STAGE_CELL_VERIFYING],
     ['completed', STAGE_CELL_COMPLETED],
     ['failed', STAGE_CELL_COMPACTING],
+    // `armed` is not in the cell table: it renders WITHOUT a bar (see
+    // renderCompactStatusline). Lookups therefore miss and fall back to 0.
 ]);
 const FILLED = '█';
 const EMPTY = '░';
@@ -245,6 +251,12 @@ export function renderCompactStatusline(state) {
             return `compact ${renderBar(2)}`;
         case 'compacting':
             return `compact ${renderBar(STAGE_CELL_COMPACTING)}`;
+        // Slice 2026-09-12-compact-band-policy: a registered trigger that has
+        // not fired is NOT progress. Rendering a bar would imply movement
+        // that is not happening, so `armed` deliberately renders no bar at
+        // all — the label states what is true and what would change it.
+        case 'armed':
+            return `compact armed${formatArmedRatio(state)} — fires in-band at ${arRedLinePct()}`;
         case 'verifying':
             return `compact ${renderBar(STAGE_CELL_VERIFYING)}`;
         case 'completed':
@@ -257,6 +269,16 @@ export function renderCompactStatusline(state) {
             return formatInvalid(state);
     }
 }
+/** The red-line ratio the armed trigger waits for, as a display percentage. */
+function arRedLinePct() {
+    return `${Math.round(AUTO_COMPACT_RED_LINE_RATIO * 100)}%`;
+}
+/** ` (88% now)` when the opening trigger ratio is known; empty otherwise. */
+function formatArmedRatio(state) {
+    return typeof state.triggerRatio === 'number'
+        ? ` (${Math.round(state.triggerRatio * 100)}% now)`
+        : '';
+}
 function formatCompleted(state) {
     const bar = renderBar(STAGE_CELL_COMPLETED);
     if (typeof state.afterRatio === 'number') {

package/dist/services/config/config-safety.d.ts

@@ -51,6 +51,58 @@ export declare class InvalidProjectRootError extends Error {
     constructor(reason: 'empty' | 'nul-byte' | 'non-existent' | 'non-canonical', input: string);
 }
 export declare function resolveCanonicalProjectRootStrict(startPath: string): string;
+/**
+ * True when `projectRoot` IS the user's home directory itself.
+ *
+ * Exact match, NOT `isInsidePath`: `~/my-project` is an ordinary project and
+ * must keep working — the guard exists for the one directory that is never a
+ * project.
+ *
+ * `projectRootsMatch` rather than `===` because the two strings reach this
+ * function from different sources: a `--project .` argument arrives in the
+ * caller's spelling while `homedir()` yields the OS form (`C:\Users\x` vs
+ * `C:/Users/x`, and differing case on win32/darwin).
+ *
+ * This is the ONE definition of "the user's home" in the codebase; the
+ * harness-window writer's own guard delegates here so the two cannot drift.
+ */
+export declare function isUserHomeProjectRoot(projectRoot: string): boolean;
+/**
+ * Thrown by `assertWritableProjectRoot` / `resolveWritableProjectRoot` when a
+ * write would land in the user's home directory. Distinct from
+ * `InvalidProjectRootError` (which is about a malformed/absent path): this path
+ * is perfectly valid — it is just not a project.
+ */
+export declare class UnsafeProjectRootError extends Error {
+    readonly projectRoot: string;
+    constructor(projectRoot: string);
+}
+/**
+ * Refuse a project root that IS the user's home directory.
+ *
+ * The hazard this closes: a fresh terminal starts in `$HOME`, and
+ * `peaks workspace init --project .` there resolved to `$HOME` (via
+ * `resolveCanonicalProjectRoot`'s fail-open fallback, which returns the start
+ * path when it can find no project marker) and then materialized a whole
+ * project tree INTO the user's home — `.claude/settings.local.json` above all,
+ * which is a live config file shared with every other project on the machine.
+ *
+ * Deliberately NOT enforced inside `resolveCanonicalProjectRoot`. That helper
+ * is called from 85 sites across 32 files, most of them READS (`peaks status`,
+ * `peaks dashboard`, `peaks memory`, the observability commands). Refusing
+ * there would break every one of them the moment a user runs a read command
+ * from their home directory, and its fail-open contract is documented and
+ * depended on. The hazard is a WRITE to `$HOME/.claude/`, so the guard belongs
+ * on write paths — this function, plus `resolveWritableProjectRoot` so a
+ * writer only has to make one call.
+ */
+export declare function assertWritableProjectRoot(projectRoot: string): void;
+/**
+ * `resolveCanonicalProjectRoot` for a path that is about to be WRITTEN to:
+ * same git-root-then-heuristic promotion, plus the home-directory refusal.
+ * Read paths keep using the fail-open helper.
+ */
+export declare function resolveWritableProjectRoot(startPath: string): string;
 export declare function getProjectConfigPath(projectRoot: string | null): string | null;
 export declare function getProjectBootstrapConfigPath(projectRoot: string): string;
 export declare function validateProjectBootstrapConfigPathForWrite(projectRoot: string, configPath: string): void;

package/dist/services/config/config-safety.js

@@ -3,6 +3,7 @@ import { execFileSync } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { dirname, isAbsolute, relative, resolve } from 'node:path';
 import { homedir } from 'node:os';
+import { projectRootsMatch } from '../../shared/path-utils.js';
 export function getUserConfigPath() {
     return resolve(homedir(), '.peaks', 'config.json');
 }
@@ -202,7 +203,8 @@ function resolveProjectRootFromGit(startPath) {
         const stdout = execFileSync('git', ['rev-parse', '--show-toplevel'], {
             cwd: startPath,
             encoding: 'utf8',
-            stdio: ['ignore', 'pipe', 'ignore']
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true
         });
         const trimmed = stdout.trim();
         if (trimmed.length === 0)
@@ -227,6 +229,78 @@ function resolveProjectRootFromGit(startPath) {
         return rawRoot;
     }
 }
+/**
+ * True when `projectRoot` IS the user's home directory itself.
+ *
+ * Exact match, NOT `isInsidePath`: `~/my-project` is an ordinary project and
+ * must keep working — the guard exists for the one directory that is never a
+ * project.
+ *
+ * `projectRootsMatch` rather than `===` because the two strings reach this
+ * function from different sources: a `--project .` argument arrives in the
+ * caller's spelling while `homedir()` yields the OS form (`C:\Users\x` vs
+ * `C:/Users/x`, and differing case on win32/darwin).
+ *
+ * This is the ONE definition of "the user's home" in the codebase; the
+ * harness-window writer's own guard delegates here so the two cannot drift.
+ */
+export function isUserHomeProjectRoot(projectRoot) {
+    try {
+        return projectRootsMatch(projectRoot, homedir());
+    }
+    catch {
+        // A path that cannot be resolved is not a claim about the home directory.
+        return false;
+    }
+}
+/**
+ * Thrown by `assertWritableProjectRoot` / `resolveWritableProjectRoot` when a
+ * write would land in the user's home directory. Distinct from
+ * `InvalidProjectRootError` (which is about a malformed/absent path): this path
+ * is perfectly valid — it is just not a project.
+ */
+export class UnsafeProjectRootError extends Error {
+    projectRoot;
+    constructor(projectRoot) {
+        super(`Refusing to write into the user's home directory: "${projectRoot}" is not a project root.`);
+        this.projectRoot = projectRoot;
+        this.name = 'UnsafeProjectRootError';
+    }
+}
+/**
+ * Refuse a project root that IS the user's home directory.
+ *
+ * The hazard this closes: a fresh terminal starts in `$HOME`, and
+ * `peaks workspace init --project .` there resolved to `$HOME` (via
+ * `resolveCanonicalProjectRoot`'s fail-open fallback, which returns the start
+ * path when it can find no project marker) and then materialized a whole
+ * project tree INTO the user's home — `.claude/settings.local.json` above all,
+ * which is a live config file shared with every other project on the machine.
+ *
+ * Deliberately NOT enforced inside `resolveCanonicalProjectRoot`. That helper
+ * is called from 85 sites across 32 files, most of them READS (`peaks status`,
+ * `peaks dashboard`, `peaks memory`, the observability commands). Refusing
+ * there would break every one of them the moment a user runs a read command
+ * from their home directory, and its fail-open contract is documented and
+ * depended on. The hazard is a WRITE to `$HOME/.claude/`, so the guard belongs
+ * on write paths — this function, plus `resolveWritableProjectRoot` so a
+ * writer only has to make one call.
+ */
+export function assertWritableProjectRoot(projectRoot) {
+    if (isUserHomeProjectRoot(projectRoot)) {
+        throw new UnsafeProjectRootError(projectRoot);
+    }
+}
+/**
+ * `resolveCanonicalProjectRoot` for a path that is about to be WRITTEN to:
+ * same git-root-then-heuristic promotion, plus the home-directory refusal.
+ * Read paths keep using the fail-open helper.
+ */
+export function resolveWritableProjectRoot(startPath) {
+    const root = resolveCanonicalProjectRoot(startPath);
+    assertWritableProjectRoot(root);
+    return root;
+}
 export function getProjectConfigPath(projectRoot) {
     if (!projectRoot)
         return null;

package/dist/services/context/auto-compact-dispatcher.d.ts

@@ -1,37 +1,3 @@
-/**
- * AC-3 — IDE-aware compact dispatcher.
- *
- * Reads the active IDE's `IdeAdapter.compact` profile and dispatches
- * compact via the adapter-declared pathway. No hard-coded IDE names
- * — Claude Code is the MVP that fills `compact`; other adapters
- * register their own `compact` profile as L2-dogfood verifies
- * each IDE's actual compact surface.
- *
- * Pathway dispatch:
- *
- *   - `ide-native`     — peaks-loop writes the compact intent to
- *                        the IDE's hook file (per
- *                        `IdeSettingsLocation`). Used when the IDE
- *                        requires a registered hook rather than a
- *                        runtime command.
- *   - `llm-self-compress` — peaks-loop records the intent and
- *                        returns `ok: true` with `pathway` echoed.
- *                        The LLM does its own context summarization
- *                        on the next turn. Always available; least
- *                        precise fallback.
- *   - `noop`           — adapter explicitly opted out. peaks-loop
- *                        returns `ok: false` with `message: 'noop'`.
- *                        Used by legacy / unverified adapters.
- *
- * rid-031 (2026-07-28): `shell-exec` pathway is DEPRECATED. The
- * `case 'shell-exec':` branch remains reachable only to keep the
- * 2 currently-passing tests in `tests/unit/context/auto-compact-main-target.test.ts:58`
- * + `tests/unit/services/context/auto-compact-dispatcher-ide-native.test.ts:102`
- * passing (they assert `pathway: 'shell-exec'`). Real callers must
- * use `ide-native` (main session) or `llm-self-compress`. No host
- * CLI spawn occurs; the case logs a deprecation warning and returns
- * the same envelope shape.
- */
 import type { CompactDispatchResult } from './auto-compact-types.js';
 export type CompactTarget = 'main' | 'sub-agent';
 export interface DispatchIdeCompactInput {
@@ -48,14 +14,18 @@ export interface DispatchIdeCompactInput {
      * shells that spawn their own `peaks code auto-compact` flow pass
      * `'sub-agent'` to preserve the legacy shell-spawn behaviour.
      *
-     * Behaviour matrix (claude-code MVP):
+     * Behaviour matrix, keyed on the ADAPTER'S DECLARED pathway only
+     * — never on the adapter's name (slice
+     * 2026-09-12-auto-compact-vendor-neutrality):
      *   - target='main'     → llm-self-compress (write intent; main LLM
-     *                          fires `/compact` on its next turn).
+     *                          fires its compact command on its next turn).
      *   - target='sub-agent'→ shell-exec stub (DEPRECATED — no host
      *                          CLI spawn; returns envelope with
      *                          `pathway: 'shell-exec'` for legacy
      *                          contract only — see rid-031).
-     * Non-claude-code IDEs + target='main' return noop + warning.
+     * An adapter with no registered `compact` profile returns noop for
+     * BOTH targets; an adapter whose profile serves the main session is
+     * dispatched regardless of which IDE it is.
      */
     readonly target?: CompactTarget | undefined;
 }

package/dist/services/context/auto-compact-dispatcher.js

@@ -1,3 +1,48 @@
+/**
+ * AC-3 — IDE-aware compact dispatcher.
+ *
+ * Reads the active IDE's `IdeAdapter.compact` profile and dispatches
+ * compact via the adapter-declared pathway. No hard-coded IDE names
+ * — Claude Code is the MVP that fills `compact`; other adapters
+ * register their own `compact` profile as L2-dogfood verifies
+ * each IDE's actual compact surface.
+ *
+ * Pathway dispatch:
+ *
+ *   - `ide-native`     — peaks-loop writes the compact intent to
+ *                        the IDE's hook file (per
+ *                        `IdeSettingsLocation`). Used when the IDE
+ *                        requires a registered hook rather than a
+ *                        runtime command.
+ *   - `llm-self-compress` — peaks-loop records the intent and
+ *                        returns `ok: true` with `pathway` echoed.
+ *                        The LLM does its own context summarization
+ *                        on the next turn. Always available; least
+ *                        precise fallback.
+ *   - `noop`           — adapter explicitly opted out. peaks-loop
+ *                        returns `ok: false` with `message: 'noop'`.
+ *                        Used by legacy / unverified adapters.
+ *
+ * rid-031 (2026-07-28): `shell-exec` pathway is DEPRECATED. Real
+ * callers must use `ide-native` (main session) or
+ * `llm-self-compress`. No host CLI spawn occurs; the `case
+ * 'shell-exec':` branch logs a deprecation warning and returns the
+ * same envelope shape.
+ *
+ * Slice 2026-09-12-auto-compact-vendor-neutrality (defect #2 of the QA
+ * pass): the paragraph above used to justify keeping that branch with
+ * "the 2 currently-passing tests" it named by path and line (`:58` of
+ * one file, `:102` of another, asserting `pathway: 'shell-exec'`).
+ * That justification ROTTED and is false as of today: both files were
+ * deleted by `f17aa377 test(rebuild): delete 559 legacy unit tests and
+ * reset vitest config`, and `grep -rn "shell-exec" tests/` now returns
+ * nothing — no test in this repo asserts `pathway: 'shell-exec'`. The
+ * branch is retained for the rid-031 ENVELOPE CONTRACT itself
+ * (`pathway` is part of `CompactDispatchResult` and is echoed to
+ * `peaks code auto-compact` callers), not for a test. Deleting it is a
+ * contract change, deliberately out of this slice.
+ */
+import { join } from 'node:path';
 import { detectIdeFromEnv } from './ide-detect.js';
 import { getAdapter } from '../ide/ide-registry.js';
 /**
@@ -21,21 +66,28 @@ export async function dispatchIdeCompact(input) {
     // the main-session context. The orchestrator passes `'sub-agent'`
     // explicitly when a sub-agent shell dispatches the call.
     const target = input.target ?? 'main';
-    // Slice 2026-06-28: when targeting the MAIN session, refuse
-    // up-front for adapters we cannot dispatch a main-session compact
-    // against. We DO this before the `!adapter.compact` short-circuit
-    // so the test message reflects the operational cause (target vs
-    // adapter capability). Even non-claude-code adapters without a
-    // registered `compact` profile should report "main-session target
-    // unsupported" rather than the generic "no compact profile" line.
-    if (target === 'main' && ideId !== 'claude-code') {
-        return {
-            ok: false,
-            ide: ideId,
-            pathway: 'noop',
-            message: `main-session target unsupported on adapter '${ideId}'; only claude-code supports in-band main-session compact.`
-        };
-    }
+    // Slice 2026-09-12-auto-compact-vendor-neutrality — the up-front
+    // `target === 'main' && ideId !== 'claude-code'` refusal is GONE.
+    //
+    // It decided by adapter NAME what the adapter's own profile already
+    // declares, contradicting this file's contract ("No hard-coded IDE
+    // names", :5-8): any adapter that filled in `compact` was still
+    // rejected for not being called `claude-code`.
+    //
+    // It was also redundant. Every pathway below owns its own
+    // main-session semantics — `ide-native` installs the hook against the
+    // caller's own window; `shell-exec` is explicitly degraded to
+    // `llm-self-compress` for a main target; `llm-self-compress` and
+    // `noop` behave identically for both targets (so `noop` still returns
+    // `ok: false` on main); an UNKNOWN pathway falls through to the
+    // default noop. An adapter with no `compact` profile keeps its own
+    // explicit refusal immediately below. No remaining capability test
+    // would have been anything but a duplicate of one of those branches,
+    // so the check was deleted rather than re-keyed. The two candidate
+    // re-keyings were both rejected: `pathway !== 'ide-native'` would
+    // refuse `shell-exec` and `llm-self-compress` adapters that the
+    // switch already serves, and `pathway === 'noop'` IS the branch
+    // immediately below.
     // Adapters that don't declare `compact` (legacy / unverified) →
     // explicit noop so the caller can distinguish "IDE doesn't support
     // compact" from "IDE supports but dispatch failed".
@@ -53,12 +105,13 @@ export async function dispatchIdeCompact(input) {
     switch (pathway) {
         case 'shell-exec':
             // rid-031 (2026-07-28): `shell-exec` pathway is DEPRECATED.
-            // No host CLI spawn occurs. The case marker is preserved so
-            // 2 currently-passing tests in
-            //   tests/unit/context/auto-compact-main-target.test.ts:58
-            //   tests/unit/services/context/auto-compact-dispatcher-ide-native.test.ts:102
-            // continue to assert `pathway: 'shell-exec'`. Real callers must
-            // use `ide-native` (main session) or `llm-self-compress`.
+            // No host CLI spawn occurs. The case marker is preserved for the
+            // rid-031 envelope contract (callers read `pathway`), NOT for a
+            // test — see this file's header, defect #2 of the 2026-09-12 QA
+            // pass: the tests the previous comment named were deleted by
+            // f17aa377 and no test asserts `pathway: 'shell-exec'` now.
+            // Real callers must use `ide-native` (main session) or
+            // `llm-self-compress`.
             console.warn(`compact: shell-exec pathway is deprecated on adapter '${ideId}' (target='${target}'); no host CLI spawn — use ide-native instead.`);
             if (target === 'main') {
                 return {
@@ -76,12 +129,14 @@ export async function dispatchIdeCompact(input) {
             };
         case 'ide-native':
             // Slice 2026-07-02-auto-compact-zero-pause: write the auto-compact
-            // PreToolUse hook into `.claude/settings.local.json`. The hook
-            // command (`peaks code auto-compact`) reads
-            // `CLAUDE_CONTEXT_USAGE_PERCENT` on every subsequent Bash/Task
-            // tool call from the runner and, at ratio ≥ 0.95, in-band spawns
-            // `claude --compact` against the CURRENT runner (not a child
-            // process — the bug documented in
+            // PreToolUse hook into the IDE's MACHINE-LOCAL settings layer,
+            // resolved from the adapter (`settings.dirName` +
+            // `settings.localSettingsFileName`) — never from a path literal
+            // here. The hook command (`peaks code auto-compact`) reads the
+            // adapter-declared `envVarForContextPercent` on every subsequent
+            // Bash/Task tool call from the runner and, at ratio ≥ 0.95,
+            // in-band spawns the adapter-declared `compactCommand` against the
+            // CURRENT runner (not a child process — the bug documented in
             // `.peaks/memory/2026-06-27-auto-compact-design.md:139-152`).
             //
             // `ide-native` is ONLY for the main-session runner. When the
@@ -93,10 +148,11 @@ export async function dispatchIdeCompact(input) {
             if (target === 'sub-agent') {
                 // rid-031 (2026-07-28): legacy shell-spawn fallback is
                 // DEPRECATED. No host CLI spawn occurs. The envelope is
-                // returned with `pathway: 'shell-exec'` to preserve the
-                // contract asserted by
-                //   tests/unit/services/context/auto-compact-dispatcher-ide-native.test.ts:102
-                // (sub-agent shells historically relied on this path).
+                // returned with `pathway: 'shell-exec'` to preserve the rid-031
+                // contract for callers that read `pathway` (sub-agent shells
+                // historically relied on this path). The test the previous
+                // comment named was deleted by f17aa377 — see this file's
+                // header, defect #2 of the 2026-09-12 QA pass.
                 console.warn(`compact: sub-agent shell-exec fallback is deprecated on adapter '${ideId}'; no host CLI spawn for '${profile.compactCommand}'.`);
                 return {
                     ok: true,
@@ -111,7 +167,9 @@ export async function dispatchIdeCompact(input) {
             return await dispatchIdeNativeHook({
                 projectRoot: input.projectRoot,
                 sessionId: input.sessionId,
-                target
+                target,
+                adapter,
+                profile
             });
         case 'llm-self-compress':
             return {
@@ -141,11 +199,18 @@ export async function dispatchIdeCompact(input) {
 /**
  * Slice 2026-07-02-auto-compact-zero-pause: implement the
  * `ide-native` pathway. Writes the auto-compact PreToolUse hook
- * into `.claude/settings.local.json` (idempotent; the install
- * service is a no-op if the hook is already present). On the next
- * Bash/Task tool call from the runner, the hook fires
- * `peaks code auto-compact` which in-band spawns
- * `claude --compact` against the CURRENT runner session.
+ * into the IDE's MACHINE-LOCAL settings file (idempotent; the
+ * install service is a no-op if the hook is already present). On
+ * the next Bash/Task tool call from the runner, the hook fires
+ * `peaks code auto-compact` which in-band spawns the adapter's
+ * declared compact command against the CURRENT runner session.
+ *
+ * Slice 2026-09-12-auto-compact-vendor-neutrality: the settings path
+ * AND the echoed `ide` are read off the adapter, so this function no
+ * longer names a vendor. An adapter that declares
+ * `compactPathway: 'ide-native'` and its own `settings` location gets
+ * its own hook file — the `.claude/settings.local.json` value survives
+ * only as the installer's default for callers with no adapter in hand.
  *
  * Returns `ok: true, pathway: 'ide-native'` regardless of install
  * action (`installed` vs `already-installed`) — both states
@@ -158,13 +223,21 @@ async function dispatchIdeNativeHook(input) {
     // avoids a static cycle if future slices add cross-imports
     // between dispatcher and hook-install.
     const { installAutoCompactHook } = await import('../hooks/auto-compact-hook-install.js');
-    const result = installAutoCompactHook({ projectRoot: input.projectRoot });
+    // Resolve the local settings file from the adapter's declared
+    // location. `undefined` means "this IDE declares no machine-local
+    // layer" → the installer's documented default applies.
+    const localFileName = input.adapter.settings.localSettingsFileName;
+    const settingsPath = localFileName === undefined
+        ? undefined
+        : join(input.projectRoot, input.adapter.settings.dirName, localFileName);
+    const result = installAutoCompactHook({ projectRoot: input.projectRoot, settingsPath });
+    const envVar = input.profile.envVarForContextPercent;
     return {
         ok: true,
-        ide: 'claude-code',
+        ide: input.adapter.id,
         pathway: 'ide-native',
         message: result.action === 'installed'
-            ? `Auto-compact PreToolUse hook installed at ${result.settingsPath}. Next Bash/Task tool call will read CLAUDE_CONTEXT_USAGE_PERCENT and compact in-band at ratio ≥ 95%.`
+            ? `Auto-compact PreToolUse hook installed at ${result.settingsPath}. Next Bash/Task tool call will read ${envVar} and compact in-band at ratio ≥ 95%.`
             : result.action === 'updated'
                 ? `Auto-compact PreToolUse hook REPAIRED at ${result.settingsPath} — the installed entry carried a stale command and was rewritten.`
                 : `Auto-compact PreToolUse hook already installed at ${result.settingsPath}; next Bash/Task tool call will trigger compact in-band at ratio ≥ 95%.`