peaks-loop 4.0.0-beta → 4.0.0-beta.11

package/dist/src/services/config/config-types.d.ts

@@ -1,119 +0,0 @@
-export type ModelPreference = 'haiku' | 'sonnet' | 'opus' | 'minimax';
-export type ModelProviderId = 'minimax' | string;
-export type ExecutionModelId = string;
-export type ProviderModelConfig = {
-    model?: ExecutionModelId;
-    baseUrl?: string;
-    apiKey?: string;
-};
-export type MiniMaxProviderConfig = ProviderModelConfig;
-export type ModelProviderConfig = {
-    minimax?: MiniMaxProviderConfig;
-    [providerId: string]: ProviderModelConfig | undefined;
-};
-export type ProxyConfig = {
-    httpProxy?: string;
-};
-export type TokenRef = {
-    env: string;
-} | {
-    keychain: string;
-} | {
-    ghCli: true;
-};
-export type TokenConfig = {
-    AnthropicApiKey?: TokenRef;
-    OpenAiApiKey?: TokenRef;
-    GitHubToken?: TokenRef;
-    GitLabToken?: TokenRef;
-};
-export type ArtifactProvider = 'github' | 'gitlab';
-export type ArtifactRemoteRepoConfig = {
-    provider: ArtifactProvider;
-    owner: string;
-    name: string;
-};
-export type ArtifactStorageConfig = {
-    mode: 'local';
-    localPath?: string;
-} | {
-    mode: 'local-with-remote-sync';
-    localPath?: string;
-    remote: ArtifactRemoteRepoConfig;
-};
-export type WorkspaceConfig = {
-    workspaceId: string;
-    name: string;
-    rootPath: string;
-    artifactRepo?: ArtifactRemoteRepoConfig;
-    artifactStorage?: ArtifactStorageConfig;
-    installedCapabilityIds: string[];
-};
-export type OcrAuthHeader = 'authorization' | 'x-api-key' | 'bearer';
-export type OcrLlmConfig = {
-    url?: string;
-    authToken?: string;
-    model?: string;
-    useAnthropic?: boolean;
-    authHeader?: OcrAuthHeader;
-};
-export type OcrConfig = {
-    llm?: OcrLlmConfig;
-};
-/**
- * 2.0.1 slim `~/.peaks/config.json` schema. The on-disk file holds
- * ONLY `version` + `ocr.llm.*` placeholders. All other settings
- * (providers, proxy, workspaces, language/model/economy/swarm
- * toggles) live in sidecar files under the same `~/.peaks/`
- * directory or in per-project `preferences.json`.
- *
- * The slim shape is enforced on disk by `loadGlobalConfig`; any
- * unknown field on read is silently stripped and the file is
- * rewritten with the slim shape, so a hand-written or partially-
- * migrated file cannot grow stale fields.
- *
- * NOTE: legacy fields below are kept on the type as `@deprecated`
- * so existing consumers (`config-service.ts`, `workflow-commands.ts`,
- * etc.) continue to compile during the migration window. They are
- * written to / read from sidecar files at runtime; the slim
- * `~/.peaks/config.json` only persists `version` + `ocr`.
- */
-export type PeaksConfig = {
-    version: string;
-    ocr?: OcrConfig;
-    /** @deprecated Moved to `~/.peaks/providers.json` (provider-service.ts) */
-    providers?: ModelProviderConfig;
-    /** @deprecated Moved to `~/.peaks/proxy.json` (proxy-service.ts) */
-    proxy?: ProxyConfig;
-    /** @deprecated Removed in 2.0.1; canonical home is `<project>/.peaks/preferences.json` */
-    language?: string;
-    /** @deprecated Removed in 2.0.1; canonical home is preferences */
-    model?: ModelPreference;
-    /** @deprecated Removed in 2.0.1; canonical home is preferences */
-    economyMode?: boolean;
-    /** @deprecated Removed in 2.0.1; canonical home is preferences */
-    swarmMode?: boolean;
-    /** @deprecated Removed in 2.0.1; never read from this file */
-    tokens?: TokenConfig;
-    /** @deprecated Moved to `~/.peaks/workspaces.json` (workspace-state-service.ts) */
-    workspaces?: WorkspaceConfig[];
-    /** @deprecated Moved to `~/.peaks/workspaces.json` (workspace-state-service.ts) */
-    currentWorkspace?: string | null;
-};
-export type ConfigLayer = 'user' | 'project';
-export type ConfigGetOptions = {
-    key?: string;
-    layer?: ConfigLayer;
-};
-export type ConfigSetOptions = {
-    key: string;
-    value: unknown;
-    layer?: ConfigLayer;
-};
-/**
- * 2.0.1 slim runtime default for `~/.peaks/config.json`. The on-disk
- * file only carries `version` + empty `ocr.llm.*` placeholders.
- */
-export declare const DEFAULT_CONFIG: PeaksConfig;
-export type { ConfigV2 } from './config-migration.js';
-export { isConfigV2 } from './config-migration.js';

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/config/provider-service.d.ts

