peaks-cli 1.4.1 → 2.0.0

package/dist/src/services/memory/memory-search-service.d.ts

@@ -0,0 +1,61 @@
+export type { ProjectMemoryKind } from './project-memory-service.js';
+import type { ProjectMemoryKind } from './project-memory-service.js';
+/**
+ * One entry in `.peaks/memory/index.json` after the on-disk `hot[]` +
+ * `cold[]` arrays are flattened. Mirrors the field shape that the
+ * existing `project-memory-service.ts` writer emits.
+ */
+export interface MemoryIndexEntry {
+    name: string;
+    kind: ProjectMemoryKind;
+    description: string;
+    sourcePath: string;
+    sourceArtifact: string | null;
+    updatedAt: string;
+}
+/**
+ * The full snapshot of `.peaks/memory/index.json`.
+ */
+export interface MemoryIndexSnapshot {
+    indexPath: string;
+    version: number;
+    updatedAt: string;
+    entries: MemoryIndexEntry[];
+}
+/**
+ * Input to `searchMemory`. `projectRoot` defaults to the resolved
+ * peaks project root (CLI resolves this before calling). `query` is
+ * required and non-empty.
+ */
+export interface MemorySearchInput {
+    query: string;
+    projectRoot?: string;
+    limit?: number;
+    kind?: ProjectMemoryKind;
+}
+/**
+ * One hit returned by `searchMemory`. Mirrors the entry shape with a
+ * normalized score in [0, 1] (top of batch = 1.0) and the char indices
+ * in the searchable text that contributed to the match.
+ */
+export interface MemorySearchResult {
+    name: string;
+    kind: ProjectMemoryKind;
+    description: string;
+    sourcePath: string;
+    score: number;
+    positions: number[];
+}
+/**
+ * Read `.peaks/memory/index.json` and flatten the on-disk `hot[<kind>][]`
+ * + `cold[]` shape into a single `entries[]` array. Throws structured
+ * errors with stable `code` markers that the CLI converts to the
+ * peaks envelope.
+ */
+export declare function loadMemoryIndex(projectRoot: string): MemoryIndexSnapshot;
+/**
+ * Run the generic fuzzy kernel against the on-disk memory index. The
+ * searchable text is `name + " " + description` for each entry (per
+ * spec §Component Details).
+ */
+export declare function searchMemory(input: MemorySearchInput): MemorySearchResult[];

package/dist/src/services/memory/memory-search-service.js

