peaks-loop 3.1.2 → 4.0.0-beta.10

package/skills/peaks-status/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: peaks-status
+description: Universal status primitive for any in-flight Peaks-Loop workflow (orchestrator-agnostic). Reads the existing CLI primitives (peaks skill presence, peaks session list, peaks project dashboard, peaks request show) and renders a 1-screen status table. Use when the user asks "where are we", "现在到哪了", "what's the current state" for ANY bee (peaks-code, future peaks-research, …). Triggers on "/peaks-status", "现在到哪了", "what is the current state", "show me the dashboard". (Replaces peaks-status as a top-level primitive.)
+---
+
+# Peaks-Loop Code Status (wrapper)
+
+Peaks-Loop Code Status is a thin wrapper that renders a compact status table for the current peaks-code orchestrator state. It is the answer to "I just want to know where we are" — no PRD, no RD, no QA, no full peaks-code orchestration. Just read the existing CLI state and render a 1-screen summary.
+
+**This is a transparent wrapper.** The user does not stay in this skill — the status table is rendered, and control hands off (back to the user, or to `peaks-code` if the user wants to act on the status).
+
+## Skill presence (MANDATORY first action)
+
+```bash
+peaks skill presence:set peaks-status --project <repo> --mode <mode> --gate startup
+peaks project memories --project <repo> --json  # load durable memory
+```
+
+## Step 1: Read the current state
+
+Use only existing CLI primitives (no new commands). **Important contract note**: `peaks session list` does NOT support `--project` (verified by dogfood 2026-06-04); it returns all sessions globally. To scope to the current project, read `.peaks/.session.json` for the bound `sessionId`, then use `peaks session info <sid>` for the bound session's full state, and filter `peaks session list` output by `projectRoot` to find other sessions in the same project.
+
+```bash
+# 1. Active skill presence
+peaks skill presence --json
+
+# 2. The bound session id (from .peaks/.session.json — local read, no CLI)
+sid=$(cat .peaks/.session.json | python3 -c "import sys,json; print(json.load(sys.stdin)['sessionId'])")
+
+# 3. The bound session's full state
+peaks session info "$sid" --json
+
+# 4. All sessions globally (then post-filter to current project)
+peaks session list --json
+# Note: this returns all sessions across all projects; the wrapper filters by
+# matching `projectRoot` against the bound session's `projectRoot` to show only
+# the sessions for THIS project. Sessions from other projects are ignored.
+
+# 5. Per-request role state (PRD / RD / QA / TXT for the bound project)
+peaks project dashboard --project <repo> --json
+
+# 6. Per-request detail (if a specific rid is in flight)
+peaks request show <rid> --role rd --project <repo> --json
+peaks request show <rid> --role qa --project <repo> --json
+```
+
+All 6 calls are read-only. Total cost: sub-second. (The original draft said "5 calls"; the corrected count is 6 because the post-filter step is now explicit.)
+
+## Step 2: Render the status table
+
+Compact 1-screen format:
+
+```
+=== peaks-code status ===
+Session:   2026-06-04-session-b60252
+Active:    peaks-code (mode: full-auto, gate: qa-validation)
+Workspace: /Users/yuanyuan/.../peaks-loop/.peaks/2026-06-04-session-b60252
+
+| Role | State          | Artifact                |
+|------|----------------|-------------------------|
+| PRD  | handed-off     | prd/requests/003.md     |
+| RD   | qa-handoff     | rd/requests/003.md      |
+| QA   | running        | qa/requests/003.md      |
+| TXT  | (not started)  | -                       |
+
+QA verdict: pending
+Last activity: 2026-06-04T17:00:00.000Z (12 min ago)
+Standards: 5/5 existing (no delta)
+Health: skill-doctor 35/35 pass
+```
+
+If the session is fresh (no in-flight slice), render a different layout:
+
+```
+=== peaks-code status ===
+Session: 2026-06-04-session-b60252
+Active:  peaks-code (mode: full-auto, gate: startup)
+Workspace: /Users/yuanyuan/.../peaks-loop/.peaks/2026-06-04-session-b60252
+
+No in-flight slice. Ready for a new request.
+Health: skill-doctor 35/35 pass
+```
+
+## Step 3: Ask the user what to do next
+
+| Option | What it does |
+|---|---|
+| Continue from the current gate | Hand off to `peaks-code` with the gate already at the current state. Existing artifacts are preserved. |
+| Open a new slice in this session | Keep the workspace, treat the current request as a new slice (new `rid`). |
+| Just summarize and exit | No further action; the user will decide later. |
+
+## Step 4: Hand off (if user picked option 1 or 2)
+
+Re-assert `peaks-code` presence so the status header reads correctly for the rest of the run:
+
+```bash
+peaks skill presence:set peaks-code --project <repo> --mode <mode> --gate <matching-gate>
+```
+
+Then yield control.
+
+## Hard rules (do NOT skip)
+
+- **Never write to `.peaks/_runtime/<sid>/`.** This skill is read-only on the workspace; it only reads existing CLI state.
+- **Never add a new `peaks <cmd>`.** Use only the existing read-only CLI primitives: `peaks skill presence`, `peaks session list`, `peaks session info`, `peaks project dashboard`, `peaks request show`. **Note**: `peaks session list` does not support `--project`; filter its output by `projectRoot` post-hoc.
+- **Never auto-progress the workflow.** The status table is informational only. The user chooses what to do via `AskUserQuestion`. Never silent about what comes next — always present the 3 options.
+- **Never expose sensitive data in the table.** Do NOT include full PRD bodies, full tech-doc bodies, or any test code in the table. Just state names, paths, and counts.
+
+## Anti-patterns (do NOT do)
+
+- Do NOT run `peaks workspace init` on the real session. The wrapper is read-only.
+- Do NOT run `peaks request transition` (would change state). The wrapper is informational only.
+- Do NOT write the status to a file (e.g. `.peaks/_runtime/<sid>/status.md`). The user can see it in the chat; persisting it adds noise to the workspace.
+- Do NOT block on slow CLI calls. The 5 read-only calls are sub-second each. If any takes >5s, fail fast and report the slow command.
+
+## Cross-references
+
+- The "drives a CLI on the user's behalf" pattern (mirror of `peaks-sop`) is the closest existing precedent.
+- `peaks-resume` (P2.1) and `peaks-test` (P2.2) are the sibling wrappers. `peaks-resume` focuses on workflow-state introspection + resume decision; `peaks-status` is the broader 5-CLI snapshot. The two are complementary, not redundant.
+- The "read 5 CLI primitives, render 1 table" pattern is intentionally minimal — the wrapper does NOT add a new status-introspection CLI command (would violate the dev-preference.md "default-no on new CLI" rule).