@@ -1,48 +0,0 @@
-/**
- * Provider configs (MiniMax and other custom providers) live in
- * `~/.peaks/providers.json` — NOT in the slim `~/.peaks/config.json`.
- * The slim config only carries `version` + `ocr.llm.*`; provider
- * model selection, base URLs, and API keys live here in a dedicated
- * sidecar so the user has one discoverable location for runtime
- * model-routing settings.
- *
- * This module is the only owner of the providers.json file. Reads
- * from `~/.peaks/config.json.providers` are tolerated as a one-time
- * back-compat fallback so an unmigrated 1.x-style config still
- * returns the user's existing MiniMax configuration; the next
- * `setMiniMaxProviderConfig` call promotes the value into
- * `~/.peaks/providers.json` and the legacy `~/.peaks/config.json`
- * field is stripped by `loadGlobalConfig` governance.
- */
-export declare const MINIMAX_API_HOST = "api.minimaxi.com";
-export type MiniMaxProviderConfig = {
-    model?: string;
-    baseUrl?: string;
-    apiKey?: string;
-};
-export type ProviderModelConfig = MiniMaxProviderConfig;
-export type ModelProviderId = 'minimax' | string;
-export type ExecutionModelId = string;
-export type ModelPreference = 'haiku' | 'sonnet' | 'opus' | 'minimax';
-export type ModelProviderConfig = {
-    minimax?: MiniMaxProviderConfig;
-    [providerId: string]: ProviderModelConfig | undefined;
-};
-export declare function isValidProviderBaseUrl(value: string): boolean;
-export declare function isValidMiniMaxBaseUrl(value: string): boolean;
-export declare function validateMiniMaxBaseUrl(value: unknown): void;
-export declare function validateProviderBaseUrl(value: unknown): void;
-export declare function validateModelProviderConfig(providers: ModelProviderConfig): void;
-export type MiniMaxProviderStatus = {
-    provider: 'minimax';
-    configured: boolean;
-    baseUrlConfigured: boolean;
-    apiKeyConfigured: boolean;
-    storage: 'sidecar-v1';
-    nextActions: string[];
-};
-export declare function getMiniMaxProviderConfig(): MiniMaxProviderConfig;
-export declare function getMiniMaxProviderStatus(): MiniMaxProviderStatus;
-export declare function setMiniMaxProviderConfig(input: MiniMaxProviderConfig): MiniMaxProviderStatus;
-export declare function getAllProviders(): ModelProviderConfig;
-export declare function setProviderConfig(providerId: string, input: ProviderModelConfig): ModelProviderConfig;

package/dist/src/services/config/provider-service.js