@@ -0,0 +1,80 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fuzzyMatchWithKey } from '../fuzzy-matching/fuzzy-match-service.js';
+const DEFAULT_LIMIT = 6;
+/**
+ * Read `.peaks/memory/index.json` and flatten the on-disk `hot[<kind>][]`
+ * + `cold[]` shape into a single `entries[]` array. Throws structured
+ * errors with stable `code` markers that the CLI converts to the
+ * peaks envelope.
+ */
+export function loadMemoryIndex(projectRoot) {
+    const indexPath = join(projectRoot, '.peaks', 'memory', 'index.json');
+    if (!existsSync(indexPath)) {
+        const err = new Error(`INDEX_MISSING: memory index not found at ${indexPath}`);
+        err.code = 'INDEX_MISSING';
+        throw err;
+    }
+    let raw;
+    try {
+        raw = readFileSync(indexPath, 'utf8');
+    }
+    catch (cause) {
+        const err = new Error(`INDEX_INVALID: failed to read memory index at ${indexPath}: ${cause.message}`);
+        err.code = 'INDEX_INVALID';
+        throw err;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (cause) {
+        const err = new Error(`INDEX_INVALID: malformed memory index at ${indexPath}: ${cause.message}`);
+        err.code = 'INDEX_INVALID';
+        throw err;
+    }
+    const index = parsed;
+    const hot = index.hot ?? {};
+    const flatFromHot = Object.values(hot).flat();
+    const flatFromCold = (index.cold ?? []);
+    const entries = [...flatFromHot, ...flatFromCold];
+    return {
+        indexPath,
+        version: index.version ?? 1,
+        updatedAt: index.updatedAt ?? '',
+        entries,
+    };
+}
+/**
+ * Run the generic fuzzy kernel against the on-disk memory index. The
+ * searchable text is `name + " " + description` for each entry (per
+ * spec §Component Details).
+ */
+export function searchMemory(input) {
+    if (input.query === '') {
+        const err = new Error('EMPTY_QUERY: searchMemory requires a non-empty query (use `peaks memory index` to list all)');
+        err.code = 'EMPTY_QUERY';
+        throw err;
+    }
+    const projectRoot = input.projectRoot ?? process.cwd();
+    const limit = input.limit ?? DEFAULT_LIMIT;
+    const snapshot = loadMemoryIndex(projectRoot);
+    let candidates = snapshot.entries;
+    if (input.kind !== undefined) {
+        candidates = candidates.filter((e) => e.kind === input.kind);
+    }
+    // Per spec: searchable text is name + " " + description.
+    // The keyFn is invoked once per item per call.
+    const matches = fuzzyMatchWithKey(input.query, candidates, { keyFn: (e) => `${e.name} ${e.description}`, limit, caseSensitive: false });
+    return matches.map((m) => {
+        const entry = m.item;
+        return {
+            name: entry.name,
+            kind: entry.kind,
+            description: entry.description,
+            sourcePath: entry.sourcePath,
+            score: m.score,
+            positions: m.positions,
+        };
+    });
+}

package/dist/src/services/openspec/openspec-propose-from-doctor-service.d.ts

@@ -0,0 +1,31 @@
+/**
+ * openspec-propose-from-doctor-service (Slice L3.3) — generates a draft
+ * OpenSpec change record (proposal.md) from a doctor CRITICAL finding.
+ *
+ * Per L1+L2+L3 redesign §5.4: "CRITICAL → proposal 草稿生成". The doctor
+ * scans the project for issues; when a CRITICAL finding is surfaced,
+ * peaks-cli generates a draft `openspec/changes/<id>/proposal.md` so the
+ * LLM doesn't have to start from scratch.
+ *
+ * The draft proposal is INFORMATIONAL — it requires the LLM to review +
+ * edit before `peaks openspec validate` will accept it.
+ */
+export interface DoctorFinding {
+    readonly id: string;
+    readonly rule: string;
+    readonly detail: string;
+    readonly severity: 'pass' | 'warn' | 'fail';
+}
+export interface ProposeFromDoctorInput {
+    readonly projectRoot: string;
+    readonly finding: DoctorFinding;
+    /** Optional clock for testability. */
+    readonly clock?: () => string;
+}
+export interface ProposeFromDoctorResult {
+    readonly changeId: string;
+    readonly changeDir: string;
+    readonly proposalPath: string;
+    readonly created: boolean;
+}
+export declare function proposeFromDoctor(input: ProposeFromDoctorInput): ProposeFromDoctorResult;

package/dist/src/services/openspec/openspec-propose-from-doctor-service.js

@@ -0,0 +1,95 @@
+/**
+ * openspec-propose-from-doctor-service (Slice L3.3) — generates a draft
+ * OpenSpec change record (proposal.md) from a doctor CRITICAL finding.
+ *
+ * Per L1+L2+L3 redesign §5.4: "CRITICAL → proposal 草稿生成". The doctor
+ * scans the project for issues; when a CRITICAL finding is surfaced,
+ * peaks-cli generates a draft `openspec/changes/<id>/proposal.md` so the
+ * LLM doesn't have to start from scratch.
+ *
+ * The draft proposal is INFORMATIONAL — it requires the LLM to review +
+ * edit before `peaks openspec validate` will accept it.
+ */
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getErrorMessage } from '../../shared/result.js';
+const SLUGIFY = /[^a-z0-9]+/g;
+function slugify(text) {
+    return text
+        .toLowerCase()
+        .replace(SLUGIFY, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 50);
+}
+function formatProposal(input) {
+    return `# Doctor Finding: ${input.finding.rule}
+
+**Date**: ${input.date}
+**Change ID**: ${input.changeId}
+**Source**: \`peaks doctor\` finding (CRITICAL severity: ${input.finding.severity})
+
+## Why
+
+A \`peaks doctor\` scan flagged the following issue at \`${input.finding.id}\`:
+
+> ${input.finding.detail}
+
+The current behavior is broken or degraded. This proposal outlines a fix.
+
+## What Changes
+
+- Address the doctor finding at \`${input.finding.id}\`.
+- See the Why section above for the original error message.
+- Acceptance criteria below describe the success conditions.
+
+## Acceptance Criteria
+
+- \`peaks doctor --json\` returns \`ok: true\` for the \`${input.finding.id}\` check.
+- Re-running the audit does not regress other findings.
+
+## Out of Scope
+
+- Other doctor findings (each is tracked in its own OpenSpec change).
+- Refactors that don't fix this specific issue.
+
+## Risks
+
+- Low: this is a doctor-flagged issue with a clear acceptance criterion.
+
+## Status
+
+- created: ${input.date}
+- last update: ${input.date}
+- state: draft
+- state reason: auto-generated from peaks doctor; LLM must review + edit before validate
+`;
+}
+function makeChangeId(finding, date) {
+    return `${date}-fix-${slugify(finding.id)}`;
+}
+export function proposeFromDoctor(input) {
+    const date = (input.clock ?? (() => new Date().toISOString()))().slice(0, 10);
+    const changeId = makeChangeId(input.finding, date);
+    const changeDir = join(input.projectRoot, 'openspec/changes', changeId);
+    const proposalPath = join(changeDir, 'proposal.md');
+    let created = false;
+    try {
+        if (!existsSync(changeDir)) {
+            mkdirSync(changeDir, { recursive: true });
+        }
+        if (!existsSync(proposalPath)) {
+            const content = formatProposal({
+                changeId,
+                finding: input.finding,
+                title: `Fix ${input.finding.rule}`,
+                date,
+            });
+            writeFileSync(proposalPath, content);
+            created = true;
+        }
+    }
+    catch (error) {
+        throw new Error(`proposeFromDoctor: ${getErrorMessage(error)}`);
+    }
+    return { changeId, changeDir, proposalPath, created };
+}

