peaks-loop 4.0.0-beta.9 → 4.0.1

package/dist/cli/commands/session-auto-compact-hook-command.d.ts

@@ -1,37 +0,0 @@
-/**
- * `peaks session auto-compact-hook` — slice 2026-07-02-auto-compact-zero-pause.
- *
- * The Bash entrypoint the PreToolUse hook fires on every Bash/Task
- * tool call from the Claude Code runner. Behaviour:
- *
- *   1. Read `CLAUDE_CONTEXT_USAGE_PERCENT` (or any adapter-declared
- *      env-var via the registry — claude-code MVP). If ratio is below
- *      the red-line threshold (0.95), exit 0 silent — the runner's
- *      normal flow continues.
- *   2. If ratio is ≥ 0.95 (red line), write a one-line stderr hint
- *      so the human sees what happened, then in-band spawn
- *      `claude --compact` so the **current** runner's context
- *      window collapses (not a new claude process).
- *   3. Always exit 0. The hook is a probe, not a gate — the gate is
- *      `claude --compact` itself returning 0.
- *
- * Idempotency: re-running the hook is safe; if `claude --compact`
- * is already in flight, the new process just exits 0 immediately
- * (Claude Code's compact is a one-shot operation against the
- * current runner).
- *
- * Why a CLI subcommand instead of an inline JS hook:
- *   - Keeps the hook payload in `.claude/settings.local.json` small
- *     (one line: `peaks session auto-compact-hook`).
- *   - Lets the heavy lifting (ratio parsing, IDE-aware env-var
- *     resolution, spawning `claude --compact`) live in TypeScript
- *     where it's unit-testable.
- *   - Discoverable via `peaks session --help` — future LLM sessions
- *     see the primitive exists.
- *
- * Karpathy §2: 50 lines, no abstractions, no speculative error
- * handling. The hook command is a single-purpose muscle; if it
- * grows beyond ~80 lines, that's a signal to split.
- */
-import type { Command } from 'commander';
-export declare function registerSessionAutoCompactHookCommand(session: Command): void;

package/dist/cli/commands/session-auto-compact-hook-command.js

