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

package/dist/services/audit/static-service.js

@@ -1,130 +1,51 @@
 /**
  * Static audit service — `peaks audit static`.
  *
- * Slice #6 L2.3 P2-a: soft-optional ECC AgentShield integration.
+ * Slice 3 of 4.0.0-beta.11 dropped the ECC AgentShield subprocess
+ * integration entirely. The pre-Slice-3 implementation probed
+ * `npx ecc-agentshield --version` and shelled out to
+ * `npx ecc-agentshield scan --json --target <path>` on every audit
+ * call, but the upstream `affaan-m/everything-claude-code` v2.0.0
+ * release ships no `ecc-agentshield` binary — the repo is
+ * `agents/*.md` flat files plus SKILL.md descriptors.
  *
- * Per spec §5.3, the audit framework integrates with ECC AgentShield
- * (102 lint rules) on a soft-optional basis. When ECC is installed
- * AND `agentShieldEnabled: true`, the audit subprocess spawns the
- * ECC scanner and merges its findings; when either is missing, the
- * audit completes with peaks-loop-only findings.
+ * The new contract: `peaks audit static` runs the peaks-loop lint
+ * layer only. There is no subprocess probe, no `installed` flag,
+ * no agent-shield reason code. The `agentShield` field is preserved
+ * on the result type as a frozen "always disabled" stub so any
+ * downstream consumer keeps compiling, but the merged findings list
+ * is always the peaks-loop findings list (no ECC findings).
  *
- * The subprocess is **observability enhancement**, not a structural
- * gate — every soft-fail path returns a well-formed audit report.
+ * The subprocess-runner seam (`SubprocessRunner`, `defaultSubprocessRunner`)
+ * is preserved as an EXPORTED TYPE so legacy tests can still
+ * mock it; the runner itself is never invoked from production code.
  */
-import { spawnSync } from 'node:child_process';
 import { runRedLinesAudit } from './red-lines-service.js';
 import { loadPreferences } from '../preferences/preferences-service.js';
 import { computeProseRatio } from './prose-ratio-calculator.js';
