peaks-cli 1.4.1 → 2.0.0

package/dist/src/services/agent/ecc-agent-service.js

@@ -0,0 +1,143 @@
+/**
+ * ECC 64 agents soft-optional integration — `peaks agent run`.
+ *
+ * Per spec §7.2 line 818: "64 agents — Soft Optional — 装了 L3
+ * 直接调; 不装 L3 退化到 peaks-cli 自有少数核心诊断". The
+ * canonical ECC subprocess contract is:
+ *
+ *   npx ecc consult "<topic>" --target claude
+ *   npx ecc agent run <agent-name> --target <path> --json
+ *
+ * The peaks-cli `peaks agent run <name> --target <path> --json`
+ * CLI shells out to the second form. When ECC is missing OR
+ * `agentShieldEnabled: false`, the audit completes with a
+ * peaks-cli-only envelope.
+ *
+ * Mirrors `static-service.ts` (the ECC AgentShield wrapper from
+ * L2.3 P2-a): same `subprocessRunner` injection point, same
+ * 5-state reason enum, same soft-fail policy.
+ */
+import { spawnSync } from 'node:child_process';
+/**
+ * The 12 most-used ECC agents per the upstream
+ * everything-claude-code catalog. The full 64-agent list is
+ * available at runtime via `npx ecc agent list`; this static
+ * subset covers the common L3-doctor dispatch paths.
+ */
+export const CANONICAL_ECC_AGENTS = [
+    { name: 'security-reviewer', description: 'Audit trust boundary + OWASP top-10' },
+    { name: 'code-reviewer', description: 'General-purpose code review' },
+    { name: 'typescript-reviewer', description: 'TypeScript-specific review' },
+    { name: 'python-reviewer', description: 'Python-specific review' },
+    { name: 'golang-reviewer', description: 'Go-specific review' },
+    { name: 'rust-reviewer', description: 'Rust-specific review' },
+    { name: 'java-reviewer', description: 'Java-specific review' },
+    { name: 'cpp-reviewer', description: 'C/C++-specific review' },
+    { name: 'backend-patterns', description: 'Backend service patterns' },
+    { name: 'frontend-patterns', description: 'Frontend patterns' },
+    { name: 'database-migrations', description: 'DB migration safety' },
+    { name: 'deployment-patterns', description: 'Deployment / CI-CD patterns' },
+];
+const ECC_DETECT_TIMEOUT_MS = 5000;
+const ECC_RUN_TIMEOUT_MS = 60000;
+const defaultSubprocessRunner = {
+    run(command, args, timeoutMs) {
+        try {
+            const r = spawnSync(command, args, {
+                timeout: timeoutMs,
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'pipe'],
+                maxBuffer: 16 * 1024 * 1024,
+            });
+            return {
+                status: r.status,
+                stdout: r.stdout ?? '',
+                stderr: r.stderr ?? '',
+            };
+        }
+        catch (err) {
+            return {
+                status: null,
+                stdout: '',
+                stderr: '',
+                error: err,
+            };
+        }
+    },
+};
+function isEccInstalled(runner) {
+    const result = runner.run('npx', ['ecc', '--version'], ECC_DETECT_TIMEOUT_MS);
+    if (result.error)
+        return false;
+    return result.status === 0;
+}
+/**
+ * Validate the agent name against the canonical ECC catalog.
+ * Returns `null` if the agent is known; an error message otherwise.
+ */
+export function validateEccAgent(agent) {
+    if (typeof agent !== 'string' || agent.length === 0) {
+        return 'peaks agent run: agent name must be a non-empty string';
+    }
+    if (!/^[a-z][a-z0-9-]*$/.test(agent)) {
+        return `peaks agent run: agent name "${agent}" is invalid (must match [a-z][a-z0-9-]*)`;
+    }
+    return null;
+}
+export function runEccAgent(input, runner = defaultSubprocessRunner) {
+    const enableAgent = input.enableAgent === true;
+    const warnings = [];
+    let result = null;
+    // Resolve the effective "should spawn" decision.
+    // flagEnabled (CLI override) > preference (always-on for now; L3+ future) > false
+    const shouldSpawn = enableAgent;
+    const installed = isEccInstalled(runner);
+    let reason;
+    let spawned;
+    if (!shouldSpawn) {
+        reason = 'flag-disabled';
+        spawned = false;
+    }
+    else if (!installed) {
+        reason = 'flag-enabled-but-ecc-missing';
+        spawned = false;
+        warnings.push('`npx ecc --version` failed. Run `npx ecc --help` to install ECC, ' +
+            'then re-run `peaks agent run`. The peaks-cli native diagnostic ' +
+            'still runs via `peaks doctor scan`.');
+    }
+    else {
+        reason = 'enabled-and-installed';
+        spawned = true;
+        const start = Date.now();
+        const subResult = runner.run('npx', ['ecc', 'agent', 'run', input.agent, '--target', input.projectRoot, '--json'], ECC_RUN_TIMEOUT_MS);
+        let parsed;
+        let error;
+        if (subResult.error) {
+            error = subResult.error.message;
+        }
+        else if (subResult.status !== 0) {
+            error = `ecc agent run exited with status ${subResult.status}: ${subResult.stderr}`;
+        }
+        else {
+            try {
+                parsed = JSON.parse(subResult.stdout);
+            }
+            catch {
+                // Non-JSON output is allowed; peaks-cli surfaces the raw
+                // stdout for the human reader and treats the run as
+                // ok=true (the subprocess exited 0).
+                parsed = undefined;
+            }
+        }
+        result = {
+            agent: input.agent,
+            ok: error === undefined,
+            stdout: subResult.stdout,
+            stderr: subResult.stderr,
+            durationMs: Date.now() - start,
+            ...(parsed !== undefined ? { parsed } : {}),
+            ...(error !== undefined ? { error } : {}),
+        };
+    }
+    return { agent: input.agent, spawned, reason, result, warnings };
+}

