peaks-cli 1.4.2 → 2.0.1

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

@@ -0,0 +1,151 @@
+/**
+ * peaks classify CLI (Slice L1a + L1b).
+ *
+ * Subcommands:
+ *   - peaks classify run --project <path> [--override <level> --reason "<text>"]
+ *     Classify the current diff via the heuristic + return a JSON envelope
+ *     with the chosen level, gate set, and audit log.
+ *   - peaks classify override --level <level> --reason "<text>" --project <path>
+ *     Force a level; writes the override to the audit log.
+ *   - peaks classify upgrade --level <level> --reason "<text>" --project <path>
+ *     Same as override but explicitly framed as an upgrade (audit log
+ *     records the upgrade event separately from override).
+ *
+ * Downgrade is REFUSED (per spec §4: "peaks classify downgrade" always
+ * errors out). LLM may ask; the CLI never grants.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { classifyTask } from '../../services/classify/classify-service.js';
+import { TASK_LEVELS } from '../../services/classify/classify-types.js';
+import { loadPreferences } from '../../services/preferences/preferences-service.js';
+import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+import { fail, ok } from '../../shared/result.js';
+const CLASSIFY_AUDIT_FILE = 'classify-audit.jsonl';
+function getSignalsFromGitDiff(projectRoot) {
+    // Use git diff --stat to extract file count + line count. Fall back to
+    // zeros if git is unavailable (e.g. fresh repo with no commits).
+    let stdout;
+    try {
+        const { execFileSync } = require('node:child_process');
+        stdout = execFileSync('git', ['diff', '--shortstat', 'HEAD'], {
+            cwd: projectRoot,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            maxBuffer: 32 * 1024 * 1024,
+        }).toString('utf8');
+    }
+    catch {
+        return { filesChanged: 0, linesChanged: 0, touchesDependencies: false, touchesMigrationScripts: false, isPureRefactor: true, keywords: [] };
+    }
+    const lines = stdout.split('\n').filter((l) => l.trim().length > 0);
+    const filesChanged = lines.length;
+    let added = 0;
+    let removed = 0;
+    let touchesDependencies = false;
+    let touchesMigrationScripts = false;
+    for (const line of lines) {
+        const match = /(\d+)\s+insertion.*?(\d+)\s+deletion/.exec(line);
+        if (match) {
+            added += Number(match[1]);
+            removed += Number(match[2]);
+        }
+        if (/(package\.json|pnpm-lock\.yaml|yarn\.lock|requirements\.txt|go\.mod)/.test(line)) {
+            touchesDependencies = true;
+        }
+        if (/(migrate|codemod|backfill|schema)/.test(line)) {
+            touchesMigrationScripts = true;
+        }
+    }
+    // isPureRefactor: heuristic — if added lines / removed lines < 0.1 OR
+    // no new exports were added, treat as refactor. For L2.2 the signal is
+    // binary (true/false). Default: true (no behavior change is the safe
+    // assumption; flip to false when keyword 'add' / 'new' / 'feature' present).
+    const isPureRefactor = true;
+    return {
+        filesChanged,
+        linesChanged: added + removed,
+        touchesDependencies,
+        touchesMigrationScripts,
+        isPureRefactor,
+        keywords: [],
+    };
+}
+function appendAuditEntry(projectRoot, entry) {
+    const auditDir = join(projectRoot, '.peaks/_runtime');
+    if (!existsSync(auditDir)) {
+        try {
+            mkdirSync(auditDir, { recursive: true });
+        }
+        catch { /* ignore */ }
+    }
+    const auditPath = join(auditDir, CLASSIFY_AUDIT_FILE);
+    let body = '';
+    try {
+        if (existsSync(auditPath)) {
+            body = readFileSync(auditPath, 'utf8');
+        }
+    }
+    catch { /* ignore */ }
+    body += JSON.stringify(entry) + '\n';
+    try {
+        writeFileSync(auditPath, body);
+    }
+    catch { /* best-effort */ }
+}
+function isTaskLevel(value) {
+    return TASK_LEVELS.includes(value);
+}
+export function registerClassifyCommands(program, io) {
+    const classify = program
+        .command('classify')
+        .description('L1a task classification: 5-level heuristic (typo/bug/feature/refactor/migration) + override/upgrade + audit log');
+    addJsonOption(classify
+        .command('run')
+        .description('Classify the current diff (git diff HEAD) into one of 5 task levels')
+        .requiredOption('--project <path>', 'target project root')
+        .option('--override <level>', 'force a level (one of typo|bug|feature|refactor|migration); requires --reason')
+        .option('--reason <text>', 'reason for the override (mandatory when --override is set)')).action(async (options) => {
+        try {
+            const prefs = await loadPreferences(options.project);
+            const signals = getSignalsFromGitDiff(options.project);
+            let override;
+            if (options.override !== undefined) {
+                if (!isTaskLevel(options.override)) {
+                    printResult(io, fail('classify.run', 'INVALID_LEVEL', `level must be one of: ${TASK_LEVELS.join(', ')}`, { provided: options.override }, ['Pass one of typo, bug, feature, refactor, migration']), options.json);
+                    process.exitCode = 1;
+                    return;
+                }
+                if (options.reason === undefined || options.reason.length === 0) {
+                    printResult(io, fail('classify.run', 'REASON_REQUIRED', '--reason is required when --override is set', {}, ['Provide a non-empty reason for the override']), options.json);
+                    process.exitCode = 1;
+                    return;
+                }
+                override = { level: options.override, reason: options.reason };
+            }
+            const result = classifyTask(override !== undefined
+                ? { signals, conservatism: prefs.classifyConservatism, override }
+                : { signals, conservatism: prefs.classifyConservatism }, prefs.classifyRules.feature_threshold_files, prefs.classifyRules.feature_threshold_lines);
+            appendAuditEntry(options.project, result.audit);
+            printResult(io, ok('classify.run', result, [], [
+                `gate set for level "${result.level}": ${result.gateSet.stages.join(', ')}`,
+                `audit log: .peaks/_runtime/${CLASSIFY_AUDIT_FILE}`,
+            ]), options.json);
+        }
+        catch (error) {
+            printResult(io, fail('classify.run', 'CLASSIFY_RUN_FAILED', getErrorMessage(error), { projectRoot: options.project }, ['Run peaks classify --help for usage']), options.json);
+            process.exitCode = 1;
+        }
+    });
+    // Downgrade is REFUSED per spec §4. Surface this as a hard fail.
+    classify
+        .command('downgrade')
+        .description('REFUSED per spec §4 — peaks-cli never downgrades a classification; ask the user to override explicitly')
+        .requiredOption('--level <level>', 'attempted level')
+        .requiredOption('--reason <text>', 'reason for the attempt (always rejected)')
+        .requiredOption('--project <path>', 'target project root')
+        .option('--json', 'print machine-readable JSON envelope')
+        .action(async (options) => {
+        printResult(io, fail('classify.downgrade', 'DOWNGRADE_REFUSED', 'peaks classify downgrade is refused per spec §4. Use --override (with reason) on `classify run` to force a level; the CLI never downgrades a classification unilaterally.', { attemptedLevel: options.level, reason: options.reason }, ['Use `peaks classify run --override <level> --reason "<text>"` instead']), options.json);
+        process.exitCode = 2;
+    });
+}

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

