peaks-loop 4.0.0-beta → 4.0.0-beta.10

package/dist/src/services/audit/red-line-catalog.js

@@ -1,195 +0,0 @@
-/**
- * Red-line catalog — the 5 P0 red lines shipped in L2.1, plus the marker
- * patterns that the classifier uses to discover them in markdown.
- *
- * The catalog is hand-maintained. New enforcers (L2.2/2.3/2.4) add entries
- * here and the backing-detector picks them up automatically.
- */
-import { RED_LINE_CATALOG_P2_A } from './red-line-catalog-p2-a.js';
-import { RED_LINE_CATALOG_P2_B } from './red-line-catalog-p2-b.js';
-export const RED_LINE_CATALOG = [
-    {
-        id: 'rl-solo-code-ban-001',
-        rule: 'Solo Code-Change Red Line',
-        markers: ['BLOCKING', 'MANDATORY'],
-        phrases: [
-            'peaks-code',
-            'orchestrator, NOT an implementer',
-            'solo',
-        ],
-        enforcerRef: 'src/services/audit/enforcers/solo-code-ban.ts',
-    },
-    {
-        id: 'rl-no-root-pollution-001',
-        rule: 'No Root Pollution',
-        markers: ['MANDATORY', 'MUST NOT', 'RED LINE'],
-        phrases: [
-            'root pollution',
-            'must not write to the project root',
-            'no root',
-        ],
-        enforcerRef: 'src/services/audit/enforcers/no-root-pollution.ts',
-    },
-    {
-        id: 'rl-sub-agent-sid-001',
-        rule: 'Sub-Agent SID Isolation',
-        markers: ['MANDATORY', 'BLOCKING'],
-        phrases: [
-            'sub-agent',
-            'session id',
-            'sub-agent session sharing',
-            'one conversation = one sid',
-        ],
-        enforcerRef: 'src/services/audit/enforcers/sub-agent-sid.ts',
-    },
-    {
-        id: 'rl-mock-placement-001',
-        rule: 'Mock Data Placement',
-        markers: ['MUST NOT', 'MANDATORY'],
-        phrases: [
-            'mock data',
-            'mock placement',
-            'inline mock',
-            'fixture placement',
-        ],
-        enforcerRef: 'src/services/audit/enforcers/mock-placement.ts',
-    },
-    // === Slice L2.2 P1 — 10 P1 red lines across 5 categories ===
-    // Each catalog entry has a phrase that distinguishes it from P0; the
-    // backing-detector + DEFERRED_ENFORCERS mechanism handles the rest.
-    {
-        id: 'rl-resume-detection-001',
-        rule: 'Resume Detection: Session Binding',
-        markers: ['MANDATORY', 'BLOCKING'],
-        phrases: ['resume detection', 'session binding', 'resume session', 'resume from'],
-        enforcerRef: 'src/services/audit/enforcers/resume-detection.ts',
-    },
-    {
-        id: 'rl-resume-detection-002',
-        rule: 'Resume Detection: Request State',
-        markers: ['MANDATORY', 'BLOCKING'],
-        phrases: ['request state', 'resumable state', 'spec-locked', 'implemented', 'qa-handoff'],
-        enforcerRef: 'src/services/audit/enforcers/resume-detection.ts',
-    },
-    {
-        id: 'rl-prototype-fidelity-001',
-        rule: 'Prototype Fidelity: No Stub Markers',
-        markers: ['MUST NOT', 'MANDATORY'],
-        phrases: ['prototype fidelity', 'no stub', 'no TODO', 'no FIXME', 'no placeholder'],
-        enforcerRef: 'src/services/audit/enforcers/prototype-fidelity.ts',
-    },
-    {
-        id: 'rl-prototype-fidelity-002',
-        rule: 'Prototype Fidelity: Test Coverage',
-        markers: ['MANDATORY', 'RED LINE'],
-        phrases: ['prototype test', 'must have tests', 'test coverage', 'fidelity test'],
-        enforcerRef: 'src/services/audit/enforcers/prototype-fidelity.ts',
-    },
-    {
-        id: 'rl-design-draft-confirm-001',
-        rule: 'Design-Draft Confirm: Existence',
-        markers: ['MANDATORY', 'BLOCKING'],
-        phrases: ['design-draft', 'design draft', 'design-draft.md', 'design draft exists'],
-        enforcerRef: 'src/services/audit/enforcers/design-draft-confirm.ts',
-    },
-    {
-        id: 'rl-design-draft-confirm-002',
-        rule: 'Design-Draft Confirm: Confirmed State',
-        markers: ['MANDATORY', 'BLOCKING'],
-        phrases: ['design confirmed', 'design-draft confirmed', 'confirmed-by-user', 'user confirmed'],
-        enforcerRef: 'src/services/audit/enforcers/design-draft-confirm.ts',
-    },
-    {
-        id: 'rl-pre-rd-scan-001',
-        rule: 'Pre-RD Scan: Archetype Detected',
-        markers: ['MANDATORY', 'BLOCKING'],
-        phrases: ['pre-rd scan', 'project-scan', 'archetype detected', 'scan archetype'],
-        enforcerRef: 'src/services/audit/enforcers/pre-rd-scan.ts',
-    },
-    {
-        id: 'rl-pre-rd-scan-002',
-        rule: 'Pre-RD Scan: Standards Preflight',
-        markers: ['MANDATORY', 'BLOCKING'],
-        phrases: ['standards preflight', 'pre-rd standards', 'standards init', 'standards update'],
-        enforcerRef: 'src/services/audit/enforcers/pre-rd-scan.ts',
-    },
-    {
-        id: 'rl-login-gate-001',
-        rule: 'Login Gate: Destructive Path Confirmation',
-        markers: ['MANDATORY', 'BLOCKING', 'RED LINE'],
-        phrases: ['login gate', 'destructive path', 'uninstall', 'force-push', 'user confirmation required'],
-        enforcerRef: 'src/services/audit/enforcers/login-gate.ts',
-    },
-    {
-        id: 'rl-login-gate-002',
-        rule: 'Login Gate: Protected Path Auth',
-        markers: ['MANDATORY', 'BLOCKING'],
-        phrases: ['protected path', 'auth required', 'auth header', 'login required', 'session check'],
-        enforcerRef: 'src/services/audit/enforcers/login-gate.ts',
-    },
-    // Slice #6 L2.3 P2-a: 24 lint-style red-lines (Theme A: section
-    // structure, B: frontmatter shape, C: output style, D: CLI-back
-    // gaps, E: reference integrity, F: workflow-bound shape, G: catalog
-    // governance). Spread from the P2-a module so future P2-a edits
-    // are localized.
-    ...RED_LINE_CATALOG_P2_A,
-    // Slice #7 L2.4 P2-b: 25 lint-style red-lines for references/*.md
-    // (Themes H-P) + 4 audit-regression enforcers (Theme L). Spread
-    // from the P2-b module so future P2-b edits are localized.
-    ...RED_LINE_CATALOG_P2_B,
-];
-/**
- * Catalog entries for enforcers whose source code is shipped in this slice
- * but whose integration is deferred to subsequent slices (L2.1.1 or later).
- *
- * The backing-detector downgrades these to `prose-only` at runtime because
- * the integration seam is missing. When the integration lands, the entry
- * is removed from this set in a single-line follow-up commit.
- *
- * L2.1 final state: Tasks 5 (solo-code-ban) + 6 (no-root-pollution) are
- * wired into peaks hook handle (Tasks 1-4: framework + 3 enforcers also
- * integrated). Tasks 3 (tech-doc-presence) and 4 (mock-placement) are
- * deferred — their request-transition / slice-check integrations are
- * tracked separately.
- */
-// v2.14.0 Slice C Group G3: prose-only catalog governance reform.
-// All 8 previously-deferred enforcers are now integrated into the
-// red-lines audit pipeline (see red-lines-service.ts §3-7). The
-// backing-detector re-classifies these entries as cli-backed because
-// their enforcerRef file exists on disk. Rationale per id lives in
-// `.peaks/standards/catalog-governance/v2-14-classifications.md`.
-//
-// The 80 discovered-prose-only entries (`rl-discovered-...` ids) remain
-// in the catalog with `informational: true` and stay outside the
-// prose-only ratio (see prose-ratio-calculator.ts).
-export const DEFERRED_ENFORCERS = new Set([]);
-/**
- * A red line's catalog id is the join key. If a discovered red line in a
- * markdown file matches no catalog entry, it stays as `prose-only`.
- *
- * Match policy: phrase-only for identity. Markers (MANDATORY / BLOCKING /
- * MUST NOT / RED LINE) are too generic to disambiguate — every catalog
- * entry shares the same marker set, so a marker-only match would always
- * return the first catalog entry regardless of the rule.
- *
- * Deferred enforcers (Tasks 4-6 integration pending) are matched by
- * phrase but tagged with enforcerRef=null so the backing-detector
- * downgrades them to prose-only at runtime. They are NOT removed from
- * the catalog so future integration commits can re-tag them with a
- * single source-of-truth change.
- */
-export function findCatalogEntry(rule, _markers) {
-    const lower = rule.toLowerCase();
-    for (const entry of RED_LINE_CATALOG) {
-        const phraseHit = entry.phrases.some((p) => lower.includes(p.toLowerCase()));
-        if (phraseHit) {
-            if (DEFERRED_ENFORCERS.has(entry.id)) {
-                // Return a copy with enforcerRef nulled out, so backing-detector
-                // treats it as prose-only until the integration lands.
-                return { ...entry, enforcerRef: null };
-            }
-            return entry;
-        }
-    }
-    return null;
-}