-const ECC_DETECT_TIMEOUT_MS = 5000;
-const ECC_SCAN_TIMEOUT_MS = 30000;
-const defaultSubprocessRunner = {
-    run(command, args, timeoutMs) {
-        try {
-            const r = spawnSync(command, args, {
-                timeout: timeoutMs,
-                encoding: 'utf8',
-                stdio: ['ignore', 'pipe', 'pipe'],
-                maxBuffer: 16 * 1024 * 1024,
-            });
-            return {
-                status: r.status,
-                stdout: r.stdout ?? '',
-                stderr: r.stderr ?? '',
-            };
-        }
-        catch (err) {
-            return {
-                status: null,
-                stdout: '',
-                stderr: '',
-                error: err,
-            };
-        }
-    },
-};
-function isEccInstalled(runner) {
-    const result = runner.run('npx', ['ecc-agentshield', '--version'], ECC_DETECT_TIMEOUT_MS);
-    if (result.error)
-        return false;
-    return result.status === 0;
-}
-function runEccScan(projectRoot, runner) {
-    try {
-        // Per spec §7.2 line 828: the canonical ECC subprocess call uses
-        // `--target <path>`, NOT `--project`. The peaks-loop CLI flag
-        // (`peaks audit static --project <path>`) follows peaks-loop
-        // convention; the inner ecc-agentshield call follows the
-        // upstream ECC contract.
-        const result = runner.run('npx', ['ecc-agentshield', 'scan', '--json', '--target', projectRoot], ECC_SCAN_TIMEOUT_MS);
-        if (result.error || result.status !== 0)
-            return [];
-        const stdout = result.stdout;
-        let parsed;
-        try {
-            parsed = JSON.parse(stdout);
-        }
-        catch {
-            return [];
-        }
-        if (!parsed.findings)
-            return [];
-        return parsed.findings.map((f, idx) => ({
-            enforcerId: `ecc-agentshield:${f.ruleId ?? `unknown-${idx}`}`,
-            rule: f.rule ?? 'ECC AgentShield rule',
-            severity: f.severity ?? 'warn',
-            file: f.file ?? '(unknown)',
-            detail: f.detail ?? '',
-        }));
-    }
-    catch {
-        return [];
-    }
-}
 export function runStaticAudit(input) {
-    // Read the project-local preferences; the CLI flag overrides.
-    const prefs = loadPreferences(input.projectRoot);
-    const prefEnabled = prefs.agentShieldEnabled;
-    const flagEnabled = input.enableAgentShield;
-    const runner = input.subprocessRunner ?? defaultSubprocessRunner;
-    // Resolve the effective "should spawn" decision.
-    // flagEnabled (CLI override) > preference > false
-    const shouldSpawn = flagEnabled ?? prefEnabled;
-    // Detect ECC.
-    const installed = isEccInstalled(runner);
-    const warnings = [];
-    let state;
-    if (!shouldSpawn) {
-        // Disabled path — no subprocess, no warnings.
-        const reason = flagEnabled === false
-            ? 'flag-disabled'
-            : 'disabled-by-preference';
-        state = { spawned: false, installed, reason, findings: [] };
-    }
-    else if (!installed) {
-        // Enabled but ECC missing — soft-fail with a warning.
-        warnings.push('agentShieldEnabled is true but `npx ecc-agentshield --version` failed. ' +
-            'Run `npx ecc-agentshield --help` to install. Audit ran with peaks-loop findings only.');
-        state = { spawned: false, installed: false, reason: 'flag-enabled-but-ecc-missing', findings: [] };
-    }
-    else {
-        // Enabled and installed — spawn the subprocess.
-        const findings = runEccScan(input.projectRoot, runner);
-        state = { spawned: true, installed: true, reason: 'enabled-and-installed', findings };
-    }
-    // Always run the peaks-loop lint layer; merge ECC findings.
+    // Slice 3: agent-shield integration removed. The CLI flag and
+    // preference are still read for backward-compat (a user with a
+    // stale preferences.json that sets `agentShieldEnabled: true`
+    // does not get a hard error) but neither spawns a subprocess.
+    loadPreferences(input.projectRoot);
+    // Always run the peaks-loop lint layer; no ECC findings merged.
     const peaksResult = runRedLinesAudit({ projectRoot: input.projectRoot });
     const mergedAudit = {
         ...peaksResult.audit,
-        enforcerFindings: [...peaksResult.audit.enforcerFindings, ...state.findings],
+        enforcerFindings: [...peaksResult.audit.enforcerFindings],
+    };
+    const state = {
+        spawned: false,
+        installed: false,
+        reason: 'disabled-and-ecc-missing',
+        findings: [],
     };
-    // v2.14.0 Slice C: compute prose-only ratio with informational
-    // exclusion. Surfaced in the JSON envelope so CI can gate on it.
     const proseRatio = computeProseRatio(mergedAudit.audit);
     return {
         audit: mergedAudit,
         agentShield: state,
-        warnings,
+        warnings: [],
         proseRatio,
     };
 }

package/dist/services/config/config-service.d.ts