@@ -0,0 +1,34 @@
+/**
+ * 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-cli
+ *     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-cli 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-cli 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

@@ -0,0 +1,83 @@
+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 ships as a peaks-cli dependency (not optional). 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-cli `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-cli config (`peaksConfig.ocr.llm`). This command does NOT write anything. The user is the only party that touches the LLM token / URL / model — peaks-cli 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-cli 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-cli 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/config-commands.js

@@ -1,10 +1,14 @@
+import { executeMigration, planMigration } from '../../services/config/config-migration.js';
 import { getConfig, getMiniMaxProviderConfig, getMiniMaxProviderStatus, isSensitiveConfigPath, redactConfigSecrets, setConfig, setMiniMaxProviderConfig } from '../../services/config/config-service.js';
+import { listAvailableFields, restoreField } from '../../services/config/config-restore.js';
+import { executeRollback, planRollback } from '../../services/config/config-rollback.js';
 import { testMiniMaxProvider } from '../../services/providers/minimax-provider-service.js';
 import { fail, ok } from '../../shared/result.js';
 import { addJsonOption, getErrorMessage, isMiniMaxHttpsUrl, parseConfigLayer, printInvalidConfigLayer, printResult, redactSensitiveErrorMessage, summarizeMiniMaxSmokeResult } from '../cli-helpers.js';
 export function registerConfigCommands(program, io) {
     const config = program.command('config').description('Manage Peaks configuration');
     registerConfigGetSetCommands(config, io);
+    registerConfigMigrationCommands(config, io);
     registerMiniMaxProviderCommands(config, io);
 }
 function registerConfigGetSetCommands(config, io) {
@@ -44,6 +48,92 @@ function registerConfigGetSetCommands(config, io) {
         }
     });
 }
+function registerConfigMigrationCommands(config, io) {
+    // Slice 0.5 Task 14 — peaks config {migrate,rollback,restore} subcommands.
+    // Wires up the config-migration / config-rollback / config-restore services
+    // from Tasks 10-12. The default mode is dry-run; --apply writes.
+    config
+        .command('migrate')
+        .description('Migrate global config from 1.x to 2.0 (YAGNI slim + per-project fields)')
+        .option('--project <path>', 'current project root (for migrating per-project fields)', process.cwd())
+        .option('--apply', 'actually write changes (default is dry-run)')
+        .option('--dry-run', 'plan only, do not write (default)')
+        .option('--json', 'JSON envelope output')
+        .action((options) => {
+        try {
+            const apply = options.apply === true;
+            if (apply) {
+                const result = executeMigration({ currentProjectRoot: options.project, apply: true });
+                printResult(io, ok('config.migrate', result), options.json);
+                return;
+            }
+            const plan = planMigration({ currentProjectRoot: options.project });
+            printResult(io, ok('config.migrate', { ...plan, applied: false }), options.json);
+        }
+        catch (error) {
+            printResult(io, fail('config.migrate', 'CONFIG_MIGRATE_FAILED', getErrorMessage(error), {}, ['Inspect ~/.peaks/config.json and re-run with --apply']), options.json);
+            process.exitCode = 1;
+        }
+    });
+    config
+        .command('rollback')
+        .description('Rollback global config to 1.x from .bak')
+        .option('--apply', 'actually write changes (default is dry-run)')
+        .option('--dry-run', 'plan only, do not write (default)')
+        .option('--json', 'JSON envelope output')
+        .action((options) => {
+        try {
+            const apply = options.apply === true;
+            if (apply) {
+                const result = executeRollback({ apply: true });
+                printResult(io, ok('config.rollback', result), options.json);
+                return;
+            }
+            const plan = planRollback();
+            printResult(io, ok('config.rollback', { ...plan, applied: false }), options.json);
+        }
+        catch (error) {
+            const message = getErrorMessage(error);
+            const code = message.startsWith('NO_BACKUP') ? 'NO_BACKUP' : 'CONFIG_ROLLBACK_FAILED';
+            io.stderr(`${code}: ${message}`);
+            printResult(io, fail('config.rollback', code, message, {}, ['Re-run peaks config migrate --apply to recreate the .bak']), options.json);
+            process.exitCode = 1;
+        }
+    });
+    config
+        .command('restore')
+        .description('Restore a single archived field from .bak to a sidecar file')
+        .option('--field <name>', 'field name to restore (e.g. language, currentWorkspace)')
+        .option('--list', 'list all fields available in .bak')
+        .option('--apply', 'actually write sidecar (default is dry-run)')
+        .option('--dry-run', 'plan only, do not write (default)')
+        .option('--json', 'JSON envelope output')
+        .action((options) => {
+        try {
+            if (options.list === true || !options.field) {
+                const fields = listAvailableFields();
+                printResult(io, ok('config.restore', { fields, applied: false }), options.json);
+                return;
+            }
+            const apply = options.apply === true;
+            const result = restoreField({ field: options.field, apply });
+            printResult(io, ok('config.restore', result), options.json);
+        }
+        catch (error) {
+            const message = getErrorMessage(error);
+            let code = 'CONFIG_RESTORE_FAILED';
+            if (message.startsWith('NO_BACKUP'))
+                code = 'NO_BACKUP';
+            else if (message.startsWith('RESTORE_GUARDED'))
+                code = 'RESTORE_GUARDED';
+            else if (message.startsWith('FIELD_NOT_FOUND'))
+                code = 'FIELD_NOT_FOUND';
+            io.stderr(`${code}: ${message}`);
+            printResult(io, fail('config.restore', code, message, {}, ['Use --list to see available fields']), options.json);
+            process.exitCode = 1;
+        }
+    });
+}
 function printConfigSetError(io, error, asJson) {
     const message = getErrorMessage(error);
     if (message === 'Sensitive config keys must be stored in the user config layer') {

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

@@ -0,0 +1,21 @@
+/**
+ * peaks context * CLI (Slice #3 L1c) — context 4-layer loader.
+ *
+ * Per docs/superpowers/specs/2026-06-11-peaks-cli-l1-l2-l3-redesign.md §4 L1c:
+ *   - L0: full read (every SKILL.md in full)
+ *   - L1: summary (one paragraph per skill + the skill list)
+ *   - L2: index (just names + paths)
+ *   - L3: fuzzy search by query (delegates to peaks memory search)
+ *
+ * The LLM-side UX layer (peaks-solo / peaks-ide) picks the layer based
+ * on the L1a task level:
+ *   - typo:     L0 only (a few lines)
+ *   - bug:     L0 + L1
+ *   - feature: L0 + L1 + L2 + L3(按需)
+ *   - refactor: L0 + L1 + L2 + L3
+ *   - migration: L0 + L1 + L2 + L3 + codegraph
+ */
+import { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export type ContextLayer = 'L0' | 'L1' | 'L2' | 'L3';
+export declare function registerContextCommands(program: Command, io: ProgramIO): void;

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

@@ -0,0 +1,167 @@
+/**
+ * peaks context * CLI (Slice #3 L1c) — context 4-layer loader.
+ *
+ * Per docs/superpowers/specs/2026-06-11-peaks-cli-l1-l2-l3-redesign.md §4 L1c:
+ *   - L0: full read (every SKILL.md in full)
+ *   - L1: summary (one paragraph per skill + the skill list)
+ *   - L2: index (just names + paths)
+ *   - L3: fuzzy search by query (delegates to peaks memory search)
+ *
+ * The LLM-side UX layer (peaks-solo / peaks-ide) picks the layer based
+ * on the L1a task level:
+ *   - typo:     L0 only (a few lines)
+ *   - bug:     L0 + L1
+ *   - feature: L0 + L1 + L2 + L3(按需)
+ *   - refactor: L0 + L1 + L2 + L3
+ *   - migration: L0 + L1 + L2 + L3 + codegraph
+ */
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { searchMemory } from '../../services/memory/memory-search-service.js';
+import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+import { fail, ok } from '../../shared/result.js';
+const SKILLS_DIR = 'skills';
+function readSkillsDir(projectRoot) {
+    const skillsRoot = join(projectRoot, SKILLS_DIR);
+    if (!existsSync(skillsRoot))
+        return [];
+    const out = [];
+    for (const entry of readdirSync(skillsRoot, { withFileTypes: true })) {
+        if (!entry.isDirectory() || entry.name.startsWith('.'))
+            continue;
+        const skillMd = join(skillsRoot, entry.name, 'SKILL.md');
+        if (existsSync(skillMd)) {
+            out.push(`skills/${entry.name}/SKILL.md`);
+        }
+    }
+    return out;
+}
+function readSkillFile(projectRoot, relPath) {
+    const abs = join(projectRoot, relPath);
+    try {
+        return readFileSync(abs, 'utf-8');
+    }
+    catch {
+        return '';
+    }
+}
+async function fetchL0(projectRoot) {
+    const files = readSkillsDir(projectRoot);
+    const warnings = [];
+    let content = '';
+    let byteSize = 0;
+    const sizes = [];
+    for (const rel of files) {
+        const body = readSkillFile(projectRoot, rel);
+        if (body.length === 0) {
+            warnings.push(`failed to read ${rel}`);
+            continue;
+        }
+        content += `## ${rel}\n\n${body}\n\n`;
+        sizes.push({ path: rel, bytes: body.length });
+        byteSize += body.length;
+    }
+    return { layer: 'L0', description: 'full read: every SKILL.md concatenated', files: sizes, content, byteSize, warnings };
+}
+async function fetchL1(projectRoot) {
+    const files = readSkillsDir(projectRoot);
+    const warnings = [];
+    let content = '';
+    let byteSize = 0;
+    const sizes = [];
+    for (const rel of files) {
+        const body = readSkillFile(projectRoot, rel);
+        if (body.length === 0) {
+            warnings.push(`failed to read ${rel}`);
+            continue;
+        }
+        const firstPara = body.split(/\r?\n\r?\n/, 2)[0] ?? body.slice(0, 400);
+        content += `## ${rel}\n\n${firstPara}\n\n`;
+        sizes.push({ path: rel, bytes: firstPara.length });
+        byteSize += firstPara.length;
+    }
+    return { layer: 'L1', description: 'summary: first paragraph per skill', files: sizes, content, byteSize, warnings };
+}
+async function fetchL2(projectRoot) {
+    const files = readSkillsDir(projectRoot);
+    const content = files.map((f) => `- ${f}`).join('\n') + '\n';
+    const byteSize = content.length;
+    return {
+        layer: 'L2',
+        description: 'index: skill paths only (no body)',
+        files: files.map((f) => ({ path: f, bytes: 0 })),
+        content,
+        byteSize,
+        warnings: [],
+    };
+}
+async function fetchL3(projectRoot, query) {
+    const warnings = [];
+    if (query.trim().length === 0) {
+        warnings.push('empty query; L3 requires a --query string for fuzzy search');
+        return { layer: 'L3', description: 'fuzzy search (empty query)', files: [], content: '', byteSize: 0, warnings };
+    }
+    try {
+        const hits = searchMemory({ projectRoot, query, limit: 10 });
+        const lines = [];
+        for (const hit of hits) {
+            lines.push(`- [${hit.score.toFixed(2)}] ${hit.sourcePath}: ${hit.description.slice(0, 120)}`);
+        }
+        const content = lines.join('\n') + '\n';
+        return {
+            layer: 'L3',
+            description: 'fuzzy search: top 10 hits from memory index',
+            files: hits.map((h) => ({ path: h.sourcePath, bytes: h.description.length })),
+            content,
+            byteSize: content.length,
+            warnings,
+        };
+    }
+    catch (error) {
+        return {
+            layer: 'L3',
+            description: 'fuzzy search (failed)',
+            files: [],
+            content: '',
+            byteSize: 0,
+            warnings: [`L3 search failed: ${getErrorMessage(error)}`],
+        };
+    }
+}
+export function registerContextCommands(program, io) {
+    const context = program
+        .command('context')
+        .description('Slice L1c: context 4-layer loader (L0 full / L1 summary / L2 index / L3 fuzzy)');
+    addJsonOption(context
+        .command('layer')
+        .description('Fetch a context layer (L0 = full SKILL.md; L1 = first paragraph; L2 = index; L3 = fuzzy search by --query)')
+        .requiredOption('--project <path>', 'target project root')
+        .requiredOption('--level <L0|L1|L2|L3>', 'context layer to load')
+        .option('--query <text>', 'fuzzy search query (required for L3)')).action(async (options) => {
+        try {
+            const level = options.level;
+            if (level !== 'L0' && level !== 'L1' && level !== 'L2' && level !== 'L3') {
+                printResult(io, fail('context.layer', 'INVALID_LEVEL', `level must be one of L0, L1, L2, L3 (got ${level})`, { provided: level }, ['Pass --level L0|L1|L2|L3']), options.json);
+                process.exitCode = 1;
+                return;
+            }
+            let payload;
+            if (level === 'L0')
+                payload = await fetchL0(options.project);
+            else if (level === 'L1')
+                payload = await fetchL1(options.project);
+            else if (level === 'L2')
+                payload = await fetchL2(options.project);
+            else
+                payload = await fetchL3(options.project, options.query ?? '');
+            printResult(io, ok('context.layer', payload, [], [
+                `${payload.layer} loaded: ${payload.byteSize} bytes across ${payload.files.length} file(s)`,
+                payload.warnings.length > 0 ? `${payload.warnings.length} warning(s); see envelope.warnings` : null
+            ].filter((x) => typeof x === 'string')), options.json);
+        }
+        catch (error) {
+            printResult(io, fail('context.layer', 'CONTEXT_LAYER_FAILED', getErrorMessage(error), { projectRoot: options.project }, ['Verify the project path and --level value']), options.json);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/src/cli/commands/core-artifact-commands.js

@@ -6,10 +6,12 @@ import { executeProjectMemoryBackup, executeProjectMemoryExtract, summarizeProje
 import { summarizeProjectStandardsInitResult, summarizeProjectStandardsUpdateResult } from '../../services/standards/project-standards-service.js';
 import { executeProjectStandardsInitIdeAware, executeProjectStandardsUpdateIdeAware } from '../../services/standards/ide-aware-standards-service.js';
 import { migrateStandards } from '../../services/standards/migrate-service.js';
+import { migrateClaudeRules } from '../../services/standards/migrate-claude-rules-service.js';
 import { listProfiles } from '../../services/profiles/profile-service.js';
 import { planProxyTest } from '../../services/proxy/proxy-service.js';
 import { runDoctor } from '../../services/doctor/doctor-service.js';
 import { listSkills } from '../../services/skills/skill-registry.js';
+import { runSkillSync, SYNC_PLATFORMS } from '../../services/skills/sync-service.js';
 import { inspectSkillRunbook } from '../../services/skills/skill-runbook-service.js';
 import { setSkillPresence, clearSkillPresence, getSkillPresence, isSkillPresenceMode, touchSkillHeartbeat } from '../../services/skills/skill-presence-service.js';
 import { detectPresenceMarker } from '../../services/hooks/presence-marker-detector.js';
@@ -88,6 +90,42 @@ export function registerCoreAndArtifactCommands(program, io) {
             process.exitCode = 1;
         }
     });
+    // Slice #12 final piece (per spec §9 line 1105):
+    // `peaks skills sync 8 平台分发`. Idempotent: re-running is a
+    // no-op when the symlinks are already correct.
+    addJsonOption(skill
+        .command('sync')
+        .description(`Sync the peaks-* skill family to one or all of the 8 supported LLM-CLI platforms (${SYNC_PLATFORMS.join(', ')}). Idempotent.`)
+        .option('--platform <id>', `sync only one platform (default: --all). Valid: ${SYNC_PLATFORMS.join(', ')}`)
+        .option('--all', 'sync all 8 platforms (default if --platform is omitted)')
+        .option('--dry-run', 'do not write; emit the same shape with applied=false')
+        .option('--project <path>', 'project root (default: cwd)')).action(async (options) => {
+        try {
+            const projectRoot = options.project ?? process.cwd();
+            const platforms = options.platform !== undefined ? [options.platform] : undefined;
+            const result = await runSkillSync({
+                projectRoot,
+                ...(platforms !== undefined ? { platforms } : {}),
+                ...(options.dryRun === true ? { dryRun: true } : {}),
+            });
+            const envelope = ok('skill.sync', result, [], [
+                `syncedCount: ${result.syncedCount}/${result.perPlatform.length} platforms`,
+                `totalInstalled: ${result.totalInstalled} skill symlinks`,
+                result.failedCount > 0
+                    ? `failedCount: ${result.failedCount} (run \`peaks skill status\` for details)`
+                    : 'no failures',
+            ]);
+            printResult(io, envelope, options.json);
+            if (result.failedCount > 0) {
+                process.exitCode = 1;
+            }
+        }
+        catch (error) {
+            const message = getErrorMessage(error);
+            printResult(io, fail('skill.sync', 'SKILL_SYNC_FAILED', message, { applied: false }, [message]), options.json);
+            process.exitCode = 1;
+        }
+    });
     addJsonOption(skill
         .command('runbook <name>')
         .description('Inspect a skill Default runbook section and its --apply authorization-note status')).action(async (name, options) => {
@@ -463,10 +501,30 @@ export function registerCoreAndArtifactCommands(program, io) {
     });
     addJsonOption(standards
         .command('migrate')
-        .description('Rewrite a consumer project CLAUDE.md to drop the legacy heartbeat block (slice 028). Dry-run by default; pass --apply to write.')
+        .description('Rewrite a consumer project CLAUDE.md to drop the legacy heartbeat block (slice 028). Dry-run by default; pass --apply to write. With --from-claude-rules, thins the 1.x .claude/rules/ tree to 2-line pointers and scaffolds .peaks/standards/ (slice 2026-06-12-standards-migrate-claude-rules).')
         .option('--project <path>', 'target project root')
-        .option('--apply', 'rewrite the legacy block in place; default is dry-run')).action((options) => {
+        .option('--apply', 'rewrite the legacy block in place; default is dry-run')
+        .option('--from-claude-rules', 'thin .claude/rules/ to pointers and scaffold .peaks/standards/ (used by `peaks upgrade --to 2.0`)')).action((options) => {
         const projectRoot = options.project ?? process.cwd();
+        if (options.fromClaudeRules === true) {
+            try {
+                const result = migrateClaudeRules({ projectRoot, apply: options.apply === true });
+                printResult(io, ok('standards.migrate', result.data, [], [...result.data.nextActions]), options.json);
+            }
+            catch (error) {
+                printResult(io, fail('standards.migrate', 'STANDARDS_MIGRATE_FAILED', getErrorMessage(error), {
+                    backupPath: null,
+                    thinnedFiles: [],
+                    scaffoldedFiles: [],
+                    preservedFiles: [],
+                    wouldChange: false,
+                    applied: false,
+                    nextActions: [],
+                }, [getErrorMessage(error)]), options.json);
+                process.exitCode = 1;
+            }
+            return;
+        }
         try {
             const result = migrateStandards({ project: projectRoot, apply: options.apply === true });
             printResult(io, ok('standards.migrate', result.data, [], result.data.nextActions), options.json);