package/dist/src/services/audit/types.d.ts

@@ -1,86 +0,0 @@
-/**
- * Red-line audit framework — types.
- *
- * Spec: docs/superpowers/specs/2026-06-11-peaks-loop-l1-l2-l3-redesign.md §5
- * PRD:  .peaks/_runtime/2026-06-11-session-f0312d/prd/requests/001-001-l2-1-redlines-audit.md
- * OpenSpec: openspec/changes/2026-06-11-l2-1-redlines-audit/
- *
- * The audit framework classifies MANDATORY / BLOCKING / MUST NOT / RED LINE
- * markers across skills/, .claude/rules/, and openspec/changes/. Each
- * discovered red line is tagged with its backing (cli-backed / partial /
- * prose-only) so the L2 redesign can track the prose-only ratio over time.
- */
-export type RedLineMarker = 'MANDATORY' | 'BLOCKING' | 'MUST NOT' | 'RED LINE';
-export type RedLineBacking = 'cli-backed' | 'partial' | 'prose-only';
-export interface RedLineSource {
-    /** Path relative to project root, posix-style (forward slashes). */
-    readonly file: string;
-    readonly line: number;
-    readonly marker: RedLineMarker;
-    /** ±2 lines of surrounding context for human review. */
-    readonly context: string;
-}
-export interface RedLineEntry {
-    /** Stable id, e.g. "rl-solo-code-ban-001". */
-    readonly id: string;
-    /** Human-readable rule name, e.g. "Solo Code-Change Red Line". */
-    readonly rule: string;
-    readonly source: RedLineSource;
-    readonly backing: RedLineBacking;
-    /** Relative path to the enforcement file, or null when prose-only. */
-    readonly enforcerRef: string | null;
-    /**
-     * v2.12.1 catalog governance: `true` for entries that are
-     * advisory / educational / "discovered-but-not-yet-enforced" and
-     * therefore should NOT count toward the prose-only ratio (per spec
-     * §10.2 L2 acceptance ≤ 5%). Defaults to `false`; the classifier
-     * sets it to `true` for auto-discovered prose-only entries (those
-     * without a catalog match, since they have no enforcer template
-     * to promote to). Callers that want strict accounting can still
-     * read `backing === 'prose-only'` and filter manually.
-     *
-     * Why: the pre-v2.12.1 catalog treated every MANDATORY/BLOCKING
-     * phrase in SKILL.md as a "red line", which produced a 60.1%
-     * prose-only ratio (89/148) for what is mostly LLM behavior
-     * guidance, not machine-enforceable rules. See
-     * `.peaks/memory/2026-06-27-prose-only-catalog-followup.md`.
-     */
-    readonly informational?: boolean;
-}
-export interface RedLineAudit {
-    readonly totalRedLines: number;
-    readonly cliBacked: number;
-    readonly partial: number;
-    readonly proseOnly: number;
-    readonly audit: readonly RedLineEntry[];
-    /** Findings from running the 7 file-system enforcers during the scan (L2.4 P2-b). */
-    readonly enforcerFindings: readonly EnforcerFinding[];
-}
-/**
- * Enforcer finding — emitted by an enforcer function that runs as part
- * of the audit scan. Distinct from `RedLineEntry` (which is catalog-matched
- * markdown text). L2.4 P2-b ships this dimension: the audit framework
- * actually invokes the 7 file-system enforcers during a scan, not just
- * catalogs them.
- */
-export type EnforcerFindingSeverity = 'pass' | 'warn' | 'fail';
-export interface EnforcerFinding {
-    readonly enforcerId: string;
-    readonly rule: string;
-    readonly severity: EnforcerFindingSeverity;
-    readonly file: string;
-    readonly detail: string;
-}
-/**
- * A single markdown line discovered by a tree scanner. The classifier turns
- * these into RedLineEntry by matching against the red-line catalog.
- */
-export interface MarkdownLine {
-    readonly file: string;
-    readonly line: number;
-    readonly text: string;
-}
-export interface ScanWarning {
-    readonly file: string;
-    readonly message: string;
-}

