peaks-loop 4.0.0-beta.6 → 4.0.0-beta.8

package/dist/src/cli/commands/code-review-commands.d.ts

@@ -1,34 +0,0 @@
-/**
- * peaks code-review * CLI surface — soft-optional ocr integration
- * for peaks-rd Gate B3.
- *
- * Per the "skill-first / CLI-auxiliary" tenet, peaks-rd SKILL.md
- * is the primary surface; this CLI returns structured JSON the
- * skill consumes to produce a second-opinion code review.
- *
- * Subcommands:
- *   - `peaks code-review detect-ocr` — JSON envelope describing the
- *     current ocr install + config state (5 reasons: ready /
- *     package-missing / binary-missing / config-missing /
- *     detection-failed). Source of truth for the LLM endpoint
- *     config is `peaksConfig.ocr.llm` in the user's peaks-loop
- *     config (NOT `~/.opencodereview/config.json`).
- *   - `peaks code-review run-ocr [--from --to --commit]` — invokes
- *     `ocr review --format json` and wraps the result in a peaks
- *     ResultEnvelope. Soft-fails when ocr isn't ready so peaks-rd
- *     can continue without the second-opinion review. Injects the
- *     LLM endpoint config as env vars (OCR_LLM_URL / OCR_LLM_TOKEN
- *     / OCR_LLM_MODEL / OCR_USE_ANTHROPIC / OCR_LLM_AUTH_HEADER)
- *     so the ocr subprocess never has to read from a file the
- *     user did not set up themselves.
- *   - `peaks code-review config-template` — prints the JSON snippet
- *     the user should paste into their peaks-loop config.json. It
- *     does NOT write anything. The user is in control of their
- *     LLM token / URL / model. No `peaks ocr config set`; the user
- *     either edits the JSON directly or uses `peaks config set
- *     --key ocr.llm.url --value '...'` (a peaks-loop command, not
- *     an ocr command).
- */
-import { Command } from 'commander';
-import { type ProgramIO } from '../cli-helpers.js';
-export declare function registerCodeReviewCommands(program: Command, io: ProgramIO): void;

package/dist/src/cli/commands/code-review-commands.js