@@ -1,127 +0,0 @@
-/**
- * `peaks session auto-compact-hook` — slice 2026-07-02-auto-compact-zero-pause.
- *
- * The Bash entrypoint the PreToolUse hook fires on every Bash/Task
- * tool call from the Claude Code runner. Behaviour:
- *
- *   1. Read `CLAUDE_CONTEXT_USAGE_PERCENT` (or any adapter-declared
- *      env-var via the registry — claude-code MVP). If ratio is below
- *      the red-line threshold (0.95), exit 0 silent — the runner's
- *      normal flow continues.
- *   2. If ratio is ≥ 0.95 (red line), write a one-line stderr hint
- *      so the human sees what happened, then in-band spawn
- *      `claude --compact` so the **current** runner's context
- *      window collapses (not a new claude process).
- *   3. Always exit 0. The hook is a probe, not a gate — the gate is
- *      `claude --compact` itself returning 0.
- *
- * Idempotency: re-running the hook is safe; if `claude --compact`
- * is already in flight, the new process just exits 0 immediately
- * (Claude Code's compact is a one-shot operation against the
- * current runner).
- *
- * Why a CLI subcommand instead of an inline JS hook:
- *   - Keeps the hook payload in `.claude/settings.local.json` small
- *     (one line: `peaks session auto-compact-hook`).
- *   - Lets the heavy lifting (ratio parsing, IDE-aware env-var
- *     resolution, spawning `claude --compact`) live in TypeScript
- *     where it's unit-testable.
- *   - Discoverable via `peaks session --help` — future LLM sessions
- *     see the primitive exists.
- *
- * Karpathy §2: 50 lines, no abstractions, no speculative error
- * handling. The hook command is a single-purpose muscle; if it
- * grows beyond ~80 lines, that's a signal to split.
- */
-import { spawn } from 'node:child_process';
-import { detectIdeFromEnv } from '../../services/context/main-session-monitor.js';
-import { getAdapter } from '../../services/ide/ide-registry.js';
-/**
- * Red-line ratio threshold. Must match the orchestrator's
- * AUTO_COMPACT_RED_LINE_RATIO constant (0.95). Kept here as a
- * literal so the hook command stays self-contained — a future
- * slice may move this to a shared constant module if the value
- * starts drifting.
- */
-const RED_LINE_RATIO = 0.95;
-/**
- * Parse `CLAUDE_CONTEXT_USAGE_PERCENT` (or the adapter-declared
- * env-var) into a ratio in [0, 1]. Returns null on missing /
- * malformed input. Mirrors `readEnvPercent` in
- * `auto-compact-reader.ts` so the hook command and the
- * orchestrator agree on parsing semantics.
- */
-function readRatioFromEnv(env) {
-    const detected = detectIdeFromEnv(env);
-    const ideId = (detected === 'unknown' ? 'claude-code' : detected);
-    const adapter = getAdapter(ideId);
-    if (!adapter.compact)
-        return null;
-    const varName = adapter.compact.envVarForContextPercent;
-    const raw = env[varName];
-    if (typeof raw !== 'string' || raw.length === 0)
-        return null;
-    const parsed = Number.parseFloat(raw);
-    if (!Number.isFinite(parsed))
-        return null;
-    // Allow either "0..1" or "0..100" encoding. Claude Code writes
-    // "0..1" today; statusline tools sometimes write "0..100". Normalize.
-    const ratio = parsed > 1.5 ? parsed / 100 : Math.max(0, Math.min(1, parsed));
-    return { ratio, varName };
-}
-export function registerSessionAutoCompactHookCommand(session) {
-    session
-        .command('auto-compact-hook')
-        .description('PreToolUse hook entrypoint — read CLAUDE_CONTEXT_USAGE_PERCENT and, ' +
-        'at ratio ≥ 0.95, in-band spawn `claude --compact` against the current ' +
-        'runner. Designed for invocation from `.claude/settings.local.json` ' +
-        'PreToolUse hooks; safe to re-run.')
-        .action(() => {
-        const probe = readRatioFromEnv(process.env);
-        if (probe === null) {
-            // No signal → exit 0 silent. The hook must never block the
-            // runner's normal flow on a missing env-var.
-            return;
-        }
-        if (probe.ratio < RED_LINE_RATIO) {
-            // Below red line → exit 0 silent. The orchestrator's
-            // pre-compact zone (0.85–0.95) is handled out-of-band by
-            // the LLM firing `peaks code auto-compact --execute`; the
-            // hook only fires on the synchronous red-line path.
-            return;
-        }
-        // Red line reached — compact the current runner in-band.
-        // The `detached: true` + `unref()` pair lets the hook return
-        // immediately while Claude Code's own slash-command processor
-        // picks up `claude --compact` against the runner's session.
-        // This is the fix for the shell-exec-spawns-a-child-process
-        // bug documented in `.peaks/memory/2026-06-27-auto-compact-design.md:139-152`.
-        //
-        // Dogfood 2026-07-02 fix: when `claude` is not on PATH (the
-        // user runs Claude Code as an MCP rather than via the CLI
-        // binary), `spawn` raises ENOENT. Catching this MUST NOT crash
-        // the runner's tool call — the hook must exit 0 silently with
-        // a one-line stderr hint so the runner keeps working. The user
-        // can then run `/compact` manually (or `peaks code auto-compact`
-        // from another terminal).
-        try {
-            const child = spawn('claude', ['--compact'], {
-                stdio: 'ignore',
-                detached: true,
-                env: process.env
-            });
-            child.on('error', () => {
-                // Spawn failed (ENOENT or EPERM). Exit 0 silently with a
-                // stderr hint — the hook contract is "never crash the
-                // runner's tool call".
-                process.stderr.write('[peaks:auto-compact-hook] claude CLI not on PATH; cannot fire in-band. Run `/compact` manually or set up the Claude Code CLI binary.\n');
-            });
-            child.unref();
-            process.stderr.write(`[peaks:auto-compact-hook] ratio=${(probe.ratio * 100).toFixed(1)}% ≥ ${(RED_LINE_RATIO * 100).toFixed(0)}%; firing claude --compact in-band\n`);
-        }
-        catch {
-            // Defensive: `spawn` can throw synchronously on some platforms.
-            process.stderr.write('[peaks:auto-compact-hook] failed to spawn claude --compact; run `/compact` manually.\n');
-        }
-    });
-}

package/dist/cli/commands/worker-commands.d.ts

@@ -1,3 +0,0 @@
-import { Command } from 'commander';
-import { type ProgramIO } from '../cli-helpers.js';
-export declare function registerWorkerCommands(program: Command, io: ProgramIO): void;

package/dist/cli/commands/worker-commands.js

