peaks-loop 4.0.0-beta.6 → 4.0.0-beta.8

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

@@ -1,393 +0,0 @@
-/**
- * peaks evolution * CLI — M4 / spec §4.4 / §6 / §7.4
- *
- * Adds the Darwin-style ratchet CLI surface:
- *
- *   peaks evolution propose --target <kind:id> --dimension <name> \
- *     --before-score <n> --after-score <n> [--delta-min <n>] \
- *     --author <id> [--brief-pointer <path>] [--project <root>] [--json]
- *   peaks evolution evaluate --proposal <id> \
- *     --evaluator <id> --skeptic <id> \
- *     --evaluator-score <n> [--refute-paragraph <text>] \
- *     [--risk-tag <tag>]... [--brief-pointer <path>] [--project <root>] [--json]
- *   peaks evolution revert --proposal <id> [--user-confirmation <ptr>] [--project <root>] [--json]
- *   peaks evolution status [--target <kind:id>] [--project <root>] [--json]
- *
- * Each verb prints a structured JSON envelope (`printResult` with
- * `asJson=true`). The CLI is a thin shim around EvolutionService +
- * the two runner modules. Author / evaluator / skeptic identities
- * are LLM-supplied; the user is NEVER asked to type them.
- *
- * Defense in depth: the EvolutionService enforces the ratchet
- * rules (AC-8 / AC-10 / AC-11); the CLI only translates flags
- * into the service payload.
- */
-import { existsSync, mkdirSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { openStateDb } from "../../services/skillhub/sqlite-store.js";
-import { EvolutionService, EvolutionIntegrityError, } from "../../services/evolution/evolution-service.js";
-import { EVOLUTION_TARGET_KINDS, } from "../../services/evolution/evolution-types.js";
-import { findProjectRoot } from "../../services/config/config-safety.js";
-import { runIndependentEvaluator, } from "../../services/evolution/independent-evaluator-runner.js";
-import { addJsonOption, getErrorMessage, printResult } from "../cli-helpers.js";
-import { fail, ok } from "../../shared/result.js";
-/**
- * Parse `--target <kind:id>`. Returns the kind + id, or `null` on
- * failure. Validates `kind` against the EVOLUTION_TARGET_KINDS
- * union.
- */
-function parseTargetFlag(raw) {
-    const idx = raw.indexOf(":");
-    if (idx <= 0 || idx === raw.length - 1)
-        return null;
-    const kind = raw.slice(0, idx);
-    const id = raw.slice(idx + 1);
-    if (!EVOLUTION_TARGET_KINDS.includes(kind))
-        return null;
-    return { kind: kind, id };
-}
-export function registerEvolutionCommands(program, io) {
-    // Reuse the existing `evolution` parent if one is registered;
-    // otherwise create it. The add-a-new-subcommand-check-for-existing-
-    // top-level-first rule requires this guard.
-    const existing = program.commands.find((c) => c.name() === "evolution");
-    const evolution = existing ?? program.command("evolution").description("Darwin-style ratchet: propose / evaluate / revert / status (spec §6)");
-    // peaks evolution propose
-    addJsonOption(evolution
-        .command("propose")
-        .description("M4: persist a new evolution proposal. Enforces AC-8 (single object + single dimension). The proposal's verdict starts at 'needs-user-decision' until the scoring + skeptic step lands.")
-        .requiredOption("--target <kind:id>", "target asset, e.g. 'loop:loop-onboarding-research' or 'bee:42'")
-        .requiredOption("--dimension <name>", "single optimization dimension (e.g. 'clarity')")
-        .requiredOption("--before-score <n>", "score on the 0..10 scale BEFORE the change")
-        .requiredOption("--after-score <n>", "score on the 0..10 scale AFTER the change (LLM-claimed)")
-        .option("--delta-min <n>", `minimum score delta for promotion (default: 1.0; spec §6.1 #5)`, "1.0")
-        .requiredOption("--author <id>", "author agent id (the LLM proposing the change)")
-        .option("--brief-pointer <ptr>", "pointer to the evidence brief used in the recommendation (spec §4.7 / §4.4)")
-        .option("--project <path>", "project root (default: cwd)")).action((options) => {
-        try {
-            const target = parseTargetFlag(options.target);
-            if (!target) {
-                printResult(io, fail("evolution.propose", "EVOLUTION_INVALID_TARGET", `--target must be '<kind>:<id>' where kind ∈ {${EVOLUTION_TARGET_KINDS.join(",")}}`, { target: options.target }, ["Pass --target loop:<loop-id> or --target bee:<bee-id>."]), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            const before = Number(options.beforeScore);
-            const after = Number(options.afterScore);
-            const deltaMin = Number(options.deltaMin);
-            if (!Number.isFinite(before) || before < 0 || before > 10) {
-                printResult(io, fail("evolution.propose", "EVOLUTION_INVALID_BEFORE_SCORE", `before_score must be a finite number in [0, 10] (got "${options.beforeScore}")`, { beforeScore: options.beforeScore }, ["Pass a numeric --before-score in [0, 10]."]), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            if (!Number.isFinite(after) || after < 0 || after > 10) {
-                printResult(io, fail("evolution.propose", "EVOLUTION_INVALID_AFTER_SCORE", `after_score must be a finite number in [0, 10] (got "${options.afterScore}")`, { afterScore: options.afterScore }, ["Pass a numeric --after-score in [0, 10]."]), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            if (!Number.isFinite(deltaMin) || deltaMin < 0) {
-                printResult(io, fail("evolution.propose", "EVOLUTION_INVALID_DELTA_MIN", `delta_min must be a finite number >= 0 (got "${options.deltaMin}")`, { deltaMin: options.deltaMin }, ["Pass a numeric --delta-min >= 0 (default 1.0)."]), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
-            if (!existsSync(join(projectRoot, ".peaks"))) {
-                // The CLI is allowed to bootstrap an empty .peaks dir so
-                // tests do not need a full peaks project.
-                mkdirSync(join(projectRoot, ".peaks"), { recursive: true });
-            }
-            const db = openStateDb(join(projectRoot, ".peaks", "state.db"));
-            try {
-                const svc = new EvolutionService(db);
-                const input = {
-                    target_kind: target.kind,
-                    target_release_id: target.id,
-                    optimization_dimension: options.dimension,
-                    before_snapshot: {},
-                    after_snapshot: { after_score: after },
-                    diff: {},
-                    before_score: before,
-                    after_score: after,
-                    score_delta_min: deltaMin,
-                    author_id: options.author,
-                    single_object: true,
-                    single_optimization_dimension: true,
-                    rubric: {},
-                    red_lines: [],
-                    source_traces: [],
-                };
-                const proposal = svc.createProposal(input);
-                printResult(io, ok("evolution.propose", {
-                    proposal: {
-                        id: proposal.id,
-                        target_kind: proposal.target_kind,
-                        target_release_id: proposal.target_release_id,
-                        optimization_dimension: proposal.optimization_dimension,
-                        before_score: proposal.before_score,
-                        after_score: proposal.after_score,
-                        score_delta: proposal.score_delta,
-                        score_delta_min: proposal.score_delta_min,
-                        author_id: proposal.author_id,
-                        verdict: "needs-user-decision",
-                        ...(options.briefPointer !== undefined ? { brief_pointer: options.briefPointer } : {}),
-                    },
-                    nextActions: [
-                        `Run \`peaks evolution evaluate --proposal ${proposal.id} --evaluator <id> --skeptic <id> --evaluator-score <n> --json\` to score the proposal.`,
-                    ],
-                }, [], []), options.json);
-            }
-            finally {
-                db.close();
-            }
-        }
-        catch (err) {
-            if (err instanceof EvolutionIntegrityError) {
-                printResult(io, fail("evolution.propose", err.code, err.message, { findings: err.findings }, [
-                    "Re-shape the proposal per spec §6: single object, single dimension, separate scorer.",
-                    "If you intended a multi-object change, split it into multiple rounds.",
-                ]), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            printResult(io, fail("evolution.propose", "EVOLUTION_PROPOSE_FAILED", getErrorMessage(err), {}, [
-                "Verify the target flag and dimension."
-            ]), options.json);
-            process.exitCode = 1;
-        }
-    });
-    // peaks evolution evaluate
-    addJsonOption(evolution
-        .command("evaluate")
-        .description("M4: score a proposal with an independent evaluator (AC-12/AC-13) and a regression skeptic (AC-14). The result is the FINAL verdict: 'keep' (after user confirmation), 'revert' (skeptic blocker or score delta below threshold), or 'needs-user-decision'.")
-        .requiredOption("--proposal <id>", "proposal id returned by `peaks evolution propose`")
-        .requiredOption("--evaluator <id>", "independent scorer id (MUST differ from --author; AC-10)")
-        .requiredOption("--skeptic <id>", "regression skeptic id (MUST differ from --evaluator and --author; AC-12/AC-14)")
-        .requiredOption("--evaluator-score <n>", "the independent scorer's score on the 0..10 scale (LLM-derived; NOT the author's after_score)")
-        .option("--refute-paragraph <text>", "the independent scorer's one-paragraph refute (LLM-authored)", "")
-        .option("--risk-tag <tag>", "add a risk tag emitted by the evaluator (repeatable)", collectRepeatable, [])
-        .option("--brief-pointer <ptr>", "pointer to the evidence brief (spec §4.7 / §4.4)")
-        .option("--project <path>", "project root (default: cwd)")).action(async (options) => {
-        try {
-            const score = Number(options.evaluatorScore);
-            if (!Number.isFinite(score) || score < 0 || score > 10) {
-                printResult(io, fail("evolution.evaluate", "EVOLUTION_INVALID_EVALUATOR_SCORE", `evaluator-score must be a finite number in [0, 10] (got "${options.evaluatorScore}")`, { evaluatorScore: options.evaluatorScore }, ["Pass a numeric --evaluator-score in [0, 10]."]), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
-            if (!existsSync(join(projectRoot, ".peaks"))) {
-                mkdirSync(join(projectRoot, ".peaks"), { recursive: true });
-            }
-            const db = openStateDb(join(projectRoot, ".peaks", "state.db"));
-            try {
-                const svc = new EvolutionService(db);
-                const proposal = svc.read(options.proposal);
-                if (!proposal) {
-                    printResult(io, fail("evolution.evaluate", "EVOLUTION_PROPOSAL_NOT_FOUND", `proposal '${options.proposal}' not found`, { proposalId: options.proposal }, ["Verify the proposal id and that you have run `peaks evolution propose` first."]), options.json);
-                    process.exitCode = 1;
-                    return;
-                }
-                // The CLI runs the deterministic LLM stubs (no live LLM in
-                // M4). Real LLM wiring lands in M5.
-                const evaluatorResult = await runIndependentEvaluator(proposal.proposal);
-                // Force the CLI-supplied --evaluator-score to be the
-                // final score; the LLM stub's score is informational.
-                evaluatorResult.score = score;
-                if (options.refuteParagraph && options.refuteParagraph.length > 0) {
-                    evaluatorResult.refuteParagraph = options.refuteParagraph;
-                }
-                if (Array.isArray(options.riskTag) && options.riskTag.length > 0) {
-                    evaluatorResult.riskTags = [
-                        ...evaluatorResult.riskTags,
-                        ...options.riskTag,
-                    ];
-                }
-                const evaluation = svc.score(options.proposal, {
-                    evaluator_id: options.evaluator,
-                    skeptic_id: options.skeptic,
-                    evaluator_result: evaluatorResult,
-                    skeptic_result: {
-                        driftRisks: [],
-                        overfitRisks: [],
-                        safetyRegressionRisks: [],
-                    },
-                    ...(options.briefPointer !== undefined ? { brief_pointer: options.briefPointer } : {}),
-                });
-                printResult(io, ok("evolution.evaluate", {
-                    proposalId: evaluation.id,
-                    verdict: evaluation.verdict,
-                    evaluator_id: evaluation.evaluator_id,
-                    skeptic_id: evaluation.skeptic_id,
-                    evaluator_result: evaluation.evaluator_result,
-                    skeptic_result: evaluation.skeptic_result,
-                    score_delta: evaluation.proposal.score_delta,
-                    score_delta_min: evaluation.proposal.score_delta_min,
-                    after_score: evaluation.proposal.after_score,
-                    nextActions: evaluation.verdict === "needs-user-decision"
-                        ? [
-                            `User confirmation required. Run \`peaks evolution mark-keep --proposal ${evaluation.id} --user-confirmation <ptr> --json\` after the user picks "keep", OR \`peaks evolution revert --proposal ${evaluation.id} --json\`.`,
-                        ]
-                        : evaluation.verdict === "revert"
-                            ? [
-                                "Proposal reverted. Investigate the skeptic blocker or the score delta below threshold.",
-                            ]
-                            : [
-                                "Proposal kept. The target asset remains unchanged on disk; full promotion lands in a later slice.",
-                            ],
-                }, [], []), options.json);
-                if (evaluation.verdict === "revert")
-                    process.exitCode = 1;
-            }
-            finally {
-                db.close();
-            }
-        }
-        catch (err) {
-            if (err instanceof EvolutionIntegrityError) {
-                printResult(io, fail("evolution.evaluate", err.code, err.message, { findings: err.findings }, [
-                    "Re-shape per spec §6: evaluator and skeptic MUST be separate from the author; the score delta MUST be >= score_delta_min for keep.",
-                ]), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            printResult(io, fail("evolution.evaluate", "EVOLUTION_EVALUATE_FAILED", getErrorMessage(err), { proposalId: options.proposal }, [
-                "Verify the proposal id and the evaluator / skeptic ids.",
-            ]), options.json);
-            process.exitCode = 1;
-        }
-    });
-    // peaks evolution mark-keep — explicit user confirmation.
-    addJsonOption(evolution
-        .command("mark-keep")
-        .description("M4: explicit user-confirmed `keep` verdict. Requires --user-confirmation <ptr> and a score_delta >= score_delta_min (AC-11/AC-15).")
-        .requiredOption("--proposal <id>", "proposal id")
-        .option("--user-confirmation <ptr>", "pointer to the user choice record (AC-15) — omit to surface the EVOLUTION_MISSING_USER_CONFIRMATION service-layer error")
-        .option("--project <path>", "project root (default: cwd)")).action((options) => {
-        try {
-            const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
-            if (!existsSync(join(projectRoot, ".peaks"))) {
-                mkdirSync(join(projectRoot, ".peaks"), { recursive: true });
-            }
-            const db = openStateDb(join(projectRoot, ".peaks", "state.db"));
-            try {
-                const svc = new EvolutionService(db);
-                const updated = svc.markVerdict(options.proposal, "keep", options.userConfirmation);
-                if (!updated) {
-                    printResult(io, fail("evolution.mark-keep", "EVOLUTION_PROPOSAL_NOT_FOUND", `proposal '${options.proposal}' not found`, { proposalId: options.proposal }, ["Verify the proposal id."]), options.json);
-                    process.exitCode = 1;
-                    return;
-                }
-                printResult(io, ok("evolution.mark-keep", {
-                    proposalId: updated.id,
-                    verdict: updated.verdict,
-                    user_confirmation_pointer: updated.user_confirmation_pointer ?? null,
-                    score_delta: updated.proposal.score_delta,
-                    score_delta_min: updated.proposal.score_delta_min,
-                }, [], []), options.json);
-            }
-            finally {
-                db.close();
-            }
-        }
-        catch (err) {
-            if (err instanceof EvolutionIntegrityError) {
-                printResult(io, fail("evolution.mark-keep", err.code, err.message, { findings: err.findings }, [
-                    "Re-shape the proposal or the score so score_delta >= score_delta_min.",
-                ]), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            printResult(io, fail("evolution.mark-keep", "EVOLUTION_MARK_KEEP_FAILED", getErrorMessage(err), { proposalId: options.proposal }, [
-                "Verify the proposal id.",
-            ]), options.json);
-            process.exitCode = 1;
-        }
-    });
-    // peaks evolution revert
-    addJsonOption(evolution
-        .command("revert")
-        .description("M4: revert a proposal (universal recovery; spec §6.1 #8). Always allowed; the user may supply --user-confirmation for audit.")
-        .requiredOption("--proposal <id>", "proposal id")
-        .option("--user-confirmation <ptr>", "optional pointer to the user choice record")
-        .option("--project <path>", "project root (default: cwd)")).action((options) => {
-        try {
-            const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
-            if (!existsSync(join(projectRoot, ".peaks"))) {
-                mkdirSync(join(projectRoot, ".peaks"), { recursive: true });
-            }
-            const db = openStateDb(join(projectRoot, ".peaks", "state.db"));
-            try {
-                const svc = new EvolutionService(db);
-                const updated = svc.revert(options.proposal, options.userConfirmation);
-                if (!updated) {
-                    printResult(io, fail("evolution.revert", "EVOLUTION_PROPOSAL_NOT_FOUND", `proposal '${options.proposal}' not found`, { proposalId: options.proposal }, ["Verify the proposal id."]), options.json);
-                    process.exitCode = 1;
-                    return;
-                }
-                printResult(io, ok("evolution.revert", {
-                    proposalId: updated.id,
-                    verdict: updated.verdict,
-                    user_confirmation_pointer: updated.user_confirmation_pointer ?? null,
-                }, [], []), options.json);
-            }
-            finally {
-                db.close();
-            }
-        }
-        catch (err) {
-            printResult(io, fail("evolution.revert", "EVOLUTION_REVERT_FAILED", getErrorMessage(err), { proposalId: options.proposal }, [
-                "Verify the proposal id.",
-            ]), options.json);
-            process.exitCode = 1;
-        }
-    });
-    // peaks evolution status
-    addJsonOption(evolution
-        .command("status")
-        .description("M4: read the status snapshot for a target (counts of evaluations by verdict + latest evaluation id).")
-        .requiredOption("--target <kind:id>", "target asset, e.g. 'loop:loop-onboarding-research'")
-        .option("--project <path>", "project root (default: cwd)")).action((options) => {
-        try {
-            const target = parseTargetFlag(options.target);
-            if (!target) {
-                printResult(io, fail("evolution.status", "EVOLUTION_INVALID_TARGET", `--target must be '<kind>:<id>' where kind ∈ {${EVOLUTION_TARGET_KINDS.join(",")}}`, { target: options.target }, ["Pass --target loop:<loop-id> or --target bee:<bee-id>."]), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
-            if (!existsSync(join(projectRoot, ".peaks"))) {
-                mkdirSync(join(projectRoot, ".peaks"), { recursive: true });
-            }
-            const db = openStateDb(join(projectRoot, ".peaks", "state.db"));
-            try {
-                const svc = new EvolutionService(db);
-                const status = svc.status({
-                    target_kind: target.kind,
-                    target_release_id: target.id,
-                });
-                printResult(io, ok("evolution.status", status, [], []), options.json);
-            }
-            finally {
-                db.close();
-            }
-        }
-        catch (err) {
-            printResult(io, fail("evolution.status", "EVOLUTION_STATUS_FAILED", getErrorMessage(err), { target: options.target }, [
-                "Verify the target flag.",
-            ]), options.json);
-            process.exitCode = 1;
-        }
-    });
-    // Suppress unused-var warnings for the dirname import; it is
-    // reserved for the M5 path-pointer materialization.
-    void dirname;
-}
-/**
- * Helper: collect repeatable `--risk-tag` values into an array.
- * Commander's `collect` is not always available; we read
- * `previous` from the default value.
- */
-function collectRepeatable(value, previous) {
-    if (Array.isArray(previous))
-        return [...previous, value];
-    return [value];
-}

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

@@ -1,18 +0,0 @@
-/**
- * v2.15.0 slice 002 — AC-3: feedback promotion CLI.
- *
- *   - `peaks feedback promote <memory-file> [--layer A|B|C] [--dry-run]`
- *   - `peaks feedback check-unpromoted --project <path> [--strict]`
- *
- * Companion to `sops/feedback-promotion-sop.md`. The promote command
- * generates a stub for the chosen enforcement layer (A: peaks-sop
- * gate, B: peaks-hooks PreToolUse, C: mode-gate hardFloorCategory)
- * and writes the promotion marker + sidecar + RD envelope. The
- * check-unpromoted command scans `.peaks/memory/*.md` for feedback
- * memories without a promotion marker and emits a structured list.
- * `--strict` flips exit code to non-zero when any unpromoted feedback
- * is found — used by `peaks workflow verify-pipeline` Gate H.
- */
-import type { Command } from 'commander';
-import { type ProgramIO } from '../cli-helpers.js';
-export declare function registerFeedbackCommands(program: Command, io: ProgramIO): void;

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

@@ -1,145 +0,0 @@
-/**
- * v2.15.0 slice 002 — AC-3: feedback promotion CLI.
- *
- *   - `peaks feedback promote <memory-file> [--layer A|B|C] [--dry-run]`
- *   - `peaks feedback check-unpromoted --project <path> [--strict]`
- *
- * Companion to `sops/feedback-promotion-sop.md`. The promote command
- * generates a stub for the chosen enforcement layer (A: peaks-sop
- * gate, B: peaks-hooks PreToolUse, C: mode-gate hardFloorCategory)
- * and writes the promotion marker + sidecar + RD envelope. The
- * check-unpromoted command scans `.peaks/memory/*.md` for feedback
- * memories without a promotion marker and emits a structured list.
- * `--strict` flips exit code to non-zero when any unpromoted feedback
- * is found — used by `peaks workflow verify-pipeline` Gate H.
- */
-import { resolve as resolvePath } from 'node:path';
-import { findProjectRoot } from '../../services/config/config-safety.js';
-import { getCurrentSessionId } from '../../services/skills/skill-presence-service.js';
-import { generatePromotionStub, isPromotionLayer, listUnpromotedFeedback, parseFeedbackMemory, PROMOTION_LAYER_DETAILS, PROMOTION_LAYERS, promoteFeedback } from '../../services/feedback/feedback-promotion-service.js';
-import { fail, ok } from '../../shared/result.js';
-import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
-export function registerFeedbackCommands(program, io) {
-    const feedback = program
-        .command('feedback')
-        .description('v2.15.0 slice 002 AC-3: promote user-given feedback memories to peaks-loop enforcement layers (A: sop, B: hooks, C: hard-floor).');
-    addJsonOption(feedback
-        .command('promote <memory-file>')
-        .description('Promote a feedback memory to one of the 3 enforcement layers (A=peaks-sop gate, B=peaks-hooks PreToolUse, C=mode-gate hardFloorCategory). ' +
-        'Reads `.peaks/memory/<file>.md`, generates a code stub for the chosen layer, and writes ' +
-        'the promotion marker (HTML comment + sidecar .promotion.json) + an RD envelope at ' +
-        '`.peaks/_runtime/<sid>/rd/feedback-promote-<name>.json`. ' +
-        'Without --layer, the CLI lists the 3 layer options as nextActions and exits with code 0 ' +
-        '(use --layer <A|B|C> to actually promote, or pass --dry-run to preview the stub).')
-        .option('--layer <A|B|C>', `enforcement layer (${PROMOTION_LAYERS.join(' | ')})`)
-        .option('--project <path>', 'project root (default: cwd)')
-        .option('--promoted-by <id>', 'identity string for the audit envelope (default: peaks-rd fork agent)')
-        .option('--dry-run', 'preview the stub without writing the marker / sidecar / envelope')).action((memoryFile, opts) => {
-        try {
-            const projectRoot = opts.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
-            const memoryPath = memoryFile.endsWith('.md')
-                ? (memoryFile.startsWith('/') || memoryFile.includes(':'))
-                    ? memoryFile
-                    : resolvePath(projectRoot, memoryFile)
-                : resolvePath(projectRoot, '.peaks', 'memory', `${memoryFile}.md`);
-            const parsed = parseFeedbackMemory(memoryPath);
-            if (parsed === null) {
-                printResult(io, fail('feedback.promote', 'NOT_A_FEEDBACK_MEMORY', `${memoryFile} is not a feedback memory (frontmatter metadata.type must equal "feedback")`, { memoryFile, memoryPath }, [
-                    'Verify the file is at .peaks/memory/<name>.md and its frontmatter has `metadata: { type: feedback }` or `type: feedback`',
-                    'Run `peaks memory list --project <path> --json` to see all known memories and their kinds'
-                ]), opts.json);
-                process.exitCode = 1;
-                return;
-            }
-            if (opts.dryRun === true) {
-                // Preview without choosing a layer: show all three stubs.
-                const previews = PROMOTION_LAYERS.map((layer) => {
-                    const stub = generatePromotionStub({
-                        layer,
-                        feedbackName: parsed.name,
-                        feedbackBody: parsed.body
-                    });
-                    return { layer, ...stub };
-                });
-                printResult(io, ok('feedback.promote', { dryRun: true, name: parsed.name, previews }, [], [
-                    `Preview generated for feedback "${parsed.name}" — 3 layer options shown above.`,
-                    'Re-run with --layer <A|B|C> to apply, or --layer <A|B|C> --dry-run to preview a single layer.'
-                ]), opts.json);
-                return;
-            }
-            if (opts.layer === undefined) {
-                // No --layer: surface the 3 options as nextActions so the
-                // LLM / human can decide. No marker written.
-                printResult(io, ok('feedback.promote', {
-                    name: parsed.name,
-                    layer: null,
-                    options: PROMOTION_LAYER_DETAILS
-                }, [], [
-                    'No --layer passed. Choose one of A / B / C and re-run.',
-                    'A: append to sops/*.md (procedural rules)',
-                    'B: append a matcher to .peaks/.claude-settings-template.json (tool-call interception)',
-                    'C: extend HardFloorCategory in mode-gate.ts (always pauses regardless of mode)',
-                    'Or pass --dry-run to preview all three stubs first.'
-                ]), opts.json);
-                return;
-            }
-            if (!isPromotionLayer(opts.layer)) {
-                printResult(io, fail('feedback.promote', 'INVALID_LAYER', `--layer must be one of ${PROMOTION_LAYERS.join(' | ')} (got "${opts.layer}")`, { provided: opts.layer }, [`Pass --layer ${PROMOTION_LAYERS.join(' | ')}`]), opts.json);
-                process.exitCode = 1;
-                return;
-            }
-            const layer = opts.layer;
-            const sessionId = getCurrentSessionId(projectRoot) ?? 'unknown-sid';
-            const promotedBy = opts.promotedBy ?? 'peaks-rd fork agent';
-            const envelope = promoteFeedback({
-                feedbackPath: memoryPath,
-                layer,
-                promotedBy,
-                sessionId,
-                projectRoot,
-                dryRun: false
-            });
-            printResult(io, ok('feedback.promote', envelope, [], [
-                `Promoted feedback "${envelope.name}" to layer ${envelope.layer} (${envelope.layerDetail}).`,
-                `Generated files: ${envelope.generatedFiles.join(', ')}`,
-                `Envelope written to .peaks/_runtime/${sessionId}/rd/feedback-promote-${envelope.name}.json`
-            ]), opts.json);
-        }
-        catch (err) {
-            printResult(io, fail('feedback.promote', 'PROMOTE_FAILED', getErrorMessage(err), { memoryFile }, ['Verify the file is a feedback memory and re-run']), opts.json);
-            process.exitCode = 1;
-        }
-    });
-    addJsonOption(feedback
-        .command('check-unpromoted')
-        .description('Scan `.peaks/memory/*.md` and list feedback memories without a promotion marker. ' +
-        'Default: dry-run (exit 0, just warn). Pass --strict to fail with exit code 1 when any ' +
-        'unpromoted feedback is found — this is what `peaks workflow verify-pipeline` Gate H uses.')
-        .requiredOption('--project <path>', 'project root')
-        .option('--strict', 'exit non-zero when any unpromoted feedback is found (used by verify-pipeline Gate H)')).action((opts) => {
-        try {
-            const unpromoted = listUnpromotedFeedback({ projectRoot: opts.project });
-            const count = unpromoted.length;
-            if (count === 0) {
-                printResult(io, ok('feedback.check-unpromoted', { count: 0, unpromoted: [] }, [], [`No unpromoted feedback found in .peaks/memory/.`]), opts.json);
-                return;
-            }
-            const message = `${count} feedback memor${count === 1 ? 'y is' : 'ies are'} not yet promoted to an enforcement layer.`;
-            const nextActions = [
-                `Run \`peaks feedback promote <memory-file> --layer <A|B|C>\` for each entry above.`,
-                'A = peaks-sop gate, B = peaks-hooks PreToolUse, C = mode-gate hardFloorCategory.',
-                'See sops/feedback-promotion-sop.md for the SOP and the layer-choice rubric.'
-            ];
-            if (opts.strict === true) {
-                printResult(io, fail('feedback.check-unpromoted', 'UNPROMOTED_FEEDBACK_FOUND', message, { count, unpromoted }, nextActions), opts.json);
-                process.exitCode = 1;
-                return;
-            }
-            printResult(io, ok('feedback.check-unpromoted', { count, unpromoted }, [message], nextActions), opts.json);
-        }
-        catch (err) {
-            printResult(io, fail('feedback.check-unpromoted', 'CHECK_FAILED', getErrorMessage(err), { project: opts.project }, ['Verify --project path and re-run']), opts.json);
-            process.exitCode = 1;
-        }
-    });
-}

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

@@ -1,31 +0,0 @@
-/**
- * W5 Fix M2 — `peaks prepare-final-review <rid>` CLI wrapper.
- *
- * Exposes the `prepareFinalReview()` service (added in W2 T9 on
- * `feature/slice-topology-multipass`) via the CLI surface. The service
- * depends on an injected `LlmRunner`; this slice wires the CLI route
- * with a `stub` provider that returns a structured "scaffold ready"
- * envelope so CI can verify the route without a real LLM. A follow-up
- * slice will bind a real provider. Until then, non-stub providers fail
- * loudly with `LLM_PROVIDER_NOT_IMPLEMENTED` so callers cannot silently
- * no-op.
- *
- * Per the dev-preference "Default-no on new CLI commands" rule and the
- * W4 T14 spec, this is a NEW top-level command (`prepare-final-review`),
- * not a subcommand of `audit`. The two primitives are distinct:
- *   - `peaks audit goal`   — propose a 6-dim goal from a human need
- *   - `peaks prepare-final-review` — produce a 4-dim review evidence
- *                                  pack for human acceptance
- */
-import { Command } from 'commander';
-import { type ProgramIO } from '../cli-helpers.js';
-export type FinalReviewStatus = 'scaffold-only' | 'not-applicable';
-export interface FinalReviewData {
-    readonly status: FinalReviewStatus;
-    readonly rid: string;
-    readonly sessionId: string;
-    readonly auditGoalPath: string;
-    readonly serviceWired: boolean;
-    readonly providerBinding: 'pending-follow-up-slice' | 'unknown';
-}
-export declare function registerFinalReviewCommands(program: Command, io: ProgramIO): void;