@@ -1,83 +0,0 @@
-import { getOcrConfigTemplate, detectOcr, runOcrReview } from '../../services/code-review/ocr-service.js';
-import { getOcrLlmConfig, getUserConfigPath, redactConfigSecrets } from '../../services/config/config-service.js';
-import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
-import { fail, ok } from '../../shared/result.js';
-export function registerCodeReviewCommands(program, io) {
-    const codeReview = program
-        .command('code-review')
-        .description('Code-review primitives for peaks-rd Gate B3. Wraps the soft-optional `@alibaba-group/open-code-review` (ocr) tool when it is installed + configured; peaks-rd uses the structured JSON output as a second-opinion review alongside its own LLM review. ocr is a peerDependency of peaks-loop 2.8.2+ (was briefly promoted to a hard dependency in 2.0.1/2.0.2, then demoted to optionalDependencies 2.0.3+ — peer in 2.8.2 because its postinstall downloads a Go binary via HTTPS and would otherwise slow `npm i -g peaks-loop` in restricted environments). Install manually with `npm i -g @alibaba-group/open-code-review` if you want second-opinion reviews. LLM endpoint config lives under `peaksConfig.ocr.llm` in the user config — run `peaks code-review config-template` to see the JSON snippet to paste.');
-    addJsonOption(codeReview
-        .command('detect-ocr')
-        .description('Read-only probe: returns the ocr install + config state as a JSON envelope (5 reasons: ready / package-missing / binary-missing / config-missing / detection-failed). peaks-rd calls this first to decide whether to invoke `run-ocr`. Reads the LLM endpoint from `peaksConfig.ocr.llm` (not from ~/.opencodereview/config.json).')
-        .option('--project <path>', 'project root (default: cwd)')).action((options) => {
-        const projectRoot = options.project ?? process.cwd();
-        try {
-            const detect = detectOcr({
-                cwd: projectRoot,
-                peaksConfigPath: getUserConfigPath(),
-                peaksOcrConfig: getOcrLlmConfig(),
-            });
-            const envelope = detect.state === 'ready'
-                ? ok('code-review.detect-ocr', detect, [...detect.warnings], [...detect.nextActions])
-                : fail('code-review.detect-ocr', detect.state.toUpperCase().replace(/-/g, '_'), `ocr is not ready: ${detect.state}`, detect, [...detect.nextActions]);
-            printResult(io, envelope, options.json);
-            if (detect.state !== 'ready') {
-                process.exitCode = 1;
-            }
-        }
-        catch (error) {
-            printResult(io, fail('code-review.detect-ocr', 'DETECT_OCR_FAILED', getErrorMessage(error), { state: 'detection-failed', packageInstalled: false, binaryPath: null, version: null, configPath: '', configValid: false, missingKeys: [] }, ['Re-run with `--project <path>` pointing at a known-good project root.']), options.json);
-            process.exitCode = 1;
-        }
-    });
-    addJsonOption(codeReview
-        .command('run-ocr')
-        .description('Run `ocr review --format json` and return the parsed JSON envelope. Soft-fails (exit 0, ok=false) when ocr is not ready, so peaks-rd can continue without the second-opinion review and surface the install/config nextActions to the user. The peaks-loop `peaksConfig.ocr.llm` block is injected as OCR_LLM_URL / OCR_LLM_TOKEN / ... env vars so the ocr subprocess never has to read ~/.opencodereview/config.json.')
-        .option('--project <path>', 'project root (default: cwd)')
-        .option('--from <ref>', 'git ref to diff from (e.g. main, origin/main)')
-        .option('--to <ref>', 'git ref to diff to (e.g. HEAD, feature-branch)')
-        .option('--commit <sha>', 'specific commit SHA to review')).action((options) => {
-        const projectRoot = options.project ?? process.cwd();
-        try {
-            const result = runOcrReview({
-                cwd: projectRoot,
-                peaksConfigPath: getUserConfigPath(),
-                peaksOcrConfig: getOcrLlmConfig(),
-                input: { projectRoot, ...(options.from !== undefined && { from: options.from }), ...(options.to !== undefined && { to: options.to }), ...(options.commit !== undefined && { commit: options.commit }) },
-            });
-            // Soft-fail policy: when ocr is not ready or the subprocess
-            // failed, we still return a JSON envelope (ok=false) but
-            // do NOT set process.exitCode — the caller is expected to
-            // pattern-match on the state and proceed without ocr.
-            const envelope = result.spawned && result.exitCode === 0
-                ? ok('code-review.run-ocr', result, [...result.warnings], [...result.nextActions])
-                : fail('code-review.run-ocr', result.state.toUpperCase().replace(/-/g, '_'), result.spawned ? `ocr review exited ${result.exitCode}` : `ocr is not ready: ${result.state}`, result, [...result.nextActions]);
-            printResult(io, envelope, options.json);
-            // Intentionally do NOT set process.exitCode here — soft-fail.
-        }
-        catch (error) {
-            printResult(io, fail('code-review.run-ocr', 'RUN_OCR_FAILED', getErrorMessage(error), { spawned: false, state: 'detection-failed', exitCode: null, stdout: '', stderr: '', durationMs: 0, parsed: null }, ['Run `peaks code-review detect-ocr --json` to inspect ocr install state.']), options.json);
-            // Soft-fail on exception too — peaks-rd should continue.
-        }
-    });
-    addJsonOption(codeReview
-        .command('config-template')
-        .description('Print the JSON snippet the user should paste into their peaks-loop config (`peaksConfig.ocr.llm`). This command does NOT write anything. The user is the only party that touches the LLM token / URL / model — peaks-loop never auto-configures the endpoint. Token value is shown as the placeholder "<your-api-key>"; replace it before pasting.')).action((options) => {
-        const template = getOcrConfigTemplate();
-        const targetPath = getUserConfigPath();
-        const currentConfig = getOcrLlmConfig();
-        const currentRedacted = currentConfig === null ? null : redactConfigSecrets(currentConfig, 'ocr.llm');
-        const payload = {
-            targetPath,
-            currentConfig: currentRedacted,
-            template,
-            nextActions: [
-                `Edit ${targetPath} and add the "ocr" block from the template above.`,
-                'OR use peaks-loop config set with one key at a time: `peaks config set --key ocr.llm.url --value \'<url>\'` etc.',
-                'The authToken field is sensitive and is stored in the user layer (`~/.peaks/config.json`); peaks-loop will not commit it.',
-                'Re-run `peaks code-review detect-ocr --json` to verify the new state is `ready`.',
-            ],
-        };
-        printResult(io, ok('code-review.config-template', payload), options.json);
-    });
-}