@@ -1,4 +1,4 @@
-import type { ConfigGetOptions, ConfigLayer, ConfigSetOptions, ConfigV2, MiniMaxProviderConfig, OcrAuthHeader, OcrConfig, OcrLlmConfig, PeaksConfig, TokenRef, WorkspaceConfig } from './config-types.js';
+import type { ConfigGetOptions, ConfigLayer, ConfigSetOptions, ConfigV2, OcrAuthHeader, OcrConfig, OcrLlmConfig, PeaksConfig, TokenRef, WorkspaceConfig } from './config-types.js';
 export { resolveProjectRootForConfig, resolveCanonicalProjectRoot } from './config-safety.js';
 /**
  * Load the slim 2.0 `~/.peaks/config.json` file. Returns the parsed
@@ -22,17 +22,6 @@ export type RedactedConfigValue = string | number | boolean | null | RedactedCon
     [key: string]: RedactedConfigValue;
 };
 export declare function redactConfigSecrets(value: unknown, path?: string): RedactedConfigValue;
-export type MiniMaxProviderStatus = {
-    provider: 'minimax';
-    configured: boolean;
-    baseUrlConfigured: boolean;
-    apiKeyConfigured: boolean;
-    storage: 'user-plaintext-v1';
-    nextActions: string[];
-};
-export declare function getMiniMaxProviderConfig(): MiniMaxProviderConfig;
-export declare function getMiniMaxProviderStatus(): MiniMaxProviderStatus;
-export declare function setMiniMaxProviderConfig(input: MiniMaxProviderConfig): MiniMaxProviderStatus;
 /**
  * Read the ocr LLM endpoint config from the user-layer
  * `~/.peaks/config.json`. The user populates this themselves by

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

@@ -221,7 +221,6 @@ function sanitizeBaseUrlForDisplay(value) {
         return '[invalid-url-redacted]';
     }
 }
-const MINIMAX_API_HOST = 'api.minimaxi.com';
 function isProviderBaseUrlPath(path) {
     return /^providers\.[^.]+\.baseUrl$/.test(path);
 }
@@ -234,37 +233,11 @@ function isValidProviderBaseUrl(value) {
         return false;
     }
 }
-function isValidMiniMaxBaseUrl(value) {
-    try {
-        const url = new URL(value);
-        return url.protocol === 'https:' && url.hostname === MINIMAX_API_HOST && url.username.length === 0 && url.password.length === 0 && url.search.length === 0 && url.hash.length === 0;
-    }
-    catch {
-        return false;
-    }
-}
-function getMiniMaxBaseUrlCandidate(key, value) {
-    if (key === 'providers.minimax.baseUrl') {
-        return value;
-    }
-    if (key === 'providers.minimax' && value !== null && typeof value === 'object' && !Array.isArray(value)) {
-        return value.baseUrl;
-    }
-    if (key === 'providers' && value !== null && typeof value === 'object' && !Array.isArray(value)) {
-        return value.minimax?.baseUrl;
-    }
-    return undefined;
-}
 function validateProviderBaseUrl(value) {
     if (value !== undefined && (typeof value !== 'string' || !isValidProviderBaseUrl(value))) {
         throw new Error('Provider base URL must be HTTPS without embedded credentials, query, or fragment');
     }
 }
-function validateMiniMaxBaseUrl(value) {
-    if (value !== undefined && (typeof value !== 'string' || !isValidMiniMaxBaseUrl(value))) {
-        throw new Error('MiniMax base URL must be the MiniMax HTTPS endpoint without embedded credentials');
-    }
-}
 function getProxyUrlCandidate(key, value) {
     if (key === 'proxy.httpProxy') {
         return value;
@@ -278,11 +251,8 @@ function isProxyConfigPath(path) {
     return path === 'proxy' || path.startsWith('proxy.');
 }
 function validateModelProviderConfig(providers) {
-    validateMiniMaxBaseUrl(providers.minimax?.baseUrl);
     for (const [providerId, provider] of Object.entries(providers)) {
-        if (providerId !== 'minimax') {
-            validateProviderBaseUrl(provider?.baseUrl);
-        }
+        validateProviderBaseUrl(provider?.baseUrl);
     }
 }
 function validateProviderConfig(partial) {
@@ -363,9 +333,6 @@ function toProviderModelConfig(value) {
         ...(typeof value.apiKey === 'string' ? { apiKey: value.apiKey } : {})
     };
 }
-function toMiniMaxProviderConfig(value) {
-    return toProviderModelConfig(value);
-}
 const TOKEN_CONFIG_KEYS = new Set(['AnthropicApiKey', 'OpenAiApiKey', 'GitHubToken', 'GitLabToken']);
 function toTokenRef(value) {
     if (!isRecord(value))
@@ -445,41 +412,6 @@ export function redactConfigSecrets(value, path = '') {
         return [key, redactConfigSecrets(entry, nextPath)];
     }));
 }
-function createMiniMaxProviderStatus(config) {
-    const baseUrl = config.baseUrl?.trim();
-    const apiKey = config.apiKey?.trim();
-    const baseUrlConfigured = typeof baseUrl === 'string' && baseUrl.length > 0 && isValidMiniMaxBaseUrl(baseUrl);
-    const apiKeyConfigured = typeof apiKey === 'string' && apiKey.length > 0;
-    return {
-        provider: 'minimax',
-        configured: baseUrlConfigured && apiKeyConfigured,
-        baseUrlConfigured,
-        apiKeyConfigured,
-        storage: 'user-plaintext-v1',
-        nextActions: baseUrlConfigured && apiKeyConfigured ? [] : ['Export MINIMAX_API_KEY and rerun peaks config provider minimax set --base-url <url>']
-    };
-}
-export function getMiniMaxProviderConfig() {
-    return toMiniMaxProviderConfig(readUserJsonFile()?.providers?.minimax);
-}
-export function getMiniMaxProviderStatus() {
-    return createMiniMaxProviderStatus(getMiniMaxProviderConfig());
-}
-export function setMiniMaxProviderConfig(input) {
-    validateMiniMaxBaseUrl(input.baseUrl);
-    const userConfig = readUserJsonFile() ?? {};
-    const existingProviders = toModelProviderConfig(userConfig.providers);
-    const providers = {
-        ...existingProviders,
-        minimax: {
-            ...existingProviders.minimax,
-            ...input
-        }
-    };
-    validateMiniMaxBaseUrl(providers.minimax?.baseUrl);
-    writeConfig({ providers }, 'user');
-    return createMiniMaxProviderStatus(providers.minimax ?? {});
-}
 const OCR_AUTH_HEADERS = new Set(['authorization', 'x-api-key', 'bearer']);
 function toOcrLlmConfig(value) {
     if (!isRecord(value))
@@ -552,7 +484,7 @@ function toPeaksConfig(value) {
     return {
         ...(typeof value.version === 'string' ? { version: value.version } : {}),
         ...(typeof value.language === 'string' ? { language: value.language } : {}),
-        ...(typeof value.model === 'string' && ['haiku', 'sonnet', 'opus', 'minimax'].includes(value.model) ? { model: value.model } : {}),
+        ...(typeof value.model === 'string' && ['haiku', 'sonnet', 'opus'].includes(value.model) ? { model: value.model } : {}),
         ...(typeof value.economyMode === 'boolean' ? { economyMode: value.economyMode } : {}),
         ...(typeof value.swarmMode === 'boolean' ? { swarmMode: value.swarmMode } : {}),
         ...(isRecord(value.tokens) ? { tokens: toTokenConfig(value.tokens) } : {}),
@@ -644,11 +576,10 @@ export function setConfig(options) {
     if (layer === 'project' && (isProviderConfigPath(options.key) || isProxyConfigPath(options.key) || isSensitiveConfigPath(options.key) || containsSensitiveConfigValue(options.value))) {
         throw new Error('Sensitive config keys must be stored in the user config layer');
     }
-    validateMiniMaxBaseUrl(getMiniMaxBaseUrlCandidate(options.key, options.value));
     if (options.key === 'providers') {
         validateModelProviderConfig(toModelProviderConfig(options.value));
     }
-    else if (options.key.startsWith('providers.') && !options.key.startsWith('providers.minimax.')) {
+    else if (options.key.startsWith('providers.')) {
         const providerId = getNestedPathParts(options.key)[1];
         if (options.key === `providers.${providerId}`) {
             validateModelProviderConfig({ [providerId]: toProviderModelConfig(options.value) });

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

@@ -1,14 +1,12 @@
-export type ModelPreference = 'haiku' | 'sonnet' | 'opus' | 'minimax';
-export type ModelProviderId = 'minimax' | string;
+export type ModelPreference = 'haiku' | 'sonnet' | 'opus';
+export type ModelProviderId = string;
 export type ExecutionModelId = string;
 export type ProviderModelConfig = {
     model?: ExecutionModelId;
     baseUrl?: string;
     apiKey?: string;
 };
-export type MiniMaxProviderConfig = ProviderModelConfig;
 export type ModelProviderConfig = {
-    minimax?: MiniMaxProviderConfig;
     [providerId: string]: ProviderModelConfig | undefined;
 };
 export type ProxyConfig = {

package/dist/services/context/context-schema.d.ts

@@ -280,8 +280,8 @@ export declare const ContextJsonSchema: z.ZodObject<{
     }>;
 }, "strip", z.ZodTypeAny, {
     version: "1.0";
-    goal: string;
     sha256: string;
+    goal: string;
     generatedAt: string;
     collector: {
         deps: Record<string, {
@@ -347,8 +347,8 @@ export declare const ContextJsonSchema: z.ZodObject<{
     };
 }, {
     version: "1.0";
-    goal: string;
     sha256: string;
+    goal: string;
     generatedAt: string;
     collector: {
         deps: Record<string, {

package/dist/services/job/job-types.d.ts

@@ -190,8 +190,8 @@ export declare const JobStateSchema: z.ZodObject<{
         blockedReason?: string | undefined;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
-    sessionId: string;
     startedAt: string;
+    sessionId: string;
     jobId: string;
     slices: {
         status: "pending" | "skipped" | "done" | "failed" | "blocked" | "in-progress";
@@ -216,8 +216,8 @@ export declare const JobStateSchema: z.ZodObject<{
         to: "single";
     } | undefined;
 }, {
-    sessionId: string;
     startedAt: string;
+    sessionId: string;
     jobId: string;
     slices: {
         status: "pending" | "skipped" | "done" | "failed" | "blocked" | "in-progress";
@@ -344,8 +344,8 @@ export declare const JobInitInputSchema: z.ZodObject<{
     json: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     project: string;
-    sessionId: string;
     json: boolean;
+    sessionId: string;
     jobId: string;
     parallelismHint: "serial" | "llm-decides";
     exitPolicy: "strict" | "best-effort";

package/dist/services/log/retention.d.ts

@@ -32,3 +32,19 @@ export type ApplyRetentionOptions = {
  * process between the `readdir` and the `unlink`).
  */
 export declare function applyRetention(opts?: ApplyRetentionOptions): string[];