package/skills/peaks-test/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: peaks-test
+description: Universal test-runner primitive for any in-flight Peaks-Loop workflow (orchestrator-agnostic). Runs the project's test suite on the current repo and reports results. Use when the user asks "run the tests", "跑一下 test", "跑测试" for ANY bee (peaks-code, future peaks-research, …). Triggers on "/peaks-test", "跑一下 test", "跑测试", "run the tests", "test now". (Replaces peaks-test as a top-level primitive.)
+---
+
+# Peaks-Loop Code Test (wrapper)
+
+Peaks-Loop Code Test is a thin wrapper that runs the project's test suite on the current repo and reports results. It is the answer to "I just want to see if the tests pass" — no PRD, no RD, no QA, no full peaks-code orchestration. Just `pnpm vitest run` and a compact summary.
+
+**This is a transparent wrapper.** The user does not stay in this skill — the test command runs, the result is summarized, and control hands off (back to the user, or to `peaks-code` if the user wants to act on the result).
+
+## Skill presence (MANDATORY first action)
+
+```bash
+peaks skill presence:set peaks-test --project <repo> --mode <mode> --gate startup
+peaks project memories --project <repo> --json  # load durable memory
+```
+
+## Step 1: Detect the project's test command
+
+The Peaks-Loop project standard is `pnpm vitest run` (per `vitest.config.ts` + `package.json` scripts). For other project types, check the package.json scripts first. If the user explicitly named a different command (e.g. "跑 `pnpm test` not vitest"), use that.
+
+```bash
+# Default for peaks-loop itself + most TS projects with vitest
+pnpm vitest run
+```
+
+For non-vitest projects (jest, mocha, pytest, etc.), the wrapper respects the project's existing test command. If the user says "run jest" or "run pytest", use that. Do NOT silently default to vitest.
+
+## Step 2: Run the test suite
+
+```bash
+# Run with a reasonable timeout (5 min default; override for slow suites)
+timeout 300 pnpm vitest run 2>&1 | tail -100
+```
+
+Capture both stdout and stderr. If the exit code is 0, tests passed. If non-zero, tests failed or the command errored out.
+
+## Step 3: Summarize the result
+
+Render a compact summary:
+
+- **Test files**: `X passed, Y failed, Z skipped` (from the `Test Files  X passed (Y)` line)
+- **Tests**: `A passed, B failed, C skipped` (from the `Tests  A passed | B skipped (C)` line)
+- **Wall-clock**: the `Duration` line
+- **Failures (if any)**: the first 5-10 failing test names + their failure messages, in priority order (the `FAIL` lines in the test output)
+
+Then ask the user what they want to do next via `AskUserQuestion`:
+
+| Option | What it does |
+|---|---|
+| Show the full failure list | Print all failing test names + messages (not just the first 5-10) |
+| Open a slice to fix the failures | Hand off to `peaks-code` with the failing tests as the slice's "acceptance criteria" |
+| Just summarize and exit | No further action; the user will decide later |
+
+## Step 4: Hand off (if user picked option 2)
+
+Re-assert `peaks-code` presence so the status header reads correctly for the rest of the run:
+
+```bash
+peaks skill presence:set peaks-code --project <repo> --mode <mode> --gate qa-validation
+```
+
+Then yield control. The user's next message will land in `peaks-code` (in QA validation phase, since the failing tests are the validation surface).
+
+## Hard rules (do NOT skip)
+
+- **Never silently fix test failures.** The user must choose what to do via `AskUserQuestion`. Silently "auto-fix"ing a failing test would mask the failure.
+- **Never modify source code in this skill.** This is a wrapper. The actual fix (if the user wants one) is `peaks-code`'s job.
+- **Never add a new `peaks <cmd>`.** Use only existing primitives: `peaks skill presence:set`, `peaks project memories`, `peaks workspace init` (for the handoff), `peaks request transition` (if going to QA-validation). The actual test command is the project's existing test runner, not a `peaks <cmd>`.
+- **Never trust the test runner's exit code as the only signal.** Some failures print partial success (e.g. 100 passed + 1 failed); the wrapper must show the failures, not just say "exit 0".
+
+## Anti-patterns (do NOT do)
+
+- Do NOT run `peaks workspace init` on the real session. The wrapper is read-only on the workspace; it only reads the test results, not the workflow state.
+- Do NOT write to `.peaks/_runtime/<sid>/`. This skill is read-only on the workspace.
+- Do NOT auto-fail the workflow if the tests fail. The user gets a summary + 3 options; the workflow state is unchanged.
+- Do NOT run `pnpm vitest run --watch` or any interactive mode. The wrapper captures the output as a one-shot run; interactive mode would block the orchestrator.
+
+## Cross-references
+
+- The "drives a CLI on the user's behalf" pattern (mirror of `peaks-sop`) is the closest existing precedent.
+- `peaks-resume` (sibling wrapper, P2.1) is the workflow-state introspection variant; `peaks-test` is the test-execution variant.
+- The "harness a project-native test runner" pattern is intentionally minimal — the wrapper should NOT add a new CLI for running tests (would violate the dev-preference.md "default-no on new CLI" rule + the user's explicit ask for "skill-first, CLI-auxiliary").

package/dist/src/cli/cli-helpers.d.ts

@@ -1,25 +0,0 @@
-import { Command } from 'commander';
-import { getErrorMessage, ok, redactSensitiveErrorMessage, type ResultEnvelope } from '../shared/result.js';
-import type { ArtifactProvider, GuidedArtifactSetup } from '../services/artifacts/artifact-service.js';
-import type { ConfigLayer } from '../services/config/config-service.js';
-import type { MiniMaxProviderSmokeResult } from '../services/providers/minimax-provider-service.js';
-import type { MiniMaxWorkerResult } from '../services/providers/minimax-worker-service.js';
-import type { RecommendationWorkflow } from '../services/recommendations/recommendation-service.js';
-export type ProgramIO = {
-    stdout: (text: string) => void;
-    stderr: (text: string) => void;
-};
-export declare function printResult<T>(io: ProgramIO, result: ResultEnvelope<T>, asJson?: boolean): void;
-export declare function addJsonOption(command: Command): Command;
-export declare function failUnsupportedNonDryRun(io: ProgramIO, command: string, asJson?: boolean): void;
-export declare function isRecommendationWorkflow(value: string): value is RecommendationWorkflow;
-export declare function isArtifactProvider(value: string): value is ArtifactProvider;
-export declare function isArtifactSetupStep(value: string): value is GuidedArtifactSetup['step'];
-export declare function isArtifactRepoSegment(value: string): boolean;
-export declare function isMiniMaxHttpsUrl(value: string): boolean;
-export declare function parseConfigLayer(value: string | undefined): ConfigLayer | undefined | null;
-export declare function printInvalidConfigLayer(io: ProgramIO, command: string, asJson?: boolean): void;
-export declare function multipleOption(value: string, previous: string[]): string[];
-export declare function summarizeMiniMaxSmokeResult(result: MiniMaxProviderSmokeResult): MiniMaxProviderSmokeResult;
-export declare function summarizeMiniMaxWorkerResult(result: MiniMaxWorkerResult): MiniMaxWorkerResult;
-export { getErrorMessage, ok, redactSensitiveErrorMessage };

package/dist/src/cli/cli-helpers.js

@@ -1,78 +0,0 @@
-import { fail, getErrorMessage, ok, redactSensitiveErrorMessage } from '../shared/result.js';
-const MINIMAX_API_HOST = 'api.minimaxi.com';
-export function printResult(io, result, asJson = false) {
-    if (asJson) {
-        io.stdout(JSON.stringify(result, null, 2));
-        return;
-    }
-    if (!result.ok) {
-        io.stderr(`${result.code}: ${result.message}`);
-        for (const action of result.nextActions) {
-            io.stderr(`- ${action}`);
-        }
-        return;
-    }
-    io.stdout(JSON.stringify(result.data, null, 2));
-    for (const warning of result.warnings) {
-        io.stderr(`warning: ${warning}`);
-    }
-    for (const action of result.nextActions) {
-        io.stdout(`next: ${action}`);
-    }
-}
-export function addJsonOption(command) {
-    return command.option('--json', 'print machine-readable JSON envelope');
-}
-export function failUnsupportedNonDryRun(io, command, asJson) {
-    printResult(io, fail(command, 'UNSUPPORTED_NON_DRY_RUN', 'Only dry-run planning is supported', {}, ['Rerun with --dry-run or omit --no-dry-run']), asJson);
-    process.exitCode = 1;
-}
-export function isRecommendationWorkflow(value) {
-    return value === 'code-refactor' || value === 'product-refactor' || value === 'frontend-design';
-}
-export function isArtifactProvider(value) {
-    return value === 'github' || value === 'gitlab';
-}
-export function isArtifactSetupStep(value) {
-    return value === 'detect' || value === 'configure' || value === 'validate' || value === 'complete';
-}
-export function isArtifactRepoSegment(value) {
-    return /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(value) && !value.includes('..') && !value.endsWith('.');
-}
-export function isMiniMaxHttpsUrl(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;
-    }
-}
-export function parseConfigLayer(value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    return value === 'user' || value === 'project' ? value : null;
-}
-export function printInvalidConfigLayer(io, command, asJson) {
-    printResult(io, fail(command, 'INVALID_CONFIG_LAYER', 'Config layer must be user or project', {}, ['Use --layer user or --layer project']), asJson);
-    process.exitCode = 1;
-}
-export function multipleOption(value, previous) {
-    return [...(previous || []), value];
-}
-export function summarizeMiniMaxSmokeResult(result) {
-    return { ...result, responseText: null, summary: null };
-}
-export function summarizeMiniMaxWorkerResult(result) {
-    const provider = summarizeMiniMaxSmokeResult(result.provider);
-    return {
-        ...result,
-        provider,
-        reviewHandoff: {
-            model: result.reviewHandoff.model,
-            prompt: '[redacted]'
-        }
-    };
-}
-export { getErrorMessage, ok, redactSensitiveErrorMessage };

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