package/dist/src/cli/commands/codegraph-commands.d.ts

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

package/dist/src/cli/commands/codegraph-commands.js

@@ -1,99 +0,0 @@
-import { InvalidArgumentError } from 'commander';
-import { createCodegraphInvocation, executeCodegraphInvocation } from '../../services/codegraph/codegraph-service.js';
-import { fail } from '../../shared/result.js';
-import { getErrorMessage, printResult, redactSensitiveErrorMessage } from '../cli-helpers.js';
-function addPeaksJsonOption(command) {
-    return command.option('--peaks-json', 'print Peaks error envelope as machine-readable JSON');
-}
-function addProjectOption(command) {
-    return addPeaksJsonOption(command.requiredOption('--project <path>', 'target project root'));
-}
-function parsePositiveInteger(value) {
-    if (!/^\d+$/.test(value)) {
-        throw new InvalidArgumentError('must be a positive integer');
-    }
-    const parsed = Number(value);
-    if (!Number.isSafeInteger(parsed) || parsed < 1) {
-        throw new InvalidArgumentError('must be a positive integer');
-    }
-    return parsed;
-}
-function printCodegraphFailure(io, command, error, asJson, exitCode = 1) {
-    printResult(io, fail(command, 'CODEGRAPH_COMMAND_FAILED', redactSensitiveErrorMessage(getErrorMessage(error)), {}, ['Check the codegraph command options and project path before retrying']), asJson);
-    process.exitCode = exitCode;
-}
-async function runCodegraphCommand(io, command, options, asJson) {
-    try {
-        const invocation = createCodegraphInvocation(options);
-        const result = await executeCodegraphInvocation(invocation);
-        if (result.exitCode !== null && result.exitCode !== 0 && asJson === true) {
-            printCodegraphFailure(io, command, new Error(result.stderr || result.stdout || `codegraph exited with code ${result.exitCode}`), true, result.exitCode);
-            return;
-        }
-        const didFail = result.exitCode !== null && result.exitCode !== 0;
-        if (result.stdout.length > 0) {
-            io.stdout((didFail ? redactSensitiveErrorMessage(result.stdout) : result.stdout).trimEnd());
-        }
-        if (result.stderr.length > 0) {
-            io.stderr((didFail ? redactSensitiveErrorMessage(result.stderr) : result.stderr).trimEnd());
-        }
-        if (didFail) {
-            process.exitCode = result.exitCode;
-        }
-    }
-    catch (error) {
-        printCodegraphFailure(io, command, error, asJson);
-    }
-}
-export function registerCodegraphCommands(program, io) {
-    const codegraph = program.command('codegraph').description('Run upstream codegraph commands through the Peaks launcher');
-    addProjectOption(codegraph.command('status').description('Show codegraph status')).action((options) => runCodegraphCommand(io, 'codegraph.status', { subcommand: 'status', project: options.project }, options.peaksJson));
-    addProjectOption(codegraph.command('init').description('Initialize codegraph for a project').option('--yes', 'answer yes to upstream prompts')).action((options) => runCodegraphCommand(io, 'codegraph.init', {
-        subcommand: 'init',
-        project: options.project,
-        ...(options.yes === true ? { yes: true } : {})
-    }, options.peaksJson));
-    addProjectOption(codegraph
-        .command('index')
-        .description('Index a project with codegraph')
-        .option('--force', 'force reindexing')
-        .option('--quiet', 'reduce upstream output')).action((options) => runCodegraphCommand(io, 'codegraph.index', {
-        subcommand: 'index',
-        project: options.project,
-        ...(options.force === true ? { force: true } : {}),
-        ...(options.quiet === true ? { quiet: true } : {})
-    }, options.peaksJson));
-    addProjectOption(codegraph
-        .command('query')
-        .description('Query codegraph')
-        .argument('<search>', 'search text')
-        .option('--json', 'forward JSON output flag to upstream codegraph')
-        .option('--limit <n>', 'maximum result count', parsePositiveInteger)).action((search, options) => runCodegraphCommand(io, 'codegraph.query', {
-        subcommand: 'query',
-        project: options.project,
-        search,
-        ...(options.json === true ? { json: true } : {}),
-        ...(options.limit !== undefined ? { limit: options.limit } : {})
-    }, options.peaksJson));
-    addProjectOption(codegraph
-        .command('files')
-        .description('List codegraph files')
-        .option('--json', 'forward JSON output flag to upstream codegraph')
-        .option('--max-depth <n>', 'maximum traversal depth', parsePositiveInteger)).action((options) => runCodegraphCommand(io, 'codegraph.files', {
-        subcommand: 'files',
-        project: options.project,
-        ...(options.json === true ? { json: true } : {}),
-        ...(options.maxDepth !== undefined ? { maxDepth: options.maxDepth } : {})
-    }, options.peaksJson));
-    addProjectOption(codegraph.command('context').description('Build task context with codegraph').argument('<task>', 'task text')).action((task, options) => runCodegraphCommand(io, 'codegraph.context', { subcommand: 'context', project: options.project, task }, options.peaksJson));
-    addProjectOption(codegraph
-        .command('affected')
-        .description('Find code affected by files')
-        .argument('<files...>', 'project-relative file paths')
-        .option('--json', 'forward JSON output flag to upstream codegraph')).action((files, options) => runCodegraphCommand(io, 'codegraph.affected', {
-        subcommand: 'affected',
-        project: options.project,
-        files,
-        ...(options.json === true ? { json: true } : {})
-    }, options.peaksJson));
-}