package/dist/src/services/preferences/preferences-service.d.ts

@@ -0,0 +1,6 @@
+import { DEFAULT_PREFERENCES, PREFERENCES_SCHEMA_VERSION, type ProjectPreferences } from './preferences-types.js';
+export { DEFAULT_PREFERENCES, PREFERENCES_SCHEMA_VERSION };
+export type { ProjectPreferences } from './preferences-types.js';
+export declare function preferencesPath(projectRoot: string): string;
+export declare function loadPreferences(projectRoot: string): ProjectPreferences;
+export declare function savePreferences(projectRoot: string, overrides: Partial<ProjectPreferences>): ProjectPreferences;

package/dist/src/services/preferences/preferences-service.js

@@ -0,0 +1,43 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { DEFAULT_PREFERENCES, PREFERENCES_SCHEMA_VERSION, } from './preferences-types.js';
+const PREFS_REL_PATH = '.peaks/preferences.json';
+export { DEFAULT_PREFERENCES, PREFERENCES_SCHEMA_VERSION };
+export function preferencesPath(projectRoot) {
+    return join(projectRoot, PREFS_REL_PATH);
+}
+export function loadPreferences(projectRoot) {
+    const filePath = preferencesPath(projectRoot);
+    if (!existsSync(filePath)) {
+        return structuredClone(DEFAULT_PREFERENCES);
+    }
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(filePath, 'utf8'));
+    }
+    catch (err) {
+        throw new Error(`PREFERENCES_JSON_INVALID: failed to parse ${filePath}: ${err.message}`);
+    }
+    if (typeof raw !== 'object' ||
+        raw === null ||
+        raw.schema_version !== PREFERENCES_SCHEMA_VERSION) {
+        throw new Error(`PREFERENCES_SCHEMA_MISMATCH: expected schema_version=${PREFERENCES_SCHEMA_VERSION} in ${filePath}, got ${raw?.schema_version}`);
+    }
+    return mergePreferences(DEFAULT_PREFERENCES, raw);
+}
+export function savePreferences(projectRoot, overrides) {
+    const filePath = preferencesPath(projectRoot);
+    const current = loadPreferences(projectRoot);
+    const merged = mergePreferences(current, overrides);
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, JSON.stringify(merged, null, 2) + '\n', 'utf8');
+    return merged;
+}
+function mergePreferences(base, overrides) {
+    const definedEntries = Object.entries(overrides).filter(([, value]) => value !== undefined);
+    return {
+        ...base,
+        ...Object.fromEntries(definedEntries),
+        schema_version: PREFERENCES_SCHEMA_VERSION,
+    };
+}

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