package/dist/src/services/config/model-routing.d.ts

@@ -1,4 +0,0 @@
-import { type ModelProviderConfig, type PeaksConfig } from './config-types.js';
-export declare const STRONGEST_MODEL_ID: "claude-opus-4-7";
-export declare function getConfiguredExecutionModelId(providers: ModelProviderConfig | undefined): string;
-export declare function getEconomyAwareExecutionModelId(config: Pick<PeaksConfig, 'economyMode' | 'providers'>): string;

package/dist/src/services/config/model-routing.js

@@ -1,17 +0,0 @@
-export const STRONGEST_MODEL_ID = 'claude-opus-4-7';
-export function getConfiguredExecutionModelId(providers) {
-    const providerConfigs = Object.values(providers ?? {});
-    const configuredModel = providerConfigs
-        .map((provider) => provider?.model?.trim())
-        .find((model) => typeof model === 'string' && model.length > 0);
-    if (!configuredModel) {
-        throw new Error('Execution model must be configured in providers');
-    }
-    return configuredModel;
-}
-export function getEconomyAwareExecutionModelId(config) {
-    // Slice 2.0.1-bug1 round 3: economy is the project default. Treat undefined as enabled
-    // (matches the pre-slice implicit default from DEFAULT_CONFIG.economyMode = true). Only an
-    // explicit `economyMode === false` switches execution to STRONGEST_MODEL_ID.
-    return config.economyMode !== false ? getConfiguredExecutionModelId(config.providers) : STRONGEST_MODEL_ID;
-}

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