package/dist/src/cli/commands/compact-command.d.ts

@@ -1,21 +0,0 @@
-/**
- * `peaks compact *` — strategic-compact CLI primitives.
- *
- * Slice 2026-07-01-strategic-compact-cli. Five subcommands under a new
- * top-level `peaks compact` group:
- *
- *   - suggest:    PreToolUse-style two-signal suggestion (context size
- *                 + tool-call count), read-only by default.
- *   - recommend:  Pure (from, to) phase-pair → severity lookup.
- *   - survival:   Static SKILL.md "What Survives Compaction" table.
- *   - dry-run:    Composite of (suggest + recommend + survival), no
- *                 writes.
- *   - force:      Write a pre-compact checkpoint via
- *                 `peaks session checkpoint`; the IDE-side `/compact`
- *                 is still the LLM's call.
- *
- * Each subcommand returns a `--json` envelope via `printResult`.
- */
-import type { Command } from 'commander';
-import { type ProgramIO } from '../cli-helpers.js';
-export declare function registerCompactCommands(program: Command, io: ProgramIO): void;

package/dist/src/cli/commands/compact-command.js

@@ -1,252 +0,0 @@
-import { resolveCanonicalProjectRoot } from '../../services/config/config-service.js';
-import { findProjectRoot } from '../../services/config/config-safety.js';
-import { fail, ok, getErrorMessage } from '../../shared/result.js';
-import { addJsonOption, printResult } from '../cli-helpers.js';
-import { writeCheckpoint } from '../../services/session/session-checkpoint-service.js';
-import { getSessionIdCanonical } from '../../services/session/session-manager.js';
-import { buildRecommendEnvelopePure, dryRunCompact, suggestCompact } from '../../services/compact/suggest-service.js';
-import { PHASES, SURVIVAL_TABLE, isPhase, lookupPhaseTransition } from '../../services/compact/decision-tables.js';
-function splitList(value) {
-    if (!value)
-        return [];
-    return value
-        .split(/\r?\n/)
-        .map((s) => s.trim())
-        .filter((s) => s.length > 0);
-}
-function resolveSessionId(projectRoot, explicit) {
-    if (explicit !== undefined && explicit.length > 0) {
-        return { sid: explicit, error: null };
-    }
-    // Statically-imported `getSessionIdCanonical` (see import block
-    // at the top of this file). It is the single source of truth for
-    // "what session is bound to this project"; we use it instead of
-    // re-implementing the resolution here to keep one fix point when
-    // the binding layout changes.
-    const sid = getSessionIdCanonical(projectRoot) ?? null;
-    if (sid === null) {
-        return {
-            sid: null,
-            error: {
-                code: 'NO_ACTIVE_SESSION',
-                message: 'No active session bound. Run `peaks workspace init --project <repo> --json` to bind one.',
-                nextActions: [`peaks workspace init --project ${projectRoot} --json`]
-            }
-        };
-    }
-    return { sid, error: null };
-}
-export function registerCompactCommands(program, io) {
-    const compact = program
-        .command('compact')
-        .description('Strategic-compact primitives: suggest / recommend / survival / dry-run / force');
-    // -----------------------------------------------------------------
-    // 1. peaks compact suggest [--json]
-    // -----------------------------------------------------------------
-    addJsonOption(compact
-        .command('suggest')
-        .description('Two-signal suggestion (context-size + tool-call-count). ' +
-        'Honor COMPACT_THRESHOLD / COMPACT_CONTEXT_THRESHOLD / COMPACT_CONTEXT_INTERVAL env vars. ' +
-        'Read-only by default; pass --apply to also append a one-line info row to the session log.')
-        .option('--project <path>', 'project root (defaults to git root or cwd)')
-        .option('--session-id <sid>', 'override the active session id (defaults to the canonical binding)')
-        .option('--apply', 'append a one-line info row to .peaks/_runtime/<sid>/session.json (default: dry-run)')).action((options) => {
-        try {
-            const projectRoot = options.project !== undefined
-                ? resolveCanonicalProjectRoot(options.project)
-                : (findProjectRoot(process.cwd()) ?? process.cwd());
-            const session = resolveSessionId(projectRoot, options.sessionId);
-            if (session.error !== null) {
-                printResult(io, fail('compact.suggest', session.error.code, session.error.message, { projectRoot }, session.error.nextActions), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            const result = suggestCompact({
-                projectRoot,
-                sessionId: session.sid
-            });
-            printResult(io, ok('compact.suggest', result, [], [
-                result.shouldSuggest
-                    ? `Run \`peaks compact force --reason "<short note>"\` to checkpoint, then /compact.`
-                    : `Context at ${(result.ratio * 100).toFixed(1)}% (${result.tokensUsed} of ${result.windowKind === '1m' ? '1M' : '200k'}); below threshold.`
-            ]), options.json);
-        }
-        catch (error) {
-            printResult(io, fail('compact.suggest', 'COMPACT_SUGGEST_FAILED', getErrorMessage(error), {}, ['Verify project root and session binding before retrying']), options.json);
-            process.exitCode = 1;
-        }
-    });
-    // -----------------------------------------------------------------
-    // 2. peaks compact recommend --from <phase> --to <phase> [--json]
-    // -----------------------------------------------------------------
-    addJsonOption(compact
-        .command('recommend')
-        .description(`Strategic-compact "Compaction Decision Guide" lookup. ` +
-        `Valid phases: ${PHASES.join(', ')}. Pure function over (from, to); no I/O.`)
-        .requiredOption('--from <phase>', `source phase (one of ${PHASES.join(', ')})`)
-        .requiredOption('--to <phase>', `target phase (one of ${PHASES.join(', ')})`)).action((options) => {
-        try {
-            if (!isPhase(options.from)) {
-                printResult(io, fail('compact.recommend', 'INVALID_PHASE', `--from must be one of ${PHASES.join(', ')} (got "${options.from}")`, { from: options.from }, [`Use --from ${PHASES.join('|')}`]), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            if (!isPhase(options.to)) {
-                printResult(io, fail('compact.recommend', 'INVALID_PHASE', `--to must be one of ${PHASES.join(', ')} (got "${options.to}")`, { to: options.to }, [`Use --to ${PHASES.join('|')}`]), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            const envelope = buildRecommendEnvelopePure(options.from, options.to);
-            const lookup = lookupPhaseTransition(options.from, options.to);
-            printResult(io, ok('compact.recommend', {
-                from: envelope.from,
-                to: envelope.to,
-                shouldCompact: envelope.shouldCompact,
-                severity: envelope.severity,
-                rationale: envelope.rationale,
-                suggestedMessage: envelope.suggestedMessage,
-                notInTable: lookup.notInTable
-            }, lookup.notInTable ? [`Transition ${options.from} → ${options.to} is not in the strategic-compact table; defaulting to severity=no.`] : []), options.json);
-        }
-        catch (error) {
-            printResult(io, fail('compact.recommend', 'COMPACT_RECOMMEND_FAILED', getErrorMessage(error), { from: options.from, to: options.to }, ['Verify the phase pair against the documented transitions']), options.json);
-            process.exitCode = 1;
-        }
-    });
-    // -----------------------------------------------------------------
-    // 3. peaks compact survival [--json]
-    // -----------------------------------------------------------------
-    addJsonOption(compact
-        .command('survival')
-        .description('Strategic-compact "What Survives Compaction" table. Pure static data; no I/O.')).action((options) => {
-        printResult(io, ok('compact.survival', {
-            persists: [...SURVIVAL_TABLE.persists],
-            lost: [...SURVIVAL_TABLE.lost]
-        }, [], [
-            'Persists = guaranteed across `/compact`. Lost = not preserved; persist to disk before compacting.'
-        ]), options.json);
-    });
-    // -----------------------------------------------------------------
-    // 4. peaks compact dry-run [--from <phase>] [--to <phase>] [--json]
-    // -----------------------------------------------------------------
-    addJsonOption(compact
-        .command('dry-run')
-        .description('Composite preview of (suggest + recommend + survival). ' +
-        'No writes. The LLM calls this every tool-call cycle to stay informed.')
-        .option('--from <phase>', `optional source phase for recommend lookup (one of ${PHASES.join(', ')})`)
-        .option('--to <phase>', `optional target phase for recommend lookup (one of ${PHASES.join(', ')})`)
-        .option('--project <path>', 'project root (defaults to git root or cwd)')
-        .option('--session-id <sid>', 'override the active session id')).action((options) => {
-        try {
-            const projectRoot = options.project !== undefined
-                ? resolveCanonicalProjectRoot(options.project)
-                : (findProjectRoot(process.cwd()) ?? process.cwd());
-            const session = resolveSessionId(projectRoot, options.sessionId);
-            if (session.error !== null) {
-                printResult(io, fail('compact.dry-run', session.error.code, session.error.message, { projectRoot }, session.error.nextActions), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            if ((options.from === undefined) !== (options.to === undefined)) {
-                printResult(io, fail('compact.dry-run', 'PHASE_PAIR_INCOMPLETE', 'Both --from and --to must be provided together', { from: options.from, to: options.to }, ['Pass both --from and --to, or omit both for a suggest-only dry-run']), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            if (options.from !== undefined && !isPhase(options.from)) {
-                printResult(io, fail('compact.dry-run', 'INVALID_PHASE', `--from must be one of ${PHASES.join(', ')} (got "${options.from}")`, { from: options.from }, [`Use --from ${PHASES.join('|')}`]), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            if (options.to !== undefined && !isPhase(options.to)) {
-                printResult(io, fail('compact.dry-run', 'INVALID_PHASE', `--to must be one of ${PHASES.join(', ')} (got "${options.to}")`, { to: options.to }, [`Use --to ${PHASES.join('|')}`]), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            const hasPhasePair = options.from !== undefined && options.to !== undefined;
-            const dryRunInput = {
-                projectRoot,
-                sessionId: session.sid
-            };
-            if (hasPhasePair) {
-                dryRunInput.from = options.from;
-                dryRunInput.to = options.to;
-            }
-            const result = dryRunCompact(dryRunInput);
-            printResult(io, ok('compact.dry-run', result, [], [
-                result.action === 'compact'
-                    ? `Action=compact: run \`peaks compact force --reason "<note>"\`, then /compact.`
-                    : `Action=skip: continue without compacting.`
-            ]), options.json);
-        }
-        catch (error) {
-            printResult(io, fail('compact.dry-run', 'COMPACT_DRY_RUN_FAILED', getErrorMessage(error), {}, ['Verify project root, session binding, and phase pair before retrying']), options.json);
-            process.exitCode = 1;
-        }
-    });
-    // -----------------------------------------------------------------
-    // 5. peaks compact force [--reason <text>] [--json]
-    // -----------------------------------------------------------------
-    addJsonOption(compact
-        .command('force')
-        .description('Write a pre-compact checkpoint via `peaks session checkpoint --reason context-fill`. ' +
-        'The IDE-side `/compact` is still the LLM\'s call; this primitive guarantees ' +
-        'the pre-compact state is persisted. NO sleep, NO wait for IDE response.')
-        .option('--reason <text>', 'human-readable reason for the pre-compact checkpoint', 'pre-force-compact')
-        .option('--project <path>', 'project root (defaults to git root or cwd)')
-        .option('--session-id <sid>', 'override the active session id')
-        .option('--current-plan <text>', 'current plan summary (forwarded to the checkpoint snapshot)')
-        .option('--open-questions <list>', 'newline-separated open questions')
-        .option('--recent-decisions <list>', 'newline-separated recent decisions')
-        .option('--recent-artifact-paths <list>', 'newline-separated recent artifact paths')
-        .option('--git-status <text>', 'recent git status')
-        .option('--skills-active <list>', 'newline-separated active skill names')
-        .option('--todo-state <list>', 'newline-separated todo lines')).action((options) => {
-        try {
-            const projectRoot = options.project !== undefined
-                ? resolveCanonicalProjectRoot(options.project)
-                : (findProjectRoot(process.cwd()) ?? process.cwd());
-            const session = resolveSessionId(projectRoot, options.sessionId);
-            if (session.error !== null) {
-                printResult(io, fail('compact.force', session.error.code, session.error.message, { projectRoot }, session.error.nextActions), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            const reason = (options.reason ?? 'pre-force-compact').slice(0, 200);
-            // The session-checkpoint-service restricts `reason` to a fixed
-            // enum. The strategic-compact `force` primitive uses
-            // 'context-fill' (the closest semantic match: the LLM is
-            // compacting because of context pressure) and records the
-            // caller's free-form reason in `gitStatus` so the snapshot
-            // is self-describing without inventing a new enum value.
-            const checkpointOptions = {
-                sessionId: session.sid,
-                reason: 'context-fill',
-                gitStatus: `compact.force: ${reason}`,
-                openQuestions: splitList(options.openQuestions),
-                recentDecisions: splitList(options.recentDecisions),
-                recentArtifactPaths: splitList(options.recentArtifactPaths),
-                skillsActive: splitList(options.skillsActive),
-                todoState: splitList(options.todoState)
-            };
-            if (options.currentPlan !== undefined) {
-                checkpointOptions.currentPlan = options.currentPlan;
-            }
-            const result = writeCheckpoint(projectRoot, checkpointOptions);
-            printResult(io, ok('compact.force', {
-                checkpointPath: result.path,
-                reason: 'pre-force-compact',
-                callerReason: reason,
-                sessionId: result.sessionId,
-                createdAt: result.createdAt,
-                totalRetained: result.totalRetained,
-                message: 'Pre-compact checkpoint written. The IDE-side /compact is still the LLM\'s call; this CLI does NOT invoke the IDE slash command.'
-            }, [], [
-                'After the LLM fires the IDE-side /compact, call `peaks compact survival` to see what to persist before the next compact.'
-            ]), options.json);
-        }
-        catch (error) {
-            printResult(io, fail('compact.force', 'COMPACT_FORCE_FAILED', getErrorMessage(error), {}, ['Verify the project path is writable and a session is bound']), options.json);
-            process.exitCode = 1;
-        }
-    });
-}

package/dist/src/cli/commands/complexity-commands.d.ts

@@ -1,9 +0,0 @@
-/**
- * v2.15.0 follow-up — G10: peaks complexity estimate CLI.
- *
- *   - `peaks complexity estimate --files <list>` — per-file tier +
- *     aggregate. Aligns with the G2 12 Gaps memory tier definition.
- */
-import type { Command } from 'commander';
-import { type ProgramIO } from '../cli-helpers.js';
-export declare function registerComplexityCommands(program: Command, io: ProgramIO): void;

package/dist/src/cli/commands/complexity-commands.js

@@ -1,34 +0,0 @@
-/**
- * v2.15.0 follow-up — G10: peaks complexity estimate CLI.
- *
- *   - `peaks complexity estimate --files <list>` — per-file tier +
- *     aggregate. Aligns with the G2 12 Gaps memory tier definition.
- */
-import { findProjectRoot } from '../../services/config/config-safety.js';
-import { estimateComplexity } from '../../services/complexity/complexity-estimator.js';
-import { fail, ok } from '../../shared/result.js';
-import { addJsonOption, printResult } from '../cli-helpers.js';
-export function registerComplexityCommands(program, io) {
-    addJsonOption(program
-        .command('complexity-estimate')
-        .description('v2.15.0 follow-up G10: estimate the complexity tier (trivial / simple / ' +
-        'complex) of a set of files, based on LOC + export count + async usage. ' +
-        'Aligns with the G2 12 Gaps memory tier definition. The aggregate ' +
-        'tier drives scheduling (trivial / simple → overnight; complex → ' +
-        'user-attended).')
-        .requiredOption('--files <list>', 'comma-separated file paths (relative to project root)')
-        .option('--project <path>', 'project root (default: cwd)')).action((opts) => {
-        const projectRoot = opts.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
-        const files = opts.files.split(',').map((s) => s.trim()).filter((s) => s.length > 0);
-        if (files.length === 0) {
-            printResult(io, fail('complexity-estimate', 'INVALID_INPUT', 'no files provided (--files)', { projectRoot }, [
-                'Pass --files with at least one file path.'
-            ]), opts.json ?? false);
-            return;
-        }
-        const report = estimateComplexity(projectRoot, files);
-        printResult(io, ok('complexity-estimate', { projectRoot, report }, [], [
-            `Overall tier: ${report.overall}. Schedule accordingly.`
-        ]), opts.json ?? false);
-    });
-}

package/dist/src/cli/commands/config-commands.d.ts

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