@@ -1,143 +0,0 @@
-import { SIDECAR_SCHEMA_VERSION, ensureSidecarVersion, providersConfigPath, readSidecarJson, writeSidecarJson } from './sidecar-store.js';
-/**
- * Provider configs (MiniMax and other custom providers) live in
- * `~/.peaks/providers.json` — NOT in the slim `~/.peaks/config.json`.
- * The slim config only carries `version` + `ocr.llm.*`; provider
- * model selection, base URLs, and API keys live here in a dedicated
- * sidecar so the user has one discoverable location for runtime
- * model-routing settings.
- *
- * This module is the only owner of the providers.json file. Reads
- * from `~/.peaks/config.json.providers` are tolerated as a one-time
- * back-compat fallback so an unmigrated 1.x-style config still
- * returns the user's existing MiniMax configuration; the next
- * `setMiniMaxProviderConfig` call promotes the value into
- * `~/.peaks/providers.json` and the legacy `~/.peaks/config.json`
- * field is stripped by `loadGlobalConfig` governance.
- */
-export const MINIMAX_API_HOST = 'api.minimaxi.com';
-function loadProvidersSidecar() {
-    const fallback = { version: SIDECAR_SCHEMA_VERSION, providers: {} };
-    const raw = readSidecarJson(providersConfigPath(), fallback);
-    const version = ensureSidecarVersion(raw).version;
-    const providers = sanitizeProviders(raw.providers);
-    return { version, providers };
-}
-function saveProvidersSidecar(providers) {
-    writeSidecarJson(providersConfigPath(), {
-        version: SIDECAR_SCHEMA_VERSION,
-        providers
-    });
-}
-function sanitizeProviders(value) {
-    if (value === null || typeof value !== 'object' || Array.isArray(value))
-        return {};
-    const out = {};
-    for (const [id, cfg] of Object.entries(value)) {
-        if (cfg === null || typeof cfg !== 'object' || Array.isArray(cfg))
-            continue;
-        const sanitized = sanitizeMiniMaxLike(cfg);
-        if (Object.keys(sanitized).length > 0) {
-            out[id] = sanitized;
-        }
-    }
-    return out;
-}
-function sanitizeMiniMaxLike(value) {
-    if (value === null || typeof value !== 'object' || Array.isArray(value))
-        return {};
-    const v = value;
-    const out = {};
-    if (typeof v.model === 'string' && v.model.trim().length > 0)
-        out.model = v.model.trim();
-    if (typeof v.baseUrl === 'string' && v.baseUrl.length > 0)
-        out.baseUrl = v.baseUrl;
-    if (typeof v.apiKey === 'string' && v.apiKey.length > 0)
-        out.apiKey = v.apiKey;
-    return out;
-}
-export function isValidProviderBaseUrl(value) {
-    try {
-        const url = new URL(value);
-        return url.protocol === 'https:' && url.username.length === 0 && url.password.length === 0 && url.search.length === 0 && url.hash.length === 0;
-    }
-    catch {
-        return false;
-    }
-}
-export function isValidMiniMaxBaseUrl(value) {
-    try {
-        const url = new URL(value);
-        return url.protocol === 'https:' && url.hostname === MINIMAX_API_HOST && url.username.length === 0 && url.password.length === 0 && url.search.length === 0 && url.hash.length === 0;
-    }
-    catch {
-        return false;
-    }
-}
-export function validateMiniMaxBaseUrl(value) {
-    if (value !== undefined && (typeof value !== 'string' || !isValidMiniMaxBaseUrl(value))) {
-        throw new Error('MiniMax base URL must be the MiniMax HTTPS endpoint without embedded credentials');
-    }
-}
-export function validateProviderBaseUrl(value) {
-    if (value !== undefined && (typeof value !== 'string' || !isValidProviderBaseUrl(value))) {
-        throw new Error('Provider base URL must be HTTPS without embedded credentials, query, or fragment');
-    }
-}
-export function validateModelProviderConfig(providers) {
-    validateMiniMaxBaseUrl(providers.minimax?.baseUrl);
-    for (const [providerId, provider] of Object.entries(providers)) {
-        if (providerId !== 'minimax') {
-            validateProviderBaseUrl(provider?.baseUrl);
-        }
-    }
-}
-function createMiniMaxProviderStatus(config) {
-    const baseUrl = config.baseUrl?.trim();
-    const apiKey = config.apiKey?.trim();
-    const baseUrlConfigured = typeof baseUrl === 'string' && baseUrl.length > 0 && isValidMiniMaxBaseUrl(baseUrl);
-    const apiKeyConfigured = typeof apiKey === 'string' && apiKey.length > 0;
-    return {
-        provider: 'minimax',
-        configured: baseUrlConfigured && apiKeyConfigured,
-        baseUrlConfigured,
-        apiKeyConfigured,
-        storage: 'sidecar-v1',
-        nextActions: baseUrlConfigured && apiKeyConfigured ? [] : ['Export MINIMAX_API_KEY and rerun peaks config provider minimax set --base-url <url>']
-    };
-}
-export function getMiniMaxProviderConfig() {
-    return loadProvidersSidecar().providers.minimax ?? {};
-}
-export function getMiniMaxProviderStatus() {
-    return createMiniMaxProviderStatus(getMiniMaxProviderConfig());
-}
-export function setMiniMaxProviderConfig(input) {
-    validateMiniMaxBaseUrl(input.baseUrl);
-    const current = loadProvidersSidecar().providers;
-    const next = {
-        ...current,
-        minimax: {
-            ...current.minimax,
-            ...input
-        }
-    };
-    validateMiniMaxBaseUrl(next.minimax?.baseUrl);
-    saveProvidersSidecar(next);
-    return createMiniMaxProviderStatus(next.minimax ?? {});
-}
-export function getAllProviders() {
-    return loadProvidersSidecar().providers;
-}
-export function setProviderConfig(providerId, input) {
-    if (providerId === 'minimax') {
-        throw new Error('Use setMiniMaxProviderConfig for the minimax provider');
-    }
-    validateProviderBaseUrl(input.baseUrl);
-    const current = loadProvidersSidecar().providers;
-    const sanitized = sanitizeMiniMaxLike(input);
-    const next = { ...current, [providerId]: sanitized };
-    validateProviderBaseUrl(sanitized.baseUrl);
-    saveProvidersSidecar(next);
-    return next;
-}

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%.`
-    };
-}