@@ -0,0 +1,90 @@
+/**
+ * peaks-cli 2.0 project-local preferences schema.
+ * Per spec §8.4 — per-project state lives in `.peaks/preferences.json`,
+ * NOT in `~/.peaks/config.json` (which is slim global).
+ *
+ * Spec reference: docs/superpowers/specs/2026-06-11-peaks-cli-l1-l2-l3-redesign.md §8.4
+ */
+export declare const PREFERENCES_SCHEMA_VERSION = "2.0.0";
+/**
+ * Per-task-level UA install UX prompt decision.
+ * Values:
+ *   - 'unset'              — ask every session (default)
+ *   - 'skip-this-session'  — skip prompt for current session only
+ *   - 'skip-forever'       — never ask, never install
+ */
+export type UaPromptDecision = 'unset' | 'skip-this-session' | 'skip-forever';
+/**
+ * L1a task classification conservatism.
+ * Values:
+ *   - 'default'  — use default signal thresholds
+ *   - 'strict'   — always upgrade to next level (slower, safer)
+ *   - 'lax'      — always downgrade to previous level (faster, riskier)
+ */
+export type ClassifyConservatism = 'default' | 'strict' | 'lax';
+/**
+ * Per-touchpoint headroom-AI mode override.
+ * Spec §7.4 — default 'balanced'.
+ */
+export type HeadroomMode = 'balanced' | 'aggressive' | 'conservative';
+export interface HeadroomPreferences {
+    /** Whether headroom integration is enabled globally. Default: true */
+    readonly enabled: boolean;
+    /** Default mode if a touchpoint doesn't override. Default: 'balanced' */
+    readonly defaultMode: HeadroomMode;
+    /** Per-touchpoint mode overrides */
+    readonly perTouchpoint: {
+        memorySearch: HeadroomMode;
+        retrospectiveSearch: HeadroomMode;
+        doctorScan: HeadroomMode;
+        doctorRoute: HeadroomMode;
+    };
+}
+export interface ClassifyRuleOverrides {
+    /** File count threshold above which a task is promoted to 'feature' */
+    readonly feature_threshold_files?: number;
+    /** Line count threshold above which a task is promoted to 'feature' */
+    readonly feature_threshold_lines?: number;
+    /** Whether to require a 24h grace before cleaning recently-active sessions */
+    readonly runtime_clean_grace_hours?: number;
+}
+export interface SwarmSpeculativePreferences {
+    /** Whether speculative dispatch is enabled. Default: true */
+    readonly enabled: boolean;
+    /** Max concurrent speculative sub-agents. Default: 2 */
+    readonly maxConcurrent: number;
+    /** Min hit rate below which speculative auto-disables. Default: 0.5 */
+    readonly minHitRate: number;
+}
+export interface ProjectPreferences {
+    /**
+     * On-disk schema version. The JSON key is `schema_version` (snake_case) — this matches the
+     * raw on-disk key in `.peaks/preferences.json`, NOT the camelCase used by the rest of this
+     * interface. preferences-service.ts validates this value against PREFERENCES_SCHEMA_VERSION
+     * on load and writes the current value on save. Any mismatch throws PREFERENCES_SCHEMA_MISMATCH.
+     */
+    readonly schema_version: typeof PREFERENCES_SCHEMA_VERSION;
+    readonly economyMode: boolean;
+    readonly swarmMode: boolean;
+    readonly uaPrompt: UaPromptDecision;
+    readonly agentShieldPrompt: UaPromptDecision;
+    readonly classifyConservatism: ClassifyConservatism;
+    readonly classifyRules: ClassifyRuleOverrides;
+    readonly headroom: HeadroomPreferences;
+    readonly swarmSpeculative: SwarmSpeculativePreferences;
+    /** Loop Autonomous (L4 14.5) toggle. Default: false — never auto-enable. */
+    readonly loopAutonomousEnabled: boolean;
+    /**
+     * L2.3 P2-a: ECC AgentShield subprocess toggle. Default: false.
+     *
+     * When true, `peaks audit static` spawns `npx ecc-agentshield scan --json`
+     * and merges its findings into the audit report. When false (default),
+     * the audit runs peaks-cli-only and the subprocess is never spawned.
+     *
+     * The preference is independent of whether ECC is installed — i.e.
+     * `agentShieldEnabled: true` with ECC missing surfaces a soft
+     * "ECC not installed" warning and the audit still completes.
+     */
+    readonly agentShieldEnabled: boolean;
+}
+export declare const DEFAULT_PREFERENCES: ProjectPreferences;