@@ -1,37 +0,0 @@
-import type { CompactDispatchResult } from './auto-compact-types.js';
-export type CompactTarget = 'main' | 'sub-agent';
-export interface DispatchIdeCompactInput {
-    readonly projectRoot: string;
-    readonly sessionId: string;
-    readonly env?: NodeJS.ProcessEnv | undefined;
-    /** Spawn timeout (ms). Default 30s — Claude Code `/compact` is sync. */
-    readonly timeoutMs?: number | undefined;
-    /**
-     * Slice 2026-06-28-solo-mode-bypass-fix (defect #4): which session
-     * the compact should target. Default `'main'` — the orchestrator
-     * (peaks-code body) runs in the main-session Claude Code window and
-     * wants to compress *its* context, not a sub-agent's. Sub-agent
-     * shells that spawn their own `peaks solo auto-compact` flow pass
-     * `'sub-agent'` to preserve the legacy shell-spawn behaviour.
-     *
-     * Behaviour matrix (claude-code MVP):
-     *   - target='main'     → llm-self-compress (write intent; main LLM
-     *                          fires `/compact` on its next turn).
-     *   - target='sub-agent'→ shell-exec (spawn `sh -c /compact` in the
-     *                          sub-agent's own shell, preserving the
-     *                          pre-slice behaviour).
-     * Non-claude-code IDEs + target='main' return noop + warning.
-     */
-    readonly target?: CompactTarget | undefined;
-}
-/**
- * Dispatch compact via the active IDE's registered pathway.
- *
- * Returns a `CompactDispatchResult` envelope. The result is `ok`
- * when the dispatch path completed without error — for
- * `llm-self-compress` the LLM still has to do the actual summary,
- * so the orchestrator MUST NOT treat `ok: true` as proof that the
- * context actually shrunk; the next `peaks context now` probe
- * confirms.
- */
-export declare function dispatchIdeCompact(input: DispatchIdeCompactInput): Promise<CompactDispatchResult>;

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

