peaks-cli 1.4.0 → 1.4.2

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/standards/project-context.d.ts

@@ -1,6 +1,6 @@
 export type BuildTool = 'umi' | 'next' | 'vite' | 'rsbuild' | 'rspack' | 'farm' | 'craco' | 'webpack' | 'gulp' | 'angular' | 'custom' | 'unknown';
 export type ComponentLibrary = {
-    readonly name: 'antd' | 'antd-pro' | 'mui' | 'shadcn' | 'element-plus' | 'element-ui' | 'arco' | 'tdesign' | 'semi' | 'nextui' | 'chakra' | 'vant' | 'none';
+    readonly name: 'antd' | 'antd-pro' | 'mui' | 'element-plus' | 'element-ui' | 'arco' | 'tdesign' | 'semi' | 'nextui' | 'chakra' | 'vant' | 'none';
     readonly majorVersion?: string;
     readonly hasProSuite?: boolean;
 };

package/dist/src/services/standards/project-context.js

@@ -64,8 +64,6 @@ function detectComponentLibrary(deps) {
     }
     if ('@mui/material' in deps)
         return { name: 'mui', ...(majorOf(deps['@mui/material']) !== undefined ? { majorVersion: majorOf(deps['@mui/material']) } : {}) };
-    if ('tailwindcss' in deps && Object.keys(deps).some((d) => d.startsWith('@radix-ui/')))
-        return { name: 'shadcn' };
     if ('element-plus' in deps)
         return { name: 'element-plus' };
     if ('element-ui' in deps)