package/dist/src/services/artifacts/request-artifact-service.js

@@ -783,6 +783,20 @@ export async function transitionRequestArtifact(options) {
     if (!prerequisiteResult.ok && options.allowIncomplete !== true) {
         throw new PrerequisitesNotSatisfiedError(options.role, options.newState, existing.sessionId, prerequisiteResult.missing);
     }
+    // L2.1 P0 red line #4: tech-doc-presence. The rd → spec-locked transition
+    // is refused if `rd/tech-doc.md` is missing or empty. This is a machine-
+    // enforced gate that backs the "MANDATORY tech-doc before spec-locked"
+    // prose in the redesign spec §5.4.
+    if (options.role === 'rd' && options.newState === 'spec-locked' && options.allowIncomplete !== true) {
+        const { checkTechDocPresence, TECH_DOC_MISSING_CODE, TECH_DOC_MISSING_MESSAGE } = await import('../audit/enforcers/tech-doc-presence.js');
+        const techDoc = checkTechDocPresence({
+            projectRoot: options.projectRoot,
+            sessionId: existing.sessionId,
+        });
+        if (!techDoc.exists || techDoc.isEmpty) {
+            throw new PrerequisitesNotSatisfiedError(options.role, options.newState, existing.sessionId, [{ path: techDoc.path, description: `${TECH_DOC_MISSING_CODE}: ${TECH_DOC_MISSING_MESSAGE}` }]);
+        }
+    }
     // Type sanity check for PRD handoff
     if (options.typeSanityCheck !== undefined && options.role === 'prd' && options.newState === 'handed-off') {
         const sanityReport = checkTypeSanity({

package/dist/src/services/audit/backing-detector.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Backing detector — classifies each red line as `cli-backed`, `partial`,
+ * or `prose-only`. The classifier already sets the backing for catalog hits
+ * (cli-backed when an enforcer file path is present). This module exists to
+ * handle the post-classification nuance: heuristics for the "partial" tier
+ * (a gate exists but the LLM can bypass it) and verification that the
+ * enforcer file actually exists on disk.
+ */
+import type { RedLineEntry } from './types.js';
+export interface BackingResult {
+    readonly entry: RedLineEntry;
+    readonly enforcerExists: boolean;
+}
+/**
+ * Re-classify a single RedLineEntry. Returns a new entry with the
+ * `backing` field updated and `enforcerRef` possibly nulled if the
+ * referenced file does not exist on disk.
+ */
+export declare function classifyBacking(entry: RedLineEntry, projectRoot: string): BackingResult;
+export interface BackingBatchResult {
+    readonly entries: readonly RedLineEntry[];
+    readonly warnings: readonly string[];
+}
+export declare function classifyBackingBatch(entries: readonly RedLineEntry[], projectRoot: string): BackingBatchResult;

package/dist/src/services/audit/backing-detector.js

@@ -0,0 +1,59 @@
+/**
+ * Backing detector — classifies each red line as `cli-backed`, `partial`,
+ * or `prose-only`. The classifier already sets the backing for catalog hits
+ * (cli-backed when an enforcer file path is present). This module exists to
+ * handle the post-classification nuance: heuristics for the "partial" tier
+ * (a gate exists but the LLM can bypass it) and verification that the
+ * enforcer file actually exists on disk.
+ */
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+const PARTIAL_PHRASES = [
+    'if llm cooperates',
+    'llm-cooperation',
+    'partial cli backing',
+    'best effort',
+    'advisory only',
+    'soft enforcement',
+    'when remembered',
+];
+function detectPartial(context) {
+    const lower = context.toLowerCase();
+    return PARTIAL_PHRASES.some((phrase) => lower.includes(phrase));
+}
+/**
+ * Re-classify a single RedLineEntry. Returns a new entry with the
+ * `backing` field updated and `enforcerRef` possibly nulled if the
+ * referenced file does not exist on disk.
+ */
+export function classifyBacking(entry, projectRoot) {
+    if (detectPartial(entry.source.context)) {
+        return {
+            entry: { ...entry, backing: 'partial' },
+            enforcerExists: entry.enforcerRef !== null && existsSync(resolve(projectRoot, entry.enforcerRef)),
+        };
+    }
+    if (entry.enforcerRef === null) {
+        return { entry, enforcerExists: false };
+    }
+    const enforcerPath = resolve(projectRoot, entry.enforcerRef);
+    const exists = existsSync(enforcerPath);
+    return {
+        entry: { ...entry, backing: exists ? 'cli-backed' : 'prose-only' },
+        enforcerExists: exists,
+    };
+}
+export function classifyBackingBatch(entries, projectRoot) {
+    const updated = [];
+    const warnings = [];
+    for (const entry of entries) {
+        const { entry: reclassified, enforcerExists } = classifyBacking(entry, projectRoot);
+        updated.push(reclassified);
+        if (reclassified.backing === 'cli-backed' && !enforcerExists) {
+            // Defensive: should not happen because classifyBacking downgrades to
+            // prose-only, but keep the assertion in case of future drift.
+            warnings.push(`enforcer ref "${reclassified.enforcerRef}" missing on disk for ${reclassified.id}`);
+        }
+    }
+    return { entries: updated, warnings };
+}

package/dist/src/services/audit/classifier.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Red-line classifier — turns raw markdown lines into RedLineEntry.
+ *
+ * Algorithm: for each MarkdownLine, check whether the line text contains one
+ * of the four red-line markers (MANDATORY / BLOCKING / MUST NOT / RED LINE).
+ * On a hit, extract the surrounding ±2 lines as context, look up the red
+ * line in the catalog, and emit a RedLineEntry. Lines that contain a marker
+ * but match no catalog entry still produce a RedLineEntry (with backing =
+ * prose-only and enforcerRef = null) — those are the "discovered but not yet
+ * enforced" red lines the L2 redesign is working to eliminate.
+ */
+import type { RedLineEntry, RedLineMarker } from './types.js';
+export declare function detectMarker(lineText: string): RedLineMarker | null;
+/**
+ * Derive a human-readable rule name from the marker line. Heuristic: take
+ * the first 8 words of the line, lowercase, trimmed. Catalog matching is
+ * the source of truth for the canonical rule name; this is the fallback
+ * when no catalog entry matches.
+ */
+export declare function deriveRuleName(lineText: string): string;
+export interface ClassifyFileInput {
+    readonly file: string;
+    readonly lines: readonly string[];
+}
+export interface ClassifyResult {
+    readonly entries: readonly RedLineEntry[];
+    readonly warnings: readonly string[];
+}
+/**
+ * Classify a single markdown file. Returns 0+ RedLineEntry; one entry per
+ * marker hit. Marker hits that appear multiple times on the same line are
+ * counted once.
+ */
+export declare function classifyFile(input: ClassifyFileInput): ClassifyResult;
+/**
+ * Batch wrapper — classify each input file and flatten the entries.
+ */
+export declare function classifyFiles(inputs: readonly ClassifyFileInput[]): ClassifyResult;

package/dist/src/services/audit/classifier.js

@@ -0,0 +1,127 @@
+/**
+ * Red-line classifier — turns raw markdown lines into RedLineEntry.
+ *
+ * Algorithm: for each MarkdownLine, check whether the line text contains one
+ * of the four red-line markers (MANDATORY / BLOCKING / MUST NOT / RED LINE).
+ * On a hit, extract the surrounding ±2 lines as context, look up the red
+ * line in the catalog, and emit a RedLineEntry. Lines that contain a marker
+ * but match no catalog entry still produce a RedLineEntry (with backing =
+ * prose-only and enforcerRef = null) — those are the "discovered but not yet
+ * enforced" red lines the L2 redesign is working to eliminate.
+ */
+import { findCatalogEntry } from './red-line-catalog.js';
+const MARKER_PATTERN = /\b(MANDATORY|BLOCKING|MUST NOT|RED LINE)\b/;
+const CONTEXT_LINES_BEFORE = 2;
+const CONTEXT_LINES_AFTER = 2;
+function isMarker(s) {
+    return s === 'MANDATORY' || s === 'BLOCKING' || s === 'MUST NOT' || s === 'RED LINE';
+}
+function extractContext(allLines, hitLine) {
+    const start = Math.max(0, hitLine - CONTEXT_LINES_BEFORE);
+    const end = Math.min(allLines.length, hitLine + 1 + CONTEXT_LINES_AFTER);
+    return allLines.slice(start, end).join('\n');
+}
+/**
+ * Detect markers in a single line of markdown. Returns the marker text found
+ * (uppercased), or null when no marker is present.
+ */
+/**
+ * Case-insensitive marker pattern (used only by detectMarker so callers can
+ * write `MANDATORY` / `mandatory` / `Mandatory` interchangeably in prose).
+ * deriveRuleName uses the all-caps MARKER_PATTERN so it doesn't strip a
+ * mid-sentence "Red Line" reference.
+ */
+const MARKER_PATTERN_CI = /\b(MANDATORY|BLOCKING|MUST NOT|RED LINE)\b/i;
+export function detectMarker(lineText) {
+    const match = MARKER_PATTERN_CI.exec(lineText);
+    if (!match)
+        return null;
+    const raw = (match[1] ?? '').toUpperCase();
+    if (raw === 'MUST') {
+        // "MUST NOT" is two tokens in the regex; the match group only captures
+        // "MUST". Re-verify by checking the next character.
+        const after = lineText[match.index + match[0].length];
+        if (after === undefined || /\s/.test(after)) {
+            return 'MUST NOT';
+        }
+        return isMarker(raw) ? raw : null;
+    }
+    return isMarker(raw) ? raw : null;
+}
+/**
+ * Derive a human-readable rule name from the marker line. Heuristic: take
+ * the first 8 words of the line, lowercase, trimmed. Catalog matching is
+ * the source of truth for the canonical rule name; this is the fallback
+ * when no catalog entry matches.
+ */
+export function deriveRuleName(lineText) {
+    const cleaned = lineText
+        .replace(MARKER_PATTERN, '')
+        .replace(/^[*_`#>:]+/, '')
+        .replace(/[*_`#>]/g, '')
+        .trim();
+    const words = cleaned.split(/\s+/).filter(Boolean).slice(0, 8);
+    return words.length > 0 ? words.join(' ').toLowerCase() : 'unspecified red line';
+}
+/**
+ * Classify a single markdown file. Returns 0+ RedLineEntry; one entry per
+ * marker hit. Marker hits that appear multiple times on the same line are
+ * counted once.
+ */
+export function classifyFile(input) {
+    const entries = [];
+    const warnings = [];
+    const seen = new Set();
+    for (let idx = 0; idx < input.lines.length; idx++) {
+        const lineText = input.lines[idx] ?? '';
+        if (seen.has(idx + 1))
+            continue;
+        const marker = detectMarker(lineText);
+        if (marker === null)
+            continue;
+        seen.add(idx + 1);
+        const context = extractContext(input.lines, idx);
+        const ruleName = deriveRuleName(lineText);
+        const markers = [marker];
+        const catalog = findCatalogEntry(ruleName, markers);
+        const source = {
+            file: input.file,
+            line: idx + 1,
+            marker,
+            context,
+        };
+        if (catalog) {
+            entries.push({
+                id: catalog.id,
+                rule: catalog.rule,
+                source,
+                backing: catalog.enforcerRef === null ? 'prose-only' : 'cli-backed',
+                enforcerRef: catalog.enforcerRef,
+            });
+        }
+        else {
+            // Marker hit but no catalog match: discovered, not yet enforced.
+            entries.push({
+                id: `rl-discovered-${input.file.replace(/[^a-z0-9]+/gi, '-').toLowerCase()}-${idx + 1}`,
+                rule: ruleName,
+                source,
+                backing: 'prose-only',
+                enforcerRef: null,
+            });
+        }
+    }
+    return { entries, warnings };
+}
+/**
+ * Batch wrapper — classify each input file and flatten the entries.
+ */
+export function classifyFiles(inputs) {
+    const allEntries = [];
+    const allWarnings = [];
+    for (const input of inputs) {
+        const result = classifyFile(input);
+        allEntries.push(...result.entries);
+        allWarnings.push(...result.warnings);
+    }
+    return { entries: allEntries, warnings: allWarnings };
+}

package/dist/src/services/audit/enforcers/active-skill-resolver.d.ts

@@ -0,0 +1,29 @@
+/**
+ * active-skill-resolver — utility for hook enforcers.
+ *
+ * Resolves the active peak skill name for the current session, so hook
+ * enforcers (e.g. solo-code-ban) can decide whether to fire.
+ *
+ * Per `src/services/session/caller-id-types.ts`: the active-skill file is
+ * at `.peaks/_runtime/<peakSessionId>/active-skill-<callerId>.json`.
+ *
+ * Resolution order (graceful degradation — never throws):
+ *   1. PEAKS_ACTIVE_SKILL env var (explicit override, used by tests)
+ *   2. .peaks/_runtime/<sid>/active-skill-<callerId>.json for each caller
+ *      bound to the current peak session
+ *   3. null (caller did not set a skill; enforcers can decide to skip)
+ */
+export interface ActiveSkillResolution {
+    readonly skill: string | null;
+    readonly callerId: string | null;
+    readonly sessionId: string | null;
+    readonly source: 'env' | 'file' | 'none';
+}
+/**
+ * Resolve the active peak skill for the current hook invocation.
+ *
+ * Reads PEAKS_ACTIVE_SKILL first (test override), then walks
+ * `.peaks/_runtime/<sid>/` for any `active-skill-*.json` file. Returns
+ * the first match.
+ */
+export declare function resolveActiveSkillForCaller(projectRoot: string): ActiveSkillResolution;

package/dist/src/services/audit/enforcers/active-skill-resolver.js

@@ -0,0 +1,71 @@
+/**
+ * active-skill-resolver — utility for hook enforcers.
+ *
+ * Resolves the active peak skill name for the current session, so hook
+ * enforcers (e.g. solo-code-ban) can decide whether to fire.
+ *
+ * Per `src/services/session/caller-id-types.ts`: the active-skill file is
+ * at `.peaks/_runtime/<peakSessionId>/active-skill-<callerId>.json`.
+ *
+ * Resolution order (graceful degradation — never throws):
+ *   1. PEAKS_ACTIVE_SKILL env var (explicit override, used by tests)
+ *   2. .peaks/_runtime/<sid>/active-skill-<callerId>.json for each caller
+ *      bound to the current peak session
+ *   3. null (caller did not set a skill; enforcers can decide to skip)
+ */
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getSessionIdCanonical } from '../../session/session-manager.js';
+import { getSessionDir } from '../../session/getSessionDir.js';
+const ACTIVE_SKILL_PREFIX = 'active-skill-';
+/**
+ * Resolve the active peak skill for the current hook invocation.
+ *
+ * Reads PEAKS_ACTIVE_SKILL first (test override), then walks
+ * `.peaks/_runtime/<sid>/` for any `active-skill-*.json` file. Returns
+ * the first match.
+ */
+export function resolveActiveSkillForCaller(projectRoot) {
+    const envOverride = process.env.PEAKS_ACTIVE_SKILL;
+    if (typeof envOverride === 'string' && envOverride.length > 0) {
+        return { skill: envOverride, callerId: null, sessionId: null, source: 'env' };
+    }
+    let sessionId = null;
+    try {
+        sessionId = getSessionIdCanonical(projectRoot);
+    }
+    catch {
+        return { skill: null, callerId: null, sessionId: null, source: 'none' };
+    }
+    if (sessionId === null) {
+        return { skill: null, callerId: null, sessionId: null, source: 'none' };
+    }
+    const sessionDir = getSessionDir(projectRoot, sessionId);
+    if (!existsSync(sessionDir)) {
+        return { skill: null, callerId: null, sessionId: sessionId, source: 'none' };
+    }
+    let entries;
+    try {
+        entries = readdirSync(sessionDir);
+    }
+    catch {
+        return { skill: null, callerId: null, sessionId: sessionId, source: 'none' };
+    }
+    for (const entry of entries) {
+        if (!entry.startsWith(ACTIVE_SKILL_PREFIX) || !entry.endsWith('.json'))
+            continue;
+        const callerId = entry.slice(ACTIVE_SKILL_PREFIX.length, -'.json'.length);
+        const filePath = join(sessionDir, entry);
+        try {
+            const raw = readFileSync(filePath, 'utf8');
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.skill === 'string' && parsed.skill.length > 0) {
+                return { skill: parsed.skill, callerId, sessionId, source: 'file' };
+            }
+        }
+        catch {
+            // skip malformed file
+        }
+    }
+    return { skill: null, callerId: null, sessionId, source: 'none' };
+}

package/dist/src/services/audit/enforcers/design-draft-confirm.d.ts

@@ -0,0 +1,25 @@
+/**
+ * design-draft-confirm enforcer (L2.2 P1) — verifies a design draft exists
+ * and has been confirmed before the rd implementation phase begins.
+ *
+ * Two red lines:
+ *   - rl-design-draft-confirm-001: design-draft.md must exist before spec-locked
+ *   - rl-design-draft-confirm-002: design-draft must have a 'confirmed' marker
+ *
+ * The state-machine check is wired into peaks request transition (the
+ * spec-locked transition requires both files to exist + design to be
+ * confirmed). The catalog flags the entry as cli-backed when the
+ * enforcer file exists.
+ */
+export interface DesignDraftConfirmInput {
+    readonly projectRoot: string;
+    readonly sessionId: string;
+    readonly changeId: string;
+}
+export interface DesignDraftConfirmResult {
+    readonly draftExists: boolean;
+    readonly draftPath: string;
+    readonly confirmed: boolean;
+    readonly confirmationPath: string;
+}
+export declare function checkDesignDraftConfirmation(input: DesignDraftConfirmInput): DesignDraftConfirmResult;

package/dist/src/services/audit/enforcers/design-draft-confirm.js

@@ -0,0 +1,54 @@
+/**
+ * design-draft-confirm enforcer (L2.2 P1) — verifies a design draft exists
+ * and has been confirmed before the rd implementation phase begins.
+ *
+ * Two red lines:
+ *   - rl-design-draft-confirm-001: design-draft.md must exist before spec-locked
+ *   - rl-design-draft-confirm-002: design-draft must have a 'confirmed' marker
+ *
+ * The state-machine check is wired into peaks request transition (the
+ * spec-locked transition requires both files to exist + design to be
+ * confirmed). The catalog flags the entry as cli-backed when the
+ * enforcer file exists.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const CONFIRMATION_MARKERS = [
+    /\bconfirmed\b\s*[:=]\s*true/i,
+    /\bstatus:\s*confirmed-by-user/i,
+    /^#\s*confirmed\b/im,
+];
+export function checkDesignDraftConfirmation(input) {
+    // Design drafts live at .peaks/<changeId>/ui/design-draft.md (UI role) or
+    // .peaks/<changeId>/prd/requests/<rid>.md (PRD). For L2.2 the canonical
+    // location is the UI design-draft.
+    const draftPath = join(input.projectRoot, '.peaks', input.changeId, 'ui/design-draft.md');
+    const draftExists = existsSync(draftPath);
+    if (!draftExists) {
+        return {
+            draftExists: false,
+            draftPath,
+            confirmed: false,
+            confirmationPath: '',
+        };
+    }
+    let content;
+    try {
+        content = readFileSync(draftPath, 'utf8');
+    }
+    catch {
+        return {
+            draftExists: true,
+            draftPath,
+            confirmed: false,
+            confirmationPath: draftPath,
+        };
+    }
+    const confirmed = CONFIRMATION_MARKERS.some((p) => p.test(content));
+    return {
+        draftExists: true,
+        draftPath,
+        confirmed,
+        confirmationPath: draftPath,
+    };
+}

package/dist/src/services/audit/enforcers/lint-audit-regression.d.ts

@@ -0,0 +1,21 @@
+import type { LintHit } from './lint-style.js';
+export declare const CATALOG_STABILITY_GROWTH_CAP = 0.2;
+export declare const CATALOG_STABILITY_WINDOW_DAYS = 90;
+export declare const RUNTIME_BUDGET_MS = 2000;
+export interface CatalogStabilityInput {
+    /** Current catalog size (entries.length). */
+    readonly currentSize: number;
+    /** Catalog size 90 days ago, or null if no history available. */
+    readonly sizeNinetyDaysAgo: number | null;
+}
+export declare function lintCatalogStability(input: CatalogStabilityInput): readonly LintHit[];
+export declare function lintNoOrphanEnforcer(projectRoot: string): readonly LintHit[];
+export declare function lintNoOrphanCatalog(): readonly LintHit[];
+export declare function lintRuntimeBudget(projectRoot: string, observedMs: number): readonly LintHit[];
+/**
+ * Read the catalog-stability history file (if it exists). The
+ * file is a small JSON document maintained by the release
+ * pipeline; absent → null. We do not invent the historical
+ * data; absent data means "soft pass".
+ */
+export declare function readCatalogHistory(projectRoot: string): number | null;