package/dist/src/services/preferences/preferences-types.js

@@ -0,0 +1,38 @@
+/**
+ * peaks-cli 2.0 project-local preferences schema.
+ * Per spec §8.4 — per-project state lives in `.peaks/preferences.json`,
+ * NOT in `~/.peaks/config.json` (which is slim global).
+ *
+ * Spec reference: docs/superpowers/specs/2026-06-11-peaks-cli-l1-l2-l3-redesign.md §8.4
+ */
+export const PREFERENCES_SCHEMA_VERSION = '2.0.0';
+export const DEFAULT_PREFERENCES = {
+    schema_version: PREFERENCES_SCHEMA_VERSION,
+    economyMode: true,
+    swarmMode: true,
+    uaPrompt: 'unset',
+    agentShieldPrompt: 'unset',
+    classifyConservatism: 'default',
+    classifyRules: {
+        feature_threshold_files: 10,
+        feature_threshold_lines: 100,
+        runtime_clean_grace_hours: 24,
+    },
+    headroom: {
+        enabled: true,
+        defaultMode: 'balanced',
+        perTouchpoint: {
+            memorySearch: 'balanced',
+            retrospectiveSearch: 'balanced',
+            doctorScan: 'balanced',
+            doctorRoute: 'conservative',
+        },
+    },
+    swarmSpeculative: {
+        enabled: true,
+        maxConcurrent: 2,
+        minHitRate: 0.5,
+    },
+    loopAutonomousEnabled: false,
+    agentShieldEnabled: false,
+};

package/dist/src/services/recommendations/capability-seed-items.js