@@ -1,52 +0,0 @@
-import { getMiniMaxProviderConfig } from '../../services/config/config-service.js';
-import { runMiniMaxWorker } from '../../services/providers/minimax-worker-service.js';
-import { fail, ok } from '../../shared/result.js';
-import { addJsonOption, getErrorMessage, printResult, redactSensitiveErrorMessage, summarizeMiniMaxWorkerResult } from '../cli-helpers.js';
-function addMiniMaxWorkerOptions(command) {
-    return addJsonOption(command
-        .description('Run a single MiniMax coding and unit-test execution worker')
-        .requiredOption('--session-id <id>', 'session identifier (the single-axis workspace binding after the change-id root removal)')
-        .requiredOption('--goal <goal>', 'execution goal')
-        .requiredOption('--coding-task <task>', 'coding execution task')
-        .requiredOption('--unit-test-task <task>', 'unit-test execution task')
-        .option('--model <model>', 'model name for the worker', 'MiniMax-M2.7')
-        .option('--confirm', 'confirm that worker inputs may be sent to the external MiniMax provider once and only return a review handoff', false));
-}
-async function runMiniMaxWorkerCommand(io, options) {
-    if (!options.confirm) {
-        printResult(io, fail('worker.minimax', 'CONFIRMATION_REQUIRED', 'This worker only runs with explicit confirmation because inputs may be sent to the external MiniMax provider', {}, ['Rerun with --confirm after removing secrets from worker inputs']), options.json);
-        process.exitCode = 1;
-        return;
-    }
-    const sessionId = options.sessionId.trim();
-    const goal = options.goal.trim();
-    const codingTask = options.codingTask.trim();
-    const unitTestTask = options.unitTestTask.trim();
-    if (!sessionId || !goal || !codingTask || !unitTestTask) {
-        printResult(io, fail('worker.minimax', 'INVALID_WORKER_INPUT', 'Worker inputs must be non-empty', {}, ['Provide non-empty values for --session-id, --goal, --coding-task, and --unit-test-task']), options.json);
-        process.exitCode = 1;
-        return;
-    }
-    try {
-        const result = await runMiniMaxWorker(getMiniMaxProviderConfig(), { sessionId, goal, codingTask, unitTestTask, model: options.model });
-        const safeResult = summarizeMiniMaxWorkerResult(result);
-        if (!result.provider.configured) {
-            printResult(io, fail('worker.minimax', 'MINIMAX_PROVIDER_NOT_CONFIGURED', 'MiniMax provider requires baseUrl and apiKey in user config', safeResult, ['Run peaks config provider minimax set --base-url <url> and either MINIMAX_API_KEY']), options.json);
-            process.exitCode = 1;
-            return;
-        }
-        printResult(io, result.provider.ok ? ok('worker.minimax', safeResult) : fail('worker.minimax', 'MINIMAX_WORKER_FAILED', 'MiniMax worker execution failed', safeResult, ['Check the MiniMax base URL, API key, and worker tasks']), options.json);
-        if (!result.provider.ok) {
-            process.exitCode = 1;
-        }
-    }
-    catch (error) {
-        printResult(io, fail('worker.minimax', 'MINIMAX_WORKER_FAILED', redactSensitiveErrorMessage(getErrorMessage(error)), {}, ['Check the MiniMax base URL, API key, and worker tasks']), options.json);
-        process.exitCode = 1;
-    }
-}
-export function registerWorkerCommands(program, io) {
-    const worker = program.command('worker').description('Run controlled execution workers');
-    addMiniMaxWorkerOptions(worker.command('minimax')).action(async (options) => runMiniMaxWorkerCommand(io, options));
-    addMiniMaxWorkerOptions(program.command('minimax-worker')).action(async (options) => runMiniMaxWorkerCommand(io, options));
-}

package/dist/services/agent/ecc-agent-service.d.ts