@@ -279,8 +277,6 @@ export function componentLibraryLabel(lib) {
                 return 'Ant Design + Ant Design Pro';
             case 'mui':
                 return 'Material UI';
-            case 'shadcn':
-                return 'shadcn/ui (Tailwind + Radix)';
             case 'element-plus':
                 return 'Element Plus';
             case 'element-ui':

package/dist/src/services/standards/project-standards-service.js

@@ -159,8 +159,6 @@ function renderCommonCodingStyle(ctx) {
     }
     if (lib === 'mui')
         stackRules.push('- Style MUI via `sx`, `styled()`, and `theme`. Do NOT apply TailwindCSS utility classes directly to MUI components.');
-    if (lib === 'shadcn')
-        stackRules.push('- Use existing shadcn component variants and Tailwind utility classes. Do not introduce a competing component library.');
     if (ctx.cssFrameworks.includes('tailwind') && (lib === 'antd' || lib === 'antd-pro' || lib === 'mui')) {
         stackRules.push('- TailwindCSS is for layout/utility only; component-library tokens own component styling.');
     }
@@ -185,7 +183,7 @@ function renderCodeReview(ctx) {
     const extra = [];
     const lib = ctx.componentLibrary.name;
     if (lib === 'antd' || lib === 'antd-pro') {
-        extra.push('- Block PRs that introduce a second component library (MUI/shadcn/Chakra) alongside antd.');
+        extra.push('- Block PRs that introduce a second component library (MUI/Chakra) alongside antd.');
         extra.push('- Block PRs that import antd v3/v4 APIs in this v5 project, or vice versa.');
     }
     if (ctx.cssFrameworks.includes('tailwind') && (lib === 'antd' || lib === 'antd-pro' || lib === 'mui')) {

package/dist/src/services/workspace/migrate-1-4-1-service.d.ts

@@ -0,0 +1,44 @@
+/**
+ * `peaks workspace migrate-1-4-1` — R004.
+ *
+ * Cleanup command for projects upgraded from peaks-cli 1.4.1 → 1.4.2.
+ *
+ * Slice 006 (1.4.0) moved the canonical per-session root to
+ * `.peaks/_runtime/<sid>/`. Per-request artifacts (PRD, RD, QA, SC requests)
+ * were written to the new root, but per-session artifacts (tech-doc.md,
+ * code-review.md, test-cases/<rid>.md, etc.) were kept at the legacy
+ * `.peaks/<sid>/<role>/<file>.md` path. The 2-tier fallback in
+ * `resolvePrerequisiteAbsolutePathWithFallback` accepts either location, so
+ * the functional behavior is correct, but the user's filesystem has visible
+ * dual-path duplication ("飘逸" — the user's term for the UX).
+ *
+ * R004 ships this command to physically move the legacy per-session files
+ * into the canonical `_runtime/<sid>/<role>/` location. After this runs,
+ * the project has a single canonical tree; the legacy `<sid>/<role>/`
+ * directories are removed (only if empty after the move).
+ *
+ * Default: dry-run. Pass `--apply` to actually move.
+ */
+export declare const PER_SESSION_ARTIFACT_TYPES: readonly ["rd/tech-doc.md", "rd/code-review.md", "rd/security-review.md", "rd/perf-baseline.md", "rd/bug-analysis.md", "qa/security-findings.md", "qa/performance-findings.md"];
+export declare const PER_REQUEST_ARTIFACT_TYPES: readonly ["qa/test-cases/<rid>.md", "qa/test-reports/<rid>.md"];
+export type MigrationPlanEntry = {
+    readonly sessionId: string;
+    readonly relativePath: string;
+    readonly from: string;
+    readonly to: string;
+    readonly sha256: string;
+    readonly reason: 'legacy-only' | 'identical-content-already-canonical' | 'content-mismatch' | 'no-legacy-file';
+};
+export type MigrationResult = {
+    readonly plan: ReadonlyArray<MigrationPlanEntry>;
+    readonly applied: boolean;
+    readonly movedCount: number;
+    readonly conflictCount: number;
+    readonly deletedEmptyDirs: ReadonlyArray<string>;
+    readonly errors: ReadonlyArray<{
+        path: string;
+        message: string;
+    }>;
+};
+export declare function planMigrate1_4_1(projectRoot: string): MigrationResult;
+export declare function applyMigrate1_4_1(projectRoot: string): MigrationResult;

package/dist/src/services/workspace/migrate-1-4-1-service.js

@@ -0,0 +1,195 @@
+/**
+ * `peaks workspace migrate-1-4-1` — R004.
+ *
+ * Cleanup command for projects upgraded from peaks-cli 1.4.1 → 1.4.2.
+ *
+ * Slice 006 (1.4.0) moved the canonical per-session root to
+ * `.peaks/_runtime/<sid>/`. Per-request artifacts (PRD, RD, QA, SC requests)
+ * were written to the new root, but per-session artifacts (tech-doc.md,
+ * code-review.md, test-cases/<rid>.md, etc.) were kept at the legacy
+ * `.peaks/<sid>/<role>/<file>.md` path. The 2-tier fallback in
+ * `resolvePrerequisiteAbsolutePathWithFallback` accepts either location, so
+ * the functional behavior is correct, but the user's filesystem has visible
+ * dual-path duplication ("飘逸" — the user's term for the UX).
+ *
+ * R004 ships this command to physically move the legacy per-session files
+ * into the canonical `_runtime/<sid>/<role>/` location. After this runs,
+ * the project has a single canonical tree; the legacy `<sid>/<role>/`
+ * directories are removed (only if empty after the move).
+ *
+ * Default: dry-run. Pass `--apply` to actually move.
+ */
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+export const PER_SESSION_ARTIFACT_TYPES = [
+    'rd/tech-doc.md',
+    'rd/code-review.md',
+    'rd/security-review.md',
+    'rd/perf-baseline.md',
+    'rd/bug-analysis.md',
+    'qa/security-findings.md',
+    'qa/performance-findings.md',
+];
+export const PER_REQUEST_ARTIFACT_TYPES = [
+    'qa/test-cases/<rid>.md',
+    'qa/test-reports/<rid>.md',
+];
+import { createHash } from 'node:crypto';
+function sha256(content) {
+    return createHash('sha256').update(content).digest('hex');
+}
+function enumerateLegacySessions(projectRoot) {
+    // Legacy per-session dirs: `.peaks/<sid>/` (NOT `.peaks/_runtime/<sid>/`).
+    // We skip well-known non-session entries.
+    const SKIP = new Set(['memory', 'PROJECT.md', 'retrospective', 'scope', '.peaks-init-hooks-decision.json', 'session.json', '.session.json', '_runtime', '_sub_agents', 'change', 'caller', 'callers', 'sop-state', 'system', 'active-skill.json', '.active-skill.json']);
+    const peaksRoot = join(projectRoot, '.peaks');
+    if (!existsSync(peaksRoot))
+        return [];
+    const out = [];
+    for (const entry of readdirSync(peaksRoot)) {
+        if (SKIP.has(entry))
+            continue;
+        if (entry.startsWith('.'))
+            continue;
+        // Treat any directory under .peaks/ that doesn't match a known non-session
+        // directory as a candidate session id. The session id is a dated prefix.
+        if (entry.match(/^\d{4}-\d{2}-\d{2}-session-/))
+            out.push(entry);
+    }
+    return out;
+}
+function listRequestIdsForSession(legacySessionRoot) {
+    // Per-request artifacts use file id like `001-r001.md`. We scan the
+    // requests dir to find existing rids.
+    const ids = new Set();
+    for (const role of ['prd', 'rd', 'qa', 'sc']) {
+        const dir = join(legacySessionRoot, role, 'requests');
+        if (!existsSync(dir))
+            continue;
+        for (const f of readdirSync(dir)) {
+            const m = f.match(/^\d+-(r\d+)\.md$/);
+            if (m && m[1])
+                ids.add(m[1]);
+        }
+    }
+    return [...ids];
+}
+function buildPlan(projectRoot) {
+    const plan = [];
+    for (const sid of enumerateLegacySessions(projectRoot)) {
+        const legacyRoot = join(projectRoot, '.peaks', sid);
+        const canonicalRoot = join(projectRoot, '.peaks', '_runtime', sid);
+        // Per-session files (no <rid> template).
+        for (const rel of PER_SESSION_ARTIFACT_TYPES) {
+            const from = join(legacyRoot, rel);
+            if (!existsSync(from))
+                continue;
+            const content = readFileSync(from, 'utf8');
+            const hash = sha256(content);
+            const to = join(canonicalRoot, rel);
+            if (existsSync(to)) {
+                const existing = readFileSync(to, 'utf8');
+                if (sha256(existing) === hash) {
+                    plan.push({ sessionId: sid, relativePath: rel, from, to, sha256: hash, reason: 'identical-content-already-canonical' });
+                }
+                else {
+                    plan.push({ sessionId: sid, relativePath: rel, from, to, sha256: hash, reason: 'content-mismatch' });
+                }
+            }
+            else {
+                plan.push({ sessionId: sid, relativePath: rel, from, to, sha256: hash, reason: 'legacy-only' });
+            }
+        }
+        // Per-request files (with <rid> template).
+        const rids = listRequestIdsForSession(legacyRoot);
+        for (const rel of PER_REQUEST_ARTIFACT_TYPES) {
+            for (const rid of rids) {
+                const expanded = rel.replace('<rid>', rid);
+                const from = join(legacyRoot, expanded);
+                if (!existsSync(from))
+                    continue;
+                const content = readFileSync(from, 'utf8');
+                const hash = sha256(content);
+                const to = join(canonicalRoot, expanded);
+                if (existsSync(to)) {
+                    const existing = readFileSync(to, 'utf8');
+                    if (sha256(existing) === hash) {
+                        plan.push({ sessionId: sid, relativePath: expanded, from, to, sha256: hash, reason: 'identical-content-already-canonical' });
+                    }
+                    else {
+                        plan.push({ sessionId: sid, relativePath: expanded, from, to, sha256: hash, reason: 'content-mismatch' });
+                    }
+                }
+                else {
+                    plan.push({ sessionId: sid, relativePath: expanded, from, to, sha256: hash, reason: 'legacy-only' });
+                }
+            }
+        }
+    }
+    return plan;
+}
+export function planMigrate1_4_1(projectRoot) {
+    const plan = buildPlan(projectRoot);
+    return {
+        plan,
+        applied: false,
+        movedCount: 0,
+        conflictCount: plan.filter((p) => p.reason === 'content-mismatch').length,
+        deletedEmptyDirs: [],
+        errors: [],
+    };
+}
+export function applyMigrate1_4_1(projectRoot) {
+    const plan = buildPlan(projectRoot);
+    const errors = [];
+    let movedCount = 0;
+    const deletedEmptyDirs = [];
+    const movedFiles = [];
+    for (const entry of plan) {
+        try {
+            if (entry.reason === 'legacy-only') {
+                // Move: ensure target dir exists, then rename.
+                mkdirSync(join(entry.to, '..'), { recursive: true });
+                renameSync(entry.from, entry.to);
+                movedFiles.push(entry.from);
+                movedCount++;
+            }
+            else if (entry.reason === 'identical-content-already-canonical') {
+                // Skip the move but delete the duplicate source.
+                try {
+                    rmSync(entry.from);
+                }
+                catch { /* best-effort */ }
+            }
+            else if (entry.reason === 'content-mismatch') {
+                // Conflict: do NOT delete the source. Mark for manual review.
+                errors.push({ path: entry.from, message: `content mismatch; review manually (target ${entry.to})` });
+            }
+        }
+        catch (err) {
+            errors.push({ path: entry.from, message: err.message });
+        }
+    }
+    // After all moves, clean up legacy session dirs. They're now empty
+    // (all files moved; per-role subdirs are also empty). Force-remove the
+    // entire tree — if any non-empty dir remains it's a pre-existing file
+    // that wasn't part of the migrate plan, which is fine to keep.
+    for (const sid of new Set(plan.map((p) => p.sessionId))) {
+        const legacyRoot = join(projectRoot, '.peaks', sid);
+        try {
+            if (existsSync(legacyRoot)) {
+                rmSync(legacyRoot, { recursive: true, force: true });
+                deletedEmptyDirs.push(legacyRoot);
+            }
+        }
+        catch { /* best-effort */ }
+    }
+    return {
+        plan,
+        applied: true,
+        movedCount,
+        conflictCount: plan.filter((p) => p.reason === 'content-mismatch').length,
+        deletedEmptyDirs,
+        errors,
+    };
+}

package/dist/src/shared/version.d.ts

@@ -1 +1 @@
-export declare const CLI_VERSION = "1.4.0";
+export declare const CLI_VERSION = "1.4.2";

package/dist/src/shared/version.js

@@ -1 +1 @@
-export const CLI_VERSION = "1.4.0";
+export const CLI_VERSION = "1.4.2";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peaks-cli",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "Cross-AI-IDE workflow-gating CLI + skill family (Claude Code shipped, Trae in progress; Codex / Cursor / Qoder / Tongyi Lingma on the roadmap).",
   "author": "SquabbyZ",
   "license": "MIT",
@@ -55,15 +55,11 @@
   },
   "dependencies": {
     "@colbymchenry/codegraph": "0.7.10",
-    "chalk": "^5.6.2",
     "commander": "^12.1.0",
-    "headroom-ai": "0.22.4",
-    "ora": "^8.2.0",
-    "shadcn": "4.7.0",
-    "terminal-kit": "^3.1.2"
+    "fzf": "^0.5.2",
+    "headroom-ai": "0.22.4"
   },
   "devDependencies": {
-    "@types/chalk": "^2.2.4",
     "@types/node": "^22.10.2",
     "@vitest/coverage-v8": "^2.1.8",
     "tsx": "^4.19.2",

package/skills/peaks-solo/SKILL.md

@@ -185,7 +185,7 @@ Five CLI commands harden the workflow against silent skips: `peaks request lint`
 
 ## Peaks-Cli Completion handoff
 
-After final validation, refresh project-local standards via `peaks standards init/update` (never hand-write). Use Peaks-Cli TXT for the compact handoff capsule: mode, validated decisions, artifact paths, standards deltas, open questions, next action. Do NOT call `peaks skill presence:clear --project <repo>` at workflow end (presence remains active for follow-ups).
+After final validation, refresh project-local standards via `peaks standards init/update` (never hand-write). Use Peaks-Cli TXT for the compact handoff capsule: mode, validated decisions, artifact paths, standards deltas, open questions, next action. **Presence management is delegated to the last downstream skill in the workflow** — peaks-solo does not call `peaks skill presence:clear` itself, and does not enforce a "no clear" rule. The downstream skills (peaks-rd, peaks-qa, peaks-txt) each manage their own presence per their respective SKILL.md.
 
 → see `references/completion-handoff.md` for the full handoff + "no auto-exit" rule.
 

package/skills/peaks-solo/references/completion-handoff.md

@@ -8,7 +8,9 @@ Use Peaks-Cli TXT for the compact handoff capsule: mode, validated decisions, ar
 
 ## Workflow completion (no auto-exit)
 
-Do NOT call `peaks skill presence:clear --project <repo>` at workflow end. The presence file and header remain active so the user stays inside the workflow context. The user can continue with follow-up requirements naturally — no need to re-invoke `/peaks-solo`. The header continues to display the active skill and current gate.
+peaks-solo does NOT itself call `peaks skill presence:clear --project <repo>` at workflow end. Presence management is delegated to the last downstream skill in the workflow (peaks-rd, peaks-qa, peaks-txt); each of those skills owns its own presence:clear step per its SKILL.md. peaks-solo only sets presence: it does not unset it.
+
+The user can continue with follow-up requirements naturally — no need to re-invoke `/peaks-solo` to do so. The header continues to display whatever skill is active; the user can `/peaks-solo` again to re-anchor.
 
 Before ending, extract durable memories from this session:
 ```bash

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

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

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

@@ -1,35 +0,0 @@
-import { createShadcnInvocation, executeShadcnInvocation } from '../../services/shadcn/shadcn-service.js';
-import { fail } from '../../shared/result.js';
-import { getErrorMessage, printResult, redactSensitiveErrorMessage } from '../cli-helpers.js';
-function printShadcnFailure(io, error, exitCode = 1) {
-    printResult(io, fail('shadcn', 'SHADCN_COMMAND_FAILED', redactSensitiveErrorMessage(getErrorMessage(error)), {}, ['Check the shadcn command arguments before retrying']), false);
-    process.exitCode = exitCode;
-}
-async function runShadcnCommand(io, args) {
-    try {
-        const invocation = createShadcnInvocation({ args });
-        const result = await executeShadcnInvocation(invocation);
-        const didFail = result.exitCode !== null && result.exitCode !== 0;
-        if (result.stdout.length > 0) {
-            io.stdout((didFail ? redactSensitiveErrorMessage(result.stdout) : result.stdout).trimEnd());
-        }
-        if (result.stderr.length > 0) {
-            io.stderr((didFail ? redactSensitiveErrorMessage(result.stderr) : result.stderr).trimEnd());
-        }
-        if (didFail) {
-            process.exitCode = result.exitCode;
-        }
-    }
-    catch (error) {
-        printShadcnFailure(io, error);
-    }
-}
-export function registerShadcnCommands(program, io) {
-    program
-        .command('shadcn')
-        .description('Run the pinned shadcn CLI bundled with Peaks')
-        .allowUnknownOption(true)
-        .helpOption(false)
-        .argument('<args...>', 'arguments forwarded to shadcn')
-        .action((args) => runShadcnCommand(io, args));
-}

package/dist/src/cli/commands/skill-scope-commands.d.ts

@@ -1,49 +0,0 @@
-/**
- * `peaks skill scope` CLI surface (slice 025.1).
- *
- * Four subcommands (mutually exclusive):
- * - `--detect` — dry-run; prints the relevance matrix, never touches files.
- * - `--apply`  — writes the source-of-truth + IDE-native config.
- * - `--show`   — reads the source-of-truth + native config back.
- * - `--reset`  — removes the source-of-truth + IDE-native config.
- *
- * Exit code matrix (tech-doc §6.3):
- *   0  success
- *   1  uncaught error
- *   2  invalid usage (missing/incompatible flags)
- *   3  source-of-truth written but adapter returned NOT_SUPPORTED
- *   4  adapter failure other than NOT_SUPPORTED
- */
-import { Command } from 'commander';
-import { type ResultEnvelope } from '../../shared/result.js';
-import { type ProgramIO } from '../cli-helpers.js';
-export type SkillScopeAction = 'detect' | 'apply' | 'show' | 'reset';
-export interface RunSkillScopeInput {
-    readonly subcommand: SkillScopeAction;
-    readonly project: string;
-    readonly strict?: boolean;
-    readonly loose?: boolean;
-    readonly ide?: string;
-    readonly shadowFallback?: boolean;
-    readonly json?: boolean;
-    /** Test seam: override the detected allowlist (CLI re-adds peaks-* per G6). */
-    readonly overrideAllowlist?: readonly string[];
-    /** Test seam: force the source-of-truth write to fail (simulates atomicity test). */
-    readonly simulateSourceOfTruthWriteFailure?: boolean;
-}
-export interface RunSkillScopeResult {
-    readonly exitCode: number;
-    readonly envelope: ResultEnvelope<unknown> | null;
-    readonly stdout: string;
-    readonly stderr: string;
-}
-/**
- * Programmatic entry point for `peaks skill scope`. Used by the CLI shim
- * AND by the unit tests.
- */
-export declare function runSkillScopeCommand(input: RunSkillScopeInput): Promise<RunSkillScopeResult>;
-/**
- * Register the `peaks skill scope` subcommand on the `skill` command group.
- * Mutually-exclusive flags: exactly one of --detect / --apply / --show / --reset.
- */
-export declare function registerSkillScopeCommands(program: Command, io: ProgramIO): void;