@@ -1,21 +0,0 @@
-/**
- * peaks context * CLI (Slice #3 L1c) — context 4-layer loader.
- *
- * Per docs/superpowers/specs/2026-06-11-peaks-loop-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

@@ -1,254 +0,0 @@
-/**
- * peaks context * CLI (Slice #3 L1c) — context 4-layer loader.
- *
- * Per docs/superpowers/specs/2026-06-11-peaks-loop-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';
-import { emitObservabilityEvent } from '../../services/observability/observability-service.js';
-import { findProjectRoot } from '../../services/config/config-safety.js';
-import { getSessionIdCanonical } from '../../services/session/session-manager.js';
-import { evaluateMainSessionThreshold, pickMainSessionTrigger, formatMainSessionTriggerLogLine, detectIdeFromEnv } from '../../services/context/main-session-monitor.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;
-        }
-    });
-    addJsonOption(context
-        .command('status')
-        .description('v2.11.0 D6: report main-session threshold tier for a given prompt size (no trigger dispatched). Useful for `--json` probes before invoking `peaks context check --auto-trigger`.')
-        .requiredOption('--prompt-size <bytes>', 'estimated prompt size in bytes')
-        .option('--capacity <bytes>', 'override the 256K default capacity (test seam)', '262144')).action((opts) => {
-        try {
-            const promptSize = Number(opts.promptSize);
-            const capacity = opts.capacity !== undefined ? Number(opts.capacity) : undefined;
-            if (!Number.isFinite(promptSize) || promptSize < 0) {
-                printResult(io, fail('context.status', 'INVALID_PROMPT_SIZE', `prompt-size must be a non-negative number (got "${opts.promptSize}")`, { provided: opts.promptSize }, ['Pass --prompt-size <bytes>']), opts.json);
-                process.exitCode = 1;
-                return;
-            }
-            const evaluation = evaluateMainSessionThreshold(promptSize, capacity);
-            printResult(io, ok('context.status', { ...evaluation, ide: detectIdeFromEnv() }, [...evaluation.warnings], [
-                `Main-session tier=${evaluation.tier} (${(evaluation.ratio * 100).toFixed(0)}%)`
-            ]), opts.json);
-        }
-        catch (err) {
-            printResult(io, fail('context.status', 'CONTEXT_STATUS_FAILED', getErrorMessage(err), null, ['Verify --prompt-size is a non-negative number']), opts.json);
-            process.exitCode = 1;
-        }
-    });
-    addJsonOption(context
-        .command('check')
-        .description('v2.11.0 D6: threshold check + IDE-aware trigger dispatch. With --auto-trigger, returns the trigger path the LLM should follow; without, returns a dry-run recommendation. The LLM is responsible for actually invoking the trigger (slash command, self-compress, or escalation).')
-        .requiredOption('--prompt-size <bytes>', 'estimated prompt size in bytes')
-        .option('--capacity <bytes>', 'override the 256K default capacity (test seam)', '262144')
-        .option('--in-flight-batch', 'a sub-agent batch is in flight (defer trigger per D6.e)', false)
-        .option('--auto-trigger', 'return the trigger path the LLM should follow', false)).action((opts) => {
-        try {
-            const promptSize = Number(opts.promptSize);
-            const capacity = opts.capacity !== undefined ? Number(opts.capacity) : undefined;
-            if (!Number.isFinite(promptSize) || promptSize < 0) {
-                printResult(io, fail('context.check', 'INVALID_PROMPT_SIZE', `prompt-size must be a non-negative number (got "${opts.promptSize}")`, { provided: opts.promptSize }, ['Pass --prompt-size <bytes>']), opts.json);
-                process.exitCode = 1;
-                return;
-            }
-            const trigger = pickMainSessionTrigger({
-                promptSize,
-                capacityBytes: capacity,
-                inFlightBatch: opts.inFlightBatch === true ? { hasInFlightBatch: true, sharedChannelEntries: 1 } : undefined
-            });
-            // Slice C of v2.11.1 — observability hook #5/7. Fire-and-forget
-            // per PRD Q4. The synchronous emit never throws.
-            const projectRoot = findProjectRoot(process.cwd()) ?? process.cwd();
-            const sid = getSessionIdCanonical(projectRoot) ?? '';
-            if (sid.length > 0) {
-                emitObservabilityEvent({
-                    schemaVersion: 1,
-                    ts: new Date().toISOString(),
-                    sessionId: sid,
-                    category: 'context-trigger',
-                    detail: {
-                        kind: trigger.kind,
-                        promptSize,
-                        ...(trigger.kind === 'soft-warn' || trigger.kind === 'compact'
-                            ? { ratio: trigger.ratio }
-                            : {})
-                    }
-                }, { projectRoot });
-            }
-            const logLine = formatMainSessionTriggerLogLine(trigger, 'main');
-            const payload = {
-                ...trigger,
-                autoTrigger: opts.autoTrigger === true,
-                logLine
-            };
-            printResult(io, ok('context.check', payload, [], [
-                trigger.kind === 'compact'
-                    ? `Tier reached → trigger ${trigger.path} on ${trigger.ide} (code=${trigger.code})`
-                    : trigger.kind === 'defer'
-                        ? `Deferred: ${trigger.reason}`
-                        : trigger.kind === 'soft-warn'
-                            ? `Soft warning at ${(trigger.ratio * 100).toFixed(0)}% (no trigger yet)`
-                            : 'Below threshold; no trigger'
-            ]), opts.json);
-        }
-        catch (err) {
-            printResult(io, fail('context.check', 'CONTEXT_CHECK_FAILED', getErrorMessage(err), null, ['Verify --prompt-size is a non-negative number']), opts.json);
-            process.exitCode = 1;
-        }
-    });
-}

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

@@ -1,26 +0,0 @@
-/**
- * `peaks contract` CLI commands — 2.7.0 slice-dag-dispatcher MVP
- * (slice 1.2.c — LLM-side contract writer).
- *
- * Round-2 fix #5 (upgrade placeholder prompt) tells the LLM-side
- * runner to execute `peaks contract write --project <root> ...` to
- * persist its slice's public surface so the orchestrator can splice
- * the contract into downstream dispatch prompts via
- * `formatContractInjection`. This file is the actual implementation
- * of that command — without it, the round-2 prompt would direct the
- * LLM to a CLI that doesn't exist (the round-5 audit caught this).
- *
- * The command is a thin wrapper over `writeContract` from
- * `src/services/dispatch/contract-store.ts`; it accepts the same
- * shape, splits the comma-separated `--exports` / `--types` /
- * `--signatures` flag values into arrays, and surfaces the result
- * via the standard `ok` / `fail` envelope used across peaks-loop.
- *
- * Skill-first / CLI-auxiliary red line: users do not invoke this
- * directly. The peaks-solo / peaks-rd LLM-side runner (the
- * IDE-resident sub-agent that finished a slice) calls this command
- * after the slice completes.
- */
-import { Command } from 'commander';
-import { type ProgramIO } from '../cli-helpers.js';
-export declare function registerContractCommands(program: Command, io: ProgramIO): void;