@@ -1,47 +0,0 @@
-/**
- * The 12 most-used ECC agents per the upstream
- * everything-claude-code catalog. The full 64-agent list is
- * available at runtime via `npx ecc agent list`; this static
- * subset covers the common L3-doctor dispatch paths.
- */
-export declare const CANONICAL_ECC_AGENTS: readonly {
-    name: string;
-    description: string;
-}[];
-export interface EccAgentResult {
-    readonly agent: string;
-    readonly ok: boolean;
-    readonly stdout: string;
-    readonly stderr: string;
-    readonly durationMs: number;
-    /** Parsed JSON envelope if the subprocess exited 0 and stdout was JSON. */
-    readonly parsed?: unknown;
-    readonly error?: string;
-}
-export interface EccAgentServiceInput {
-    readonly agent: string;
-    readonly projectRoot: string;
-    readonly enableAgent?: boolean | undefined;
-}
-export interface EccAgentServiceResult {
-    readonly agent: string;
-    readonly spawned: boolean;
-    readonly reason: 'enabled-and-installed' | 'disabled-by-preference' | 'flag-disabled' | 'flag-enabled-but-ecc-missing' | 'disabled-and-ecc-missing';
-    readonly result: EccAgentResult | null;
-    readonly warnings: readonly string[];
-}
-export interface SubprocessRunner {
-    run(command: string, args: readonly string[], timeoutMs: number): SubprocessResult;
-}
-export interface SubprocessResult {
-    readonly status: number | null;
-    readonly stdout: string;
-    readonly stderr: string;
-    readonly error?: Error;
-}
-/**
- * Validate the agent name against the canonical ECC catalog.
- * Returns `null` if the agent is known; an error message otherwise.
- */
-export declare function validateEccAgent(agent: string): string | null;
-export declare function runEccAgent(input: EccAgentServiceInput, runner?: SubprocessRunner): EccAgentServiceResult;

package/dist/services/agent/ecc-agent-service.js

@@ -1,143 +0,0 @@
-/**
- * ECC 64 agents soft-optional integration — `peaks agent run`.
- *
- * Per spec §7.2 line 818: "64 agents — Soft Optional — 装了 L3
- * 直接调; 不装 L3 退化到 peaks-loop 自有少数核心诊断". The
- * canonical ECC subprocess contract is:
- *
- *   npx ecc consult "<topic>" --target claude
- *   npx ecc agent run <agent-name> --target <path> --json
- *
- * The peaks-loop `peaks agent run <name> --target <path> --json`
- * CLI shells out to the second form. When ECC is missing OR
- * `agentShieldEnabled: false`, the audit completes with a
- * peaks-loop-only envelope.
- *
- * Mirrors `static-service.ts` (the ECC AgentShield wrapper from
- * L2.3 P2-a): same `subprocessRunner` injection point, same
- * 5-state reason enum, same soft-fail policy.
- */
-import { spawnSync } from 'node:child_process';
-/**
- * The 12 most-used ECC agents per the upstream
- * everything-claude-code catalog. The full 64-agent list is
- * available at runtime via `npx ecc agent list`; this static
- * subset covers the common L3-doctor dispatch paths.
- */
-export const CANONICAL_ECC_AGENTS = [
-    { name: 'security-reviewer', description: 'Audit trust boundary + OWASP top-10' },
-    { name: 'code-reviewer', description: 'General-purpose code review' },
-    { name: 'typescript-reviewer', description: 'TypeScript-specific review' },
-    { name: 'python-reviewer', description: 'Python-specific review' },
-    { name: 'golang-reviewer', description: 'Go-specific review' },
-    { name: 'rust-reviewer', description: 'Rust-specific review' },
-    { name: 'java-reviewer', description: 'Java-specific review' },
-    { name: 'cpp-reviewer', description: 'C/C++-specific review' },
-    { name: 'backend-patterns', description: 'Backend service patterns' },
-    { name: 'frontend-patterns', description: 'Frontend patterns' },
-    { name: 'database-migrations', description: 'DB migration safety' },
-    { name: 'deployment-patterns', description: 'Deployment / CI-CD patterns' },
-];
-const ECC_DETECT_TIMEOUT_MS = 5000;
-const ECC_RUN_TIMEOUT_MS = 60000;
-const defaultSubprocessRunner = {
-    run(command, args, timeoutMs) {
-        try {
-            const r = spawnSync(command, args, {
-                timeout: timeoutMs,
-                encoding: 'utf8',
-                stdio: ['ignore', 'pipe', 'pipe'],
-                maxBuffer: 16 * 1024 * 1024,
-            });
-            return {
-                status: r.status,
-                stdout: r.stdout ?? '',
-                stderr: r.stderr ?? '',
-            };
-        }
-        catch (err) {
-            return {
-                status: null,
-                stdout: '',
-                stderr: '',
-                error: err,
-            };
-        }
-    },
-};
-function isEccInstalled(runner) {
-    const result = runner.run('npx', ['ecc', '--version'], ECC_DETECT_TIMEOUT_MS);
-    if (result.error)
-        return false;
-    return result.status === 0;
-}
-/**
- * Validate the agent name against the canonical ECC catalog.
- * Returns `null` if the agent is known; an error message otherwise.
- */
-export function validateEccAgent(agent) {
-    if (typeof agent !== 'string' || agent.length === 0) {
-        return 'peaks agent run: agent name must be a non-empty string';
-    }
-    if (!/^[a-z][a-z0-9-]*$/.test(agent)) {
-        return `peaks agent run: agent name "${agent}" is invalid (must match [a-z][a-z0-9-]*)`;
-    }
-    return null;
-}
-export function runEccAgent(input, runner = defaultSubprocessRunner) {
-    const enableAgent = input.enableAgent === true;
-    const warnings = [];
-    let result = null;
-    // Resolve the effective "should spawn" decision.
-    // flagEnabled (CLI override) > preference (always-on for now; L3+ future) > false
-    const shouldSpawn = enableAgent;
-    const installed = isEccInstalled(runner);
-    let reason;
-    let spawned;
-    if (!shouldSpawn) {
-        reason = 'flag-disabled';
-        spawned = false;
-    }
-    else if (!installed) {
-        reason = 'flag-enabled-but-ecc-missing';
-        spawned = false;
-        warnings.push('`npx ecc --version` failed. Run `npx ecc --help` to install ECC, ' +
-            'then re-run `peaks agent run`. The peaks-loop native diagnostic ' +
-            'still runs via `peaks doctor scan`.');
-    }
-    else {
-        reason = 'enabled-and-installed';
-        spawned = true;
-        const start = Date.now();
-        const subResult = runner.run('npx', ['ecc', 'agent', 'run', input.agent, '--target', input.projectRoot, '--json'], ECC_RUN_TIMEOUT_MS);
-        let parsed;
-        let error;
-        if (subResult.error) {
-            error = subResult.error.message;
-        }
-        else if (subResult.status !== 0) {
-            error = `ecc agent run exited with status ${subResult.status}: ${subResult.stderr}`;
-        }
-        else {
-            try {
-                parsed = JSON.parse(subResult.stdout);
-            }
-            catch {
-                // Non-JSON output is allowed; peaks-loop surfaces the raw
-                // stdout for the human reader and treats the run as
-                // ok=true (the subprocess exited 0).
-                parsed = undefined;
-            }
-        }
-        result = {
-            agent: input.agent,
-            ok: error === undefined,
-            stdout: subResult.stdout,
-            stderr: subResult.stderr,
-            durationMs: Date.now() - start,
-            ...(parsed !== undefined ? { parsed } : {}),
-            ...(error !== undefined ? { error } : {}),
-        };
-    }
-    return { agent: input.agent, spawned, reason, result, warnings };
-}