@@ -95,7 +95,6 @@ export const seedCapabilityItems = [
     capability('agent-browser.browser-agent', 'agent-browser', 'Agent Browser', 'agent', 'browser-agent', ['engineer', 'qa'], 'medium', 'manual-browser-walkthrough', 'Use screenshots and manual test steps if agent browser is unavailable.', 'Agent Browser', '浏览器代理', 'Supports browser-based validation and interaction planning.', '支持基于浏览器的验证和交互规划。'),
     capability('minimax-skills.worker-guidance', 'minimax-skills', 'MiniMax Worker Guidance', 'skill', 'worker-guidance', ['engineer'], 'medium', 'peaks-worker-contract', 'Use Peaks built-in minimax-worker contract and review handoff.', 'MiniMax Worker Guidance', 'MiniMax Worker 指南', 'Guides MiniMax coding/test worker delegation.', '指导 MiniMax 编码/测试 worker 委托。'),
     capability('claude-mem.memory-persistence', 'claude-mem', 'Claude Memory Persistence', 'skill', 'memory', ['engineer'], 'medium', 'peaks-txt-context-capsule', 'Use peaks-txt context capsules without storing secrets.', 'Memory Persistence', '记忆持久化', 'Persists reusable context when explicitly approved.', '在明确授权时持久化可复用上下文。'),
-    capability('shadcn-ui.component-system', 'shadcn-ui', 'shadcn/ui Component System', 'doc', 'ui-components', ['engineer', 'designer'], 'low', 'project-local-ui-patterns', 'Use existing project components and design tokens.', 'Component System Reference', '组件系统参考', 'Provides component and design-system references for UI planning.', '为 UI 规划提供组件和设计系统参考。'),
     capability('openspec.spec-workflow', 'openspec', 'OpenSpec Workflow', 'workflow', 'spec-workflow', ['product', 'engineer'], 'low', 'peaks-prd-rd-qa-artifacts', 'Use Peaks built-in PRD/RD/QA artifact flow.', 'OpenSpec Workflow', 'OpenSpec 规格流程', 'Supports spec-first product and engineering governance.', '支持规格优先的产品与工程治理。'),
     capability('gitnexus.repo-intelligence', 'gitnexus', 'GitNexus Repository Intelligence', 'cli', 'repo-intelligence', ['engineer'], 'medium', 'local-repo-scan', 'Use local project scanning through Peaks RD.', 'Repository Intelligence', '仓库智能分析', 'Repository intelligence should be proxied through Peaks before use.', '仓库智能分析应先通过 Peaks 代理边界再使用。'),
     capability('claude-code-best-practice.workflow-guidance', 'claude-code-best-practice', 'Claude Code Best Practice', 'doc', 'workflow-guidance', ['engineer'], 'low', 'peaks-built-in-rules', 'Use Peaks built-in workflow and review rules.', 'Claude Code Best Practice', 'Claude Code 最佳实践', 'Guidance for Claude Code engineering workflows.', 'Claude Code 工程工作流指导。'),

package/dist/src/services/recommendations/capability-seed-mappings.js

@@ -33,7 +33,6 @@ export const seedCapabilityLandingMappings = [
     mapping({ capabilityId: 'agent-browser.browser-agent', sourceId: 'agent-browser', sourceGroup: 'mcp-server', landingKind: 'skill', target: 'peaks-qa', skillName: 'peaks-qa', guidance: 'Use for browser validation; never submit forms or mutate authenticated state without explicit permission.' }),
     mapping({ capabilityId: 'minimax-skills.worker-guidance', sourceId: 'minimax-skills', sourceGroup: 'mcp-server', landingKind: 'cli', target: 'peaks minimax-worker', commandPreview: 'peaks minimax-worker --json', guidance: 'Use Peaks worker command only after reviewing inputs; add --confirm manually when explicit external-provider approval exists.' }),
     mapping({ capabilityId: 'claude-mem.memory-persistence', sourceId: 'claude-mem', sourceGroup: 'mcp-server', landingKind: 'skill', target: 'peaks-txt', skillName: 'peaks-txt', guidance: 'Use only with explicit durable-memory consent and never store secrets.' }),
-    mapping({ capabilityId: 'shadcn-ui.component-system', sourceId: 'shadcn-ui', sourceGroup: 'mcp-server', landingKind: 'skill', target: 'peaks-ui', skillName: 'peaks-ui', guidance: 'Use as a component-system reference, not as an unreviewed generated UI default.' }),
     mapping({ capabilityId: 'darwin-skill.external-skill', sourceId: 'darwin-skill', sourceGroup: 'mcp-server', landingKind: 'catalog', target: 'external skill catalog', guidance: 'Catalog only until inspected for project fit and safety.' }),
     mapping({ capabilityId: 'claude-code-best-practice.workflow-guidance', sourceId: 'claude-code-best-practice', sourceGroup: 'mcp-server', landingKind: 'skill', target: 'peaks-rd', skillName: 'peaks-rd', guidance: 'Use as Claude Code workflow reference while preserving Peaks gates.' }),
     mapping({ capabilityId: 'openspec.spec-workflow', sourceId: 'openspec', sourceGroup: 'mcp-server', landingKind: 'skill', target: 'peaks-prd', skillName: 'peaks-prd', guidance: 'Use for spec-first product and engineering artifact structure.' }),

package/dist/src/services/recommendations/capability-seed-sources.js

@@ -17,7 +17,6 @@ export const seedCapabilitySources = [
     { sourceId: 'agent-browser', sourceType: 'repo', sourceGroup: 'mcp-server', title: 'Agent Browser', url: 'https://github.com/vercel-labs/agent-browser', discoveryStatus: 'indexed', items: ['agent-browser.browser-agent'] },
     { sourceId: 'minimax-skills', sourceType: 'skills-package', sourceGroup: 'mcp-server', title: 'MiniMax Skills', url: 'https://github.com/MiniMax-AI/skills', discoveryStatus: 'indexed', items: ['minimax-skills.worker-guidance'] },
     { sourceId: 'claude-mem', sourceType: 'repo', sourceGroup: 'mcp-server', title: 'claude-mem', url: 'https://github.com/thedotmack/claude-mem', discoveryStatus: 'indexed', items: ['claude-mem.memory-persistence'] },
-    { sourceId: 'shadcn-ui', sourceType: 'repo', sourceGroup: 'mcp-server', title: 'shadcn/ui', url: 'https://github.com/shadcn-ui/ui', discoveryStatus: 'indexed', items: ['shadcn-ui.component-system'] },
     { sourceId: 'darwin-skill', sourceType: 'skills-package', sourceGroup: 'mcp-server', title: 'darwin-skill', url: 'https://github.com/alchaincyf/darwin-skill', discoveryStatus: 'unscanned', items: ['darwin-skill.external-skill'] },
     { sourceId: 'claude-code-best-practice', sourceType: 'repo', sourceGroup: 'mcp-server', title: 'Claude Code Best Practice', url: 'https://github.com/shanraisshan/claude-code-best-practice', discoveryStatus: 'indexed', items: ['claude-code-best-practice.workflow-guidance'] },
     { sourceId: 'openspec', sourceType: 'repo', sourceGroup: 'mcp-server', title: 'OpenSpec', url: 'https://github.com/Fission-AI/OpenSpec', discoveryStatus: 'indexed', items: ['openspec.spec-workflow'] },

package/dist/src/services/retrospective/retrospective-search-service.d.ts

@@ -0,0 +1,37 @@
+export type { RetrospectiveType, RetrospectiveOutcome, RetrospectiveEntry } from './retrospective-index.js';
+import type { RetrospectiveType, RetrospectiveOutcome } from './retrospective-index.js';
+/**
+ * Input to `searchRetrospective`. `projectRoot` defaults to `process.cwd()`.
+ * `query` is required and non-empty. `type` and `outcome` are optional
+ * structured filters that compose with AND.
+ */
+export interface RetrospectiveSearchInput {
+    query: string;
+    projectRoot?: string;
+    limit?: number;
+    type?: RetrospectiveType;
+    outcome?: RetrospectiveOutcome;
+}
+/**
+ * One hit returned by `searchRetrospective`. The `artifactPaths` are
+ * preserved so the LLM can follow up with `peaks retrospective show
+ * <id>` (or read the artifact directly).
+ */
+export interface RetrospectiveSearchResult {
+    id: string;
+    sessionId: string;
+    type: RetrospectiveType;
+    title: string;
+    summary: string;
+    outcome: RetrospectiveOutcome;
+    artifactPaths: string[];
+    score: number;
+    positions: number[];
+}
+/**
+ * Run the generic fuzzy kernel against the on-disk retrospective index.
+ * Searchable text is `title + " " + summary` per spec §Component Details.
+ * `--type` and `--outcome` filters compose with AND before the kernel
+ * runs (cheaper to filter, then fuzzy on a smaller set).
+ */
+export declare function searchRetrospective(input: RetrospectiveSearchInput): RetrospectiveSearchResult[];

package/dist/src/services/retrospective/retrospective-search-service.js

@@ -0,0 +1,75 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { fuzzyMatchWithKey } from '../fuzzy-matching/fuzzy-match-service.js';
+const DEFAULT_LIMIT = 6;
+/**
+ * Read `.peaks/retrospective/index.json` and return the entries.
+ * Throws structured errors with stable codes that the CLI converts
+ * to the peaks envelope.
+ */
+function readIndex(projectRoot) {
+    const resolvedRoot = resolve(projectRoot);
+    const indexPath = join(resolvedRoot, '.peaks', 'retrospective', 'index.json');
+    if (!existsSync(indexPath)) {
+        const err = new Error(`INDEX_MISSING: retrospective index not found at ${indexPath}`);
+        err.code = 'INDEX_MISSING';
+        throw err;
+    }
+    let raw;
+    try {
+        raw = readFileSync(indexPath, 'utf8');
+    }
+    catch (cause) {
+        const err = new Error(`INDEX_INVALID: failed to read retrospective index at ${indexPath}: ${cause.message}`);
+        err.code = 'INDEX_INVALID';
+        throw err;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (cause) {
+        const err = new Error(`INDEX_INVALID: malformed retrospective index at ${indexPath}: ${cause.message}`);
+        err.code = 'INDEX_INVALID';
+        throw err;
+    }
+    const index = parsed;
+    return Array.isArray(index.entries) ? index.entries : [];
+}
+/**
+ * Run the generic fuzzy kernel against the on-disk retrospective index.
+ * Searchable text is `title + " " + summary` per spec §Component Details.
+ * `--type` and `--outcome` filters compose with AND before the kernel
+ * runs (cheaper to filter, then fuzzy on a smaller set).
+ */
+export function searchRetrospective(input) {
+    if (input.query === '') {
+        const err = new Error('EMPTY_QUERY: searchRetrospective requires a non-empty query (use `peaks retrospective index` to list all)');
+        err.code = 'EMPTY_QUERY';
+        throw err;
+    }
+    const projectRoot = input.projectRoot ?? process.cwd();
+    const limit = input.limit ?? DEFAULT_LIMIT;
+    let candidates = readIndex(projectRoot);
+    if (input.type !== undefined) {
+        candidates = candidates.filter((e) => e.type === input.type);
+    }
+    if (input.outcome !== undefined) {
+        candidates = candidates.filter((e) => e.outcome === input.outcome);
+    }
+    const matches = fuzzyMatchWithKey(input.query, candidates, { keyFn: (e) => `${e.title} ${e.summary}`, limit, caseSensitive: false });
+    return matches.map((m) => {
+        const entry = m.item;
+        return {
+            id: entry.id,
+            sessionId: entry.sessionId,
+            type: entry.type,
+            title: entry.title,
+            summary: entry.summary,
+            outcome: entry.outcome,
+            artifactPaths: entry.artifactPaths,
+            score: m.score,
+            positions: m.positions,
+        };
+    });
+}

package/dist/src/services/skills/skill-conformance-service.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Skill-conformance audit (Slice #12) — checks every peaks-* SKILL.md
+ * against the 5 standards from the L1+L2+L3 redesign §5.4 Slice #12:
+ *
+ *   1. task-level frontmatter (all 12 skills must declare one)
+ *   2. CLI-back 注解 coverage (each skill body must document which
+ *      `peaks <cmd>` commands it composes; the absence is a SKILL.md
+ *      anti-pattern — it means the LLM has to discover the CLI
+ *      primitives by accident)
+ *   3. loadStrategy on-demand 标注 (skills should declare when they
+ *      load — `eager` for always-loaded, `on-demand` for invoked)
+ *   4. 800-line cap (Karpathy limit per spec §2.3)
+ *   5. outputStyle: peaks-concise-v1 frontmatter (peak-cli display
+ *      style for the skill's user-visible output)
+ *
+ * Plus 1 derived check:
+ *   6. CLI primitives declared in references/audit/ (Skill must
+ *      surface every peaks <cmd> it composes in the references/ subdir;
+ *      this is the "CLI-back 注解 100% 覆盖" check)
+ */
+export type LoadStrategy = 'eager' | 'on-demand';
+export type ConformanceLevel = 'pass' | 'warn' | 'fail';
+export interface ConformanceCheck {
+    readonly id: string;
+    readonly skill: string;
+    readonly level: ConformanceLevel;
+    readonly message: string;
+}
+export interface ConformanceReport {
+    readonly checked: number;
+    readonly passed: number;
+    readonly warned: number;
+    readonly failed: number;
+    readonly checks: readonly ConformanceCheck[];
+    readonly summary: string;
+}
+export interface SkillConformanceInput {
+    readonly projectRoot: string;
+}
+export declare function auditSkillConformance(input: SkillConformanceInput): ConformanceReport;