@@ -1,240 +0,0 @@
-/**
- * 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:
- *
- *   - `shell-exec`     — peaks-loop spawns the adapter's
- *                        `compactCommand` via `child_process.spawn`.
- *                        Works for any IDE that accepts a slash
- *                        command via a shell-spawnable entry point
- *                        (Claude Code MVP: `/compact`).
- *   - `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.
- */
-import { spawn } from 'node:child_process';
-import { detectIdeFromEnv } from './main-session-monitor.js';
-import { getAdapter } from '../ide/ide-registry.js';
-/**
- * Dispatch compact via the active IDE's registered pathway.
- *
- * Returns a `CompactDispatchResult` envelope. The result is `ok`
- * when the dispatch path completed without error — for
- * `llm-self-compress` the LLM still has to do the actual summary,
- * so the orchestrator MUST NOT treat `ok: true` as proof that the
- * context actually shrunk; the next `peaks context now` probe
- * confirms.
- */
-export async function dispatchIdeCompact(input) {
-    const env = input.env ?? process.env;
-    const detected = detectIdeFromEnv(env);
-    // See auto-compact-reader.ts for the IdeKind→IdeId cast rationale.
-    const ideId = (detected === 'unknown' ? 'claude-code' : detected);
-    const adapter = getAdapter(ideId);
-    // Slice 2026-06-28-solo-mode-bypass-fix (defect #4): default to
-    // `'main'` so the orchestrator's auto-compact actually compresses
-    // 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.`
-        };
-    }
-    // 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".
-    if (!adapter.compact) {
-        return {
-            ok: false,
-            ide: ideId,
-            pathway: 'noop',
-            message: `IDE '${ideId}' has no registered compact profile; cannot dispatch.`
-        };
-    }
-    const profile = adapter.compact;
-    const timeoutMs = input.timeoutMs ?? 30_000;
-    const pathway = profile.compactPathway;
-    switch (pathway) {
-        case 'shell-exec':
-            // Slice 2026-06-28: shell-exec is only correct when the caller
-            // IS the shell whose context we want compressed. Sub-agents
-            // qualify; the main-session orchestrator does not.
-            if (target === 'main') {
-                return {
-                    ok: true,
-                    ide: ideId,
-                    pathway: 'llm-self-compress',
-                    message: `Main-session target on shell-exec adapter '${ideId}': deferring to in-band /compact (next LLM turn); writing intent record.`
-                };
-            }
-            return await dispatchShellExec({
-                ideId,
-                command: profile.compactCommand,
-                timeoutMs
-            });
-        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 session auto-compact-hook`) 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
-            // `.peaks/memory/2026-06-27-auto-compact-design.md:139-152`).
-            //
-            // `ide-native` is ONLY for the main-session runner. When the
-            // caller is a sub-agent shell (which has its own ephemeral
-            // context window — not the runner's), fall through to
-            // shell-exec so the sub-agent's `compactCommand` spawns a
-            // child claude process and the sub-agent's own runner doesn't
-            // get a PreToolUse hook installed in the wrong place.
-            if (target === 'sub-agent') {
-                return await dispatchShellExec({
-                    ideId,
-                    command: profile.compactCommand,
-                    timeoutMs
-                });
-            }
-            // Lazy install: we only get here when the caller explicitly
-            // invokes `peaks solo auto-compact --execute`, so the user has
-            // already opted in. No zero-touch surprise on workspace init.
-            return await dispatchIdeNativeHook({
-                projectRoot: input.projectRoot,
-                sessionId: input.sessionId,
-                target
-            });
-        case 'llm-self-compress':
-            return {
-                ok: true,
-                ide: ideId,
-                pathway: 'llm-self-compress',
-                message: `Adapter '${ideId}' uses LLM-self-compress; LLM will summarize on next turn.`
-            };
-        case 'noop':
-            return {
-                ok: false,
-                ide: ideId,
-                pathway: 'noop',
-                message: `Adapter '${ideId}' explicitly opted out of auto-compact.`
-            };
-        default:
-            // Forward-compatibility: if a new pathway is added to the
-            // union, we fall through to noop + log the unknown value.
-            return {
-                ok: false,
-                ide: ideId,
-                pathway: 'noop',
-                message: `Unknown compact pathway '${String(pathway)}' for adapter '${ideId}'.`
-            };
-    }
-}
-/**
- * Spawn the adapter's `compactCommand` via child_process. Returns
- * the dispatch envelope with `pathway: 'shell-exec'`.
- *
- * MVP: Claude Code registers `compactCommand: '/compact'` and
- * `compactPathway: 'shell-exec'`. We spawn via `sh -c` so the
- * slash-command resolves inside the runner's shell session.
- *
- * For other IDEs that adopt `shell-exec` in the future, the
- * `compactCommand` field drives whatever shell-spawnable token
- * the IDE accepts (e.g. trae's compact-token).
- */
-function dispatchShellExec(input) {
-    return new Promise((resolve) => {
-        const child = spawn('sh', ['-c', input.command], {
-            stdio: 'ignore',
-            // Detach so the IDE's runner picks up the slash command.
-            detached: true,
-            env: process.env
-        });
-        child.unref();
-        const timer = setTimeout(() => {
-            // Don't kill — the IDE runner keeps the command alive in
-            // its own session; we just stop waiting.
-            resolve({
-                ok: true,
-                ide: input.ideId,
-                pathway: 'shell-exec',
-                message: `Compact command '${input.command}' dispatched (timeout=${input.timeoutMs}ms); IDE runner should pick it up.`
-            });
-        }, input.timeoutMs);
-        child.on('error', (err) => {
-            clearTimeout(timer);
-            resolve({
-                ok: false,
-                ide: input.ideId,
-                pathway: 'shell-exec',
-                message: `Failed to spawn compact command '${input.command}': ${err.message}`
-            });
-        });
-        child.on('spawn', () => {
-            // Spawn succeeded — return immediately; the IDE runner
-            // continues processing the slash command in its own session.
-            clearTimeout(timer);
-            resolve({
-                ok: true,
-                ide: input.ideId,
-                pathway: 'shell-exec',
-                message: `Compact command '${input.command}' spawned successfully.`
-            });
-        });
-    });
-}
-/**
- * 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 session auto-compact-hook` which in-band spawns
- * `claude --compact` against the CURRENT runner session.
- *
- * Returns `ok: true, pathway: 'ide-native'` regardless of install
- * action (`installed` vs `already-installed`) — both states
- * achieve the operational goal: the hook is wired and the next
- * Bash call will trigger it.
- */
-async function dispatchIdeNativeHook(input) {
-    // Lazy dynamic import — matches the existing pattern in
-    // `runAutoCompact` for `auto-compact-reader.ts` (line 311) and
-    // 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 });
-    return {
-        ok: true,
-        ide: 'claude-code',
-        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 already installed at ${result.settingsPath}; next Bash/Task tool call will trigger compact in-band at ratio ≥ 95%.`
-    };
-}