package/dist/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/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/services/context/dispatch-context-guard.d.ts

@@ -1,27 +0,0 @@
-/** Build the canonical artifact path for a given session/rid/role/idx/ext. */
-export declare function artifactPath(projectRoot: string, sid: string, rid: string, role: string, idx: number, ext?: string): string;
-/** Build the canonical shared channel path. */
-export declare function sharedChannelPath(projectRoot: string, sid: string, rid: string, batchId: string): string;
-/**
- * Assert that `artifactPath` lives under
- * `projectRoot/.peaks/_sub_agents/<sid>/artifacts/`. Rejects
- * symlink/junction escapes and `..` segments.
- *
- * Throws an Error with `.code = 'INVALID_ARTIFACT_PATH'` on rejection.
- */
-export declare function assertSafeArtifactPath(artifactPathInput: string, projectRoot: string): string;
-/**
- * Assert that `channelPath` lives under
- * `projectRoot/.peaks/_sub_agents/<sid>/shared/`. Same R-2 logic as
- * `assertSafeArtifactPath` but with a different canonical subdir.
- *
- * Throws an Error with `.code = 'INVALID_SHARED_CHANNEL_PATH'` on rejection.
- */
-export declare function assertSafeSharedChannelPath(channelPathInput: string, projectRoot: string): string;
-/**
- * Soft-warn check on the artifact file name pattern. Returns null if
- * the name matches `<rid>-<role>-<idx>.<ext>`, otherwise returns a
- * warning string. Does NOT reject (the path is still in the canonical
- * dir; the warning is for human/audit readability per G7.4.c).
- */
-export declare function checkArtifactNameConvention(artifactPathInput: string): string | null;