+/**
+ * Slice 3 (on-demand-ecc) — 7-day TTL sweep over `~/.peaks/cache/ecc-<sha>/`
+ * directories. Delegates to `cleanupStaleCache` in the ECC cache
+ * service so the retention policy lives next to the cache it
+ * governs.
+ *
+ * Mirrors the `applyRetention` signature for symmetry: tests pass
+ * `nowMs` + `dirOverride`; production callers leave both unset.
+ */
+export declare function cleanupEccCache(options: {
+    retentionDays: number;
+    nowMs?: number;
+    dirOverride?: string;
+}): {
+    removed: string[];
+};

package/dist/services/log/retention.js

@@ -16,6 +16,7 @@
 import { readdirSync, statSync, unlinkSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { resolveLogDir } from './logger.js';
+import { cleanupStaleCache } from '../agent/ecc-cache-service.js';
 const LOG_FILE_NAME_PATTERN = /^peaks-loop-(\d{4}-\d{2}-\d{2})\.log$/;
 function dayDiffUtc(nowUtcMidnightMs, fileDateUtcMs) {
     const dayMs = 24 * 60 * 60 * 1000;
@@ -76,3 +77,19 @@ export function applyRetention(opts = {}) {
     }
     return removed;
 }
+/**
+ * Slice 3 (on-demand-ecc) — 7-day TTL sweep over `~/.peaks/cache/ecc-<sha>/`
+ * directories. Delegates to `cleanupStaleCache` in the ECC cache
+ * service so the retention policy lives next to the cache it
+ * governs.
+ *
+ * Mirrors the `applyRetention` signature for symmetry: tests pass
+ * `nowMs` + `dirOverride`; production callers leave both unset.
+ */
+export function cleanupEccCache(options) {
+    return cleanupStaleCache({
+        retentionDays: options.retentionDays,
+        nowMs: options.nowMs ?? Date.now(),
+        ...(options.dirOverride !== undefined ? { dirOverride: options.dirOverride } : {}),
+    });
+}

package/dist/services/migrate-skill-name/schema.d.ts

@@ -23,16 +23,16 @@ export declare const MigrateResultSchema: z.ZodObject<{
     skipped: z.ZodArray<z.ZodString, "many">;
     errors: z.ZodArray<z.ZodString, "many">;
 }, "strip", z.ZodTypeAny, {
-    ok: boolean;
     skipped: string[];
+    ok: boolean;
     scannedFiles: number;
     modifiedFiles: number;
     keyValueReplacements: number;
     stringReplacements: number;
     errors: string[];
 }, {
-    ok: boolean;
     skipped: string[];
+    ok: boolean;
     scannedFiles: number;
     modifiedFiles: number;
     keyValueReplacements: number;

package/dist/services/rd/rd-service.js

@@ -9,18 +9,17 @@ import { getConfiguredExecutionModelId, getStrongestModelId } from '../config/mo
  * 2.0.1-bug1: the slim 2.0 `~/.peaks/config.json` no longer carries a
  * `providers` block (legacy model config lives in
  * `.peaks/preferences.json` per spec §10.4). `buildPlan` is a pure
- * planner function and historically took its execution model from
- * `DEFAULT_CONFIG.providers.minimax.model`; with the slim default
- * that field is `undefined`, so `getConfiguredExecutionModelId`
- * would throw. We retain the pre-2.0 default here as a literal so
- * the planner remains usable when the caller has not passed an
- * explicit `executionModelId` (unit tests, dry-run previews, the
- * `peaks swarm plan` onboarding path). Production callers that
- * have a real `ocr.llm.model` configured pass it via
- * `request.executionModelId` (or via the legacy preferences.json
- * bridge) and bypass this fallback.
+ * planner function and historically took its execution model from a
+ * legacy provider config; with the slim default that field is
+ * `undefined`, so `getConfiguredExecutionModelId` would throw. We
+ * retain a sensible default here as a literal so the planner remains
+ * usable when the caller has not passed an explicit `executionModelId`
+ * (unit tests, dry-run previews, the `peaks swarm plan` onboarding
+ * path). Production callers that have a real `ocr.llm.model` configured
+ * pass it via `request.executionModelId` (or via the legacy
+ * preferences.json bridge) and bypass this fallback.
  */
-const DEFAULT_EXECUTION_MODEL_ID = 'minimax-2.7';
+const DEFAULT_EXECUTION_MODEL_ID = 'claude-opus-4-7';
 import { getTechStatus, TECH_REQUIRED_ARTIFACTS } from '../tech/tech-service.js';
 import { resolveRdStartupStandardsCheck } from './standards-diagnostic.js';
 import { runStrategicStage } from './strategic-stage.js';

package/dist/services/rd/types.d.ts

@@ -25,8 +25,8 @@ export declare const StrategyOutputSchema: z.ZodObject<{
     }>>;
 }, "strip", z.ZodTypeAny, {
     version: "1.0";
-    goal: string;
     sha256: string;
+    goal: string;
     generatedAt: string;
     rootCauseAnalysis: string;
     impactSurface: string[];
@@ -37,8 +37,8 @@ export declare const StrategyOutputSchema: z.ZodObject<{
     } | undefined;
 }, {
     version: "1.0";
-    goal: string;
     sha256: string;
+    goal: string;
     generatedAt: string;
     rootCauseAnalysis: string;
     impactSurface: string[];

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

@@ -93,7 +93,6 @@ export const seedCapabilityItems = [
     capability('searchcode-mcp.code-search', 'searchcode-mcp', 'SearchCode MCP', 'mcp', 'code-search', ['engineer'], 'medium', 'local-code-search', 'Use local Grep/Glob and ask before sending private code externally.', 'External Code Search', '外部代码搜索', 'Searches code examples or repositories outside the current workspace.', '搜索当前工作区外部的代码示例或仓库。'),
     capability('mysql-mcp.database-inspection', 'mysql-mcp-server', 'MySQL Database Inspection', 'mcp', 'database-inspection', ['engineer'], 'high', 'schema-excerpt-input', 'Ask the user for schema excerpts or sanitized query plans.', 'MySQL Inspection', 'MySQL 检查', 'Inspects MySQL schema and data through an MCP boundary.', '通过 MCP 边界检查 MySQL schema 与数据。'),
     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('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 代理边界再使用。'),

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

@@ -31,7 +31,6 @@ export const seedCapabilityLandingMappings = [
     mapping({ capabilityId: 'impeccable.quality-guidance', sourceId: 'impeccable', sourceGroup: 'mcp-server', landingKind: 'catalog', target: 'quality reference catalog', guidance: 'Use as quality inspiration; Peaks review gates remain authoritative.' }),
     mapping({ capabilityId: 'vercel-agent-skills.skill-pack', sourceId: 'vercel-agent-skills', sourceGroup: 'mcp-server', landingKind: 'catalog', target: 'external skill catalog', guidance: 'Catalog only until individual skills are inspected and approved.' }),
     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: '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.' }),

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

@@ -15,7 +15,6 @@ export const seedCapabilitySources = [
     { sourceId: 'impeccable', sourceType: 'repo', sourceGroup: 'mcp-server', title: 'impeccable', url: 'https://github.com/pbakaus/impeccable', discoveryStatus: 'unscanned', items: ['impeccable.quality-guidance'] },
     { sourceId: 'vercel-agent-skills', sourceType: 'skills-package', sourceGroup: 'mcp-server', title: 'Vercel Agent Skills', url: 'https://github.com/vercel-labs/agent-skills', discoveryStatus: 'unscanned', items: ['vercel-agent-skills.skill-pack'] },
     { 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: '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'] },

package/dist/services/skill/skill-search-service.d.ts

@@ -29,8 +29,10 @@ export declare const SkillSearchInputSchema: z.ZodEffects<z.ZodObject<{
     tag: z.ZodOptional<z.ZodString>;
     domain: z.ZodOptional<z.ZodEnum<["code", "content", "doctor", "research", "triage", "sop", "audit", "final-review", "resume", "status", "test", "ide", "slice-decompose", "issue-fix-orchestrator", "perf-audit", "security-audit", "reviewer"]>>;
     limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    includeInternal: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, "strip", z.ZodTypeAny, {
     limit: number;
+    includeInternal: boolean;
     query?: string | undefined;
     tag?: string | undefined;
     domain?: "code" | "status" | "content" | "test" | "doctor" | "resume" | "ide" | "research" | "triage" | "sop" | "audit" | "final-review" | "slice-decompose" | "issue-fix-orchestrator" | "perf-audit" | "security-audit" | "reviewer" | undefined;
@@ -39,8 +41,10 @@ export declare const SkillSearchInputSchema: z.ZodEffects<z.ZodObject<{
     query?: string | undefined;
     tag?: string | undefined;
     domain?: "code" | "status" | "content" | "test" | "doctor" | "resume" | "ide" | "research" | "triage" | "sop" | "audit" | "final-review" | "slice-decompose" | "issue-fix-orchestrator" | "perf-audit" | "security-audit" | "reviewer" | undefined;
+    includeInternal?: boolean | undefined;
 }>, {
     limit: number;
+    includeInternal: boolean;
     query?: string | undefined;
     tag?: string | undefined;
     domain?: "code" | "status" | "content" | "test" | "doctor" | "resume" | "ide" | "research" | "triage" | "sop" | "audit" | "final-review" | "slice-decompose" | "issue-fix-orchestrator" | "perf-audit" | "security-audit" | "reviewer" | undefined;
@@ -49,6 +53,7 @@ export declare const SkillSearchInputSchema: z.ZodEffects<z.ZodObject<{
     query?: string | undefined;
     tag?: string | undefined;
     domain?: "code" | "status" | "content" | "test" | "doctor" | "resume" | "ide" | "research" | "triage" | "sop" | "audit" | "final-review" | "slice-decompose" | "issue-fix-orchestrator" | "perf-audit" | "security-audit" | "reviewer" | undefined;
+    includeInternal?: boolean | undefined;
 }>;
 export type SkillSearchInput = z.input<typeof SkillSearchInputSchema>;
 export declare const SkillSearchResultSchema: z.ZodObject<{

package/dist/services/skill/skill-search-service.js

@@ -51,7 +51,8 @@ export const SkillSearchInputSchema = z
     query: z.string().min(1).max(500).optional(),
     tag: z.string().min(1).max(100).optional(),
     domain: z.enum(SKILL_DOMAINS).optional(),
-    limit: z.number().int().min(1).max(100).optional().default(20)
+    limit: z.number().int().min(1).max(100).optional().default(20),
+    includeInternal: z.boolean().optional().default(false)
 })
     .refine((v) => v.query !== undefined || v.tag !== undefined || v.domain !== undefined, { message: 'At least one of --query / --tag / --domain is required' });
 export const SkillSearchResultSchema = z.object({
@@ -130,7 +131,8 @@ async function loadEnrichedSkills() {
             triggers: extractTriggers(s.description),
             tags: meta.tags,
             domain: meta.domain,
-            skillPath: s.skillPath
+            skillPath: s.skillPath,
+            ...(s.visibility !== undefined ? { visibility: s.visibility } : {})
         };
     }));
 }
@@ -187,6 +189,8 @@ export async function searchSkills(rawInput) {
     const input = SkillSearchInputSchema.parse(rawInput);
     const skills = await loadEnrichedSkills();
     const filtered = skills.filter((skill) => {
+        if (!input.includeInternal && skill.visibility === 'internal')
+            return false;
         if (input.tag !== undefined) {
             const wanted = input.tag.toLowerCase();
             const has = skill.tags.some((t) => t.toLowerCase() === wanted);

package/dist/services/skills/skill-registry.d.ts

@@ -3,6 +3,7 @@ export type SkillMetadata = {
     description: string;
     directory: string;
     skillPath: string;
+    visibility?: string;
 };
 export type SkillLoadFailure = {
     directory: string;

package/dist/services/skills/skill-registry.js

@@ -31,7 +31,8 @@ export async function loadSkillRegistry(baseDir = skillsDir) {
                         name: frontmatter.name,
                         description: frontmatter.description,
                         directory: subDir,
-                        skillPath
+                        skillPath,
+                        ...(frontmatter.visibility !== undefined ? { visibility: frontmatter.visibility } : {})
                     });
                 }
                 catch (error) {
@@ -50,7 +51,8 @@ export async function loadSkillRegistry(baseDir = skillsDir) {
                 name: frontmatter.name,
                 description: frontmatter.description,
                 directory,
-                skillPath
+                skillPath,
+                ...(frontmatter.visibility !== undefined ? { visibility: frontmatter.visibility } : {})
             });
         }
         catch (error) {