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

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

@@ -1,71 +0,0 @@
-/**
- * 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 { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-            // skip malformed file
-        }
-    }
-    return { skill: null, callerId: null, sessionId, source: 'none' };
-}

package/dist/src/services/audit/enforcers/solo-code-ban.d.ts

@@ -1,23 +0,0 @@
-/**
- * Solo-code-ban enforcer — PreToolUse Bash guard.
- *
- * Per L2 redesign §5.4. Deny `git commit` or `git apply` invocations from
- * a peaks-* skill. The Solo Code-Change Red Line says peaks-code / peaks-rd
- * are orchestrators, not implementers; the actual `git commit` step must
- * go through `peaks request transition`, which itself enforces spec-locked
- * + tech-doc-presence.
- *
- * Trust red line (per `gate-enforcement-hook.md`): if the registry or
- * manifest read fails, the hook must fail-OPEN (warn + allow). The LLM is
- * never bricked by a peaks bug.
- */
-export interface SoloCodeBanInput {
-    readonly skill: string;
-    readonly command: string;
-}
-export interface SoloCodeBanResult {
-    readonly denied: boolean;
-    readonly reason: string;
-}
-export declare function isSoloCodeCommit(skill: string, command: string): boolean;
-export declare function evaluateSoloCodeBan(input: SoloCodeBanInput): SoloCodeBanResult;

package/dist/src/services/audit/enforcers/solo-code-ban.js

@@ -1,27 +0,0 @@
-/**
- * Solo-code-ban enforcer — PreToolUse Bash guard.
- *
- * Per L2 redesign §5.4. Deny `git commit` or `git apply` invocations from
- * a peaks-* skill. The Solo Code-Change Red Line says peaks-code / peaks-rd
- * are orchestrators, not implementers; the actual `git commit` step must
- * go through `peaks request transition`, which itself enforces spec-locked
- * + tech-doc-presence.
- *
- * Trust red line (per `gate-enforcement-hook.md`): if the registry or
- * manifest read fails, the hook must fail-OPEN (warn + allow). The LLM is
- * never bricked by a peaks bug.
- */
-const COMMIT_APPLY_PATTERN = /^\s*git\s+(commit|apply)\b/;
-const DENY_REASON = 'Solo Code-Change Red Line: peaks-* skills must go through peaks-code / peaks-rd. ' +
-    'Use `peaks request transition` instead of `git commit` / `git apply` directly.';
-export function isSoloCodeCommit(skill, command) {
-    if (!skill.startsWith('peaks-'))
-        return false;
-    return COMMIT_APPLY_PATTERN.test(command);
-}
-export function evaluateSoloCodeBan(input) {
-    if (isSoloCodeCommit(input.skill, input.command)) {
-        return { denied: true, reason: DENY_REASON };
-    }
-    return { denied: false, reason: '' };
-}

package/dist/src/services/audit/red-line-catalog.d.ts

@@ -1,51 +0,0 @@
-/**
- * Red-line catalog — the 5 P0 red lines shipped in L2.1, plus the marker
- * patterns that the classifier uses to discover them in markdown.
- *
- * The catalog is hand-maintained. New enforcers (L2.2/2.3/2.4) add entries
- * here and the backing-detector picks them up automatically.
- */
-import type { RedLineMarker } from './types.js';
-export interface RedLineCatalogEntry {
-    /** Stable id, e.g. "rl-solo-code-ban-001". */
-    readonly id: string;
-    readonly rule: string;
-    /** Markers that, if found near the rule's text, identify this red line. */
-    readonly markers: readonly RedLineMarker[];
-    /** Substring(s) that must appear in the surrounding ±2 lines. */
-    readonly phrases: readonly string[];
-    /** Relative path to the enforcement file (or null when prose-only). */
-    readonly enforcerRef: string | null;
-}
-export declare const RED_LINE_CATALOG: readonly RedLineCatalogEntry[];
-/**
- * Catalog entries for enforcers whose source code is shipped in this slice
- * but whose integration is deferred to subsequent slices (L2.1.1 or later).
- *
- * The backing-detector downgrades these to `prose-only` at runtime because
- * the integration seam is missing. When the integration lands, the entry
- * is removed from this set in a single-line follow-up commit.
- *
- * L2.1 final state: Tasks 5 (solo-code-ban) + 6 (no-root-pollution) are
- * wired into peaks hook handle (Tasks 1-4: framework + 3 enforcers also
- * integrated). Tasks 3 (tech-doc-presence) and 4 (mock-placement) are
- * deferred — their request-transition / slice-check integrations are
- * tracked separately.
- */
-export declare const DEFERRED_ENFORCERS: ReadonlySet<string>;
-/**
- * A red line's catalog id is the join key. If a discovered red line in a
- * markdown file matches no catalog entry, it stays as `prose-only`.
- *
- * Match policy: phrase-only for identity. Markers (MANDATORY / BLOCKING /
- * MUST NOT / RED LINE) are too generic to disambiguate — every catalog
- * entry shares the same marker set, so a marker-only match would always
- * return the first catalog entry regardless of the rule.
- *
- * Deferred enforcers (Tasks 4-6 integration pending) are matched by
- * phrase but tagged with enforcerRef=null so the backing-detector
- * downgrades them to prose-only at runtime. They are NOT removed from
- * the catalog so future integration commits can re-tag them with a
- * single source-of-truth change.
- */
-export declare function findCatalogEntry(rule: string, _markers: readonly RedLineMarker[]): RedLineCatalogEntry | null;

package/dist/src/services/audit/red-line-catalog.js

@@ -1,195 +0,0 @@
-/**
- * Red-line catalog — the 5 P0 red lines shipped in L2.1, plus the marker
- * patterns that the classifier uses to discover them in markdown.
- *
- * The catalog is hand-maintained. New enforcers (L2.2/2.3/2.4) add entries
- * here and the backing-detector picks them up automatically.
- */
-import { RED_LINE_CATALOG_P2_A } from './red-line-catalog-p2-a.js';
-import { RED_LINE_CATALOG_P2_B } from './red-line-catalog-p2-b.js';
-export const RED_LINE_CATALOG = [
-    {
-        id: 'rl-solo-code-ban-001',
-        rule: 'Solo Code-Change Red Line',
-        markers: ['BLOCKING', 'MANDATORY'],
-        phrases: [
-            'peaks-code',
-            'orchestrator, NOT an implementer',
-            'solo',
-        ],
-        enforcerRef: 'src/services/audit/enforcers/solo-code-ban.ts',
-    },
-    {
-        id: 'rl-no-root-pollution-001',
-        rule: 'No Root Pollution',
-        markers: ['MANDATORY', 'MUST NOT', 'RED LINE'],
-        phrases: [
-            'root pollution',
-            'must not write to the project root',
-            'no root',
-        ],
-        enforcerRef: 'src/services/audit/enforcers/no-root-pollution.ts',
-    },
-    {
-        id: 'rl-sub-agent-sid-001',
-        rule: 'Sub-Agent SID Isolation',
-        markers: ['MANDATORY', 'BLOCKING'],
-        phrases: [
-            'sub-agent',
-            'session id',
-            'sub-agent session sharing',
-            'one conversation = one sid',
-        ],
-        enforcerRef: 'src/services/audit/enforcers/sub-agent-sid.ts',
-    },
-    {
-        id: 'rl-mock-placement-001',
-        rule: 'Mock Data Placement',
-        markers: ['MUST NOT', 'MANDATORY'],
-        phrases: [
-            'mock data',
-            'mock placement',
-            'inline mock',
-            'fixture placement',
-        ],
-        enforcerRef: 'src/services/audit/enforcers/mock-placement.ts',
-    },
-    // === Slice L2.2 P1 — 10 P1 red lines across 5 categories ===
-    // Each catalog entry has a phrase that distinguishes it from P0; the
-    // backing-detector + DEFERRED_ENFORCERS mechanism handles the rest.
-    {
-        id: 'rl-resume-detection-001',
-        rule: 'Resume Detection: Session Binding',
-        markers: ['MANDATORY', 'BLOCKING'],
-        phrases: ['resume detection', 'session binding', 'resume session', 'resume from'],
-        enforcerRef: 'src/services/audit/enforcers/resume-detection.ts',
-    },
-    {
-        id: 'rl-resume-detection-002',
-        rule: 'Resume Detection: Request State',
-        markers: ['MANDATORY', 'BLOCKING'],
-        phrases: ['request state', 'resumable state', 'spec-locked', 'implemented', 'qa-handoff'],
-        enforcerRef: 'src/services/audit/enforcers/resume-detection.ts',
-    },
-    {
-        id: 'rl-prototype-fidelity-001',
-        rule: 'Prototype Fidelity: No Stub Markers',
-        markers: ['MUST NOT', 'MANDATORY'],
-        phrases: ['prototype fidelity', 'no stub', 'no TODO', 'no FIXME', 'no placeholder'],
-        enforcerRef: 'src/services/audit/enforcers/prototype-fidelity.ts',
-    },
-    {
-        id: 'rl-prototype-fidelity-002',
-        rule: 'Prototype Fidelity: Test Coverage',
-        markers: ['MANDATORY', 'RED LINE'],
-        phrases: ['prototype test', 'must have tests', 'test coverage', 'fidelity test'],
-        enforcerRef: 'src/services/audit/enforcers/prototype-fidelity.ts',
-    },
-    {
-        id: 'rl-design-draft-confirm-001',
-        rule: 'Design-Draft Confirm: Existence',
-        markers: ['MANDATORY', 'BLOCKING'],
-        phrases: ['design-draft', 'design draft', 'design-draft.md', 'design draft exists'],
-        enforcerRef: 'src/services/audit/enforcers/design-draft-confirm.ts',
-    },
-    {
-        id: 'rl-design-draft-confirm-002',
-        rule: 'Design-Draft Confirm: Confirmed State',
-        markers: ['MANDATORY', 'BLOCKING'],
-        phrases: ['design confirmed', 'design-draft confirmed', 'confirmed-by-user', 'user confirmed'],
-        enforcerRef: 'src/services/audit/enforcers/design-draft-confirm.ts',
-    },
-    {
-        id: 'rl-pre-rd-scan-001',
-        rule: 'Pre-RD Scan: Archetype Detected',
-        markers: ['MANDATORY', 'BLOCKING'],
-        phrases: ['pre-rd scan', 'project-scan', 'archetype detected', 'scan archetype'],
-        enforcerRef: 'src/services/audit/enforcers/pre-rd-scan.ts',
-    },
-    {
-        id: 'rl-pre-rd-scan-002',
-        rule: 'Pre-RD Scan: Standards Preflight',
-        markers: ['MANDATORY', 'BLOCKING'],
-        phrases: ['standards preflight', 'pre-rd standards', 'standards init', 'standards update'],
-        enforcerRef: 'src/services/audit/enforcers/pre-rd-scan.ts',
-    },
-    {
-        id: 'rl-login-gate-001',
-        rule: 'Login Gate: Destructive Path Confirmation',
-        markers: ['MANDATORY', 'BLOCKING', 'RED LINE'],
-        phrases: ['login gate', 'destructive path', 'uninstall', 'force-push', 'user confirmation required'],
-        enforcerRef: 'src/services/audit/enforcers/login-gate.ts',
-    },
-    {
-        id: 'rl-login-gate-002',
-        rule: 'Login Gate: Protected Path Auth',
-        markers: ['MANDATORY', 'BLOCKING'],
-        phrases: ['protected path', 'auth required', 'auth header', 'login required', 'session check'],
-        enforcerRef: 'src/services/audit/enforcers/login-gate.ts',
-    },
-    // Slice #6 L2.3 P2-a: 24 lint-style red-lines (Theme A: section
-    // structure, B: frontmatter shape, C: output style, D: CLI-back
-    // gaps, E: reference integrity, F: workflow-bound shape, G: catalog
-    // governance). Spread from the P2-a module so future P2-a edits
-    // are localized.
-    ...RED_LINE_CATALOG_P2_A,
-    // Slice #7 L2.4 P2-b: 25 lint-style red-lines for references/*.md
-    // (Themes H-P) + 4 audit-regression enforcers (Theme L). Spread
-    // from the P2-b module so future P2-b edits are localized.
-    ...RED_LINE_CATALOG_P2_B,
-];
-/**
- * Catalog entries for enforcers whose source code is shipped in this slice
- * but whose integration is deferred to subsequent slices (L2.1.1 or later).
- *
- * The backing-detector downgrades these to `prose-only` at runtime because
- * the integration seam is missing. When the integration lands, the entry
- * is removed from this set in a single-line follow-up commit.
- *
- * L2.1 final state: Tasks 5 (solo-code-ban) + 6 (no-root-pollution) are
- * wired into peaks hook handle (Tasks 1-4: framework + 3 enforcers also
- * integrated). Tasks 3 (tech-doc-presence) and 4 (mock-placement) are
- * deferred — their request-transition / slice-check integrations are
- * tracked separately.
- */
-// v2.14.0 Slice C Group G3: prose-only catalog governance reform.
-// All 8 previously-deferred enforcers are now integrated into the
-// red-lines audit pipeline (see red-lines-service.ts §3-7). The
-// backing-detector re-classifies these entries as cli-backed because
-// their enforcerRef file exists on disk. Rationale per id lives in
-// `.peaks/standards/catalog-governance/v2-14-classifications.md`.
-//
-// The 80 discovered-prose-only entries (`rl-discovered-...` ids) remain
-// in the catalog with `informational: true` and stay outside the
-// prose-only ratio (see prose-ratio-calculator.ts).
-export const DEFERRED_ENFORCERS = new Set([]);
-/**
- * A red line's catalog id is the join key. If a discovered red line in a
- * markdown file matches no catalog entry, it stays as `prose-only`.
- *
- * Match policy: phrase-only for identity. Markers (MANDATORY / BLOCKING /
- * MUST NOT / RED LINE) are too generic to disambiguate — every catalog
- * entry shares the same marker set, so a marker-only match would always
- * return the first catalog entry regardless of the rule.
- *
- * Deferred enforcers (Tasks 4-6 integration pending) are matched by
- * phrase but tagged with enforcerRef=null so the backing-detector
- * downgrades them to prose-only at runtime. They are NOT removed from
- * the catalog so future integration commits can re-tag them with a
- * single source-of-truth change.
- */
-export function findCatalogEntry(rule, _markers) {
-    const lower = rule.toLowerCase();
-    for (const entry of RED_LINE_CATALOG) {
-        const phraseHit = entry.phrases.some((p) => lower.includes(p.toLowerCase()));
-        if (phraseHit) {
-            if (DEFERRED_ENFORCERS.has(entry.id)) {
-                // Return a copy with enforcerRef nulled out, so backing-detector
-                // treats it as prose-only until the integration lands.
-                return { ...entry, enforcerRef: null };
-            }
-            return entry;
-        }
-    }
-    return null;
-}

package/dist/src/services/audit/static-service.d.ts

@@ -1,60 +0,0 @@
-/**
- * Static audit service — `peaks audit static`.
- *
- * Slice #6 L2.3 P2-a: soft-optional ECC AgentShield integration.
- *
- * Per spec §5.3, the audit framework integrates with ECC AgentShield
- * (102 lint rules) on a soft-optional basis. When ECC is installed
- * AND `agentShieldEnabled: true`, the audit subprocess spawns the
- * ECC scanner and merges its findings; when either is missing, the
- * audit completes with peaks-loop-only findings.
- *
- * The subprocess is **observability enhancement**, not a structural
- * gate — every soft-fail path returns a well-formed audit report.
- */
-import { type ProseRatioResult } from './prose-ratio-calculator.js';
-import type { EnforcerFinding, RedLineAudit } from './types.js';
-export interface StaticAuditInput {
-    readonly projectRoot: string;
-    /** Override the preference for a single call. Default: read from preferences. */
-    readonly enableAgentShield?: boolean | undefined;
-    /**
-     * Optional subprocess runner injection point. Used by tests
-     * to mock `npx ecc-agentshield`. Production callers should
-     * leave this undefined; the default uses `child_process.spawnSync`.
-     */
-    readonly subprocessRunner?: SubprocessRunner | undefined;
-}
-export interface StaticAuditResult {
-    readonly audit: RedLineAudit;
-    readonly agentShield: AgentShieldState;
-    readonly warnings: readonly string[];
-    /** v2.14.0 Slice C: prose-only ratio with informational exclusion (per A3.1). */
-    readonly proseRatio: ProseRatioResult;
-}
-export interface AgentShieldState {
-    /** Whether the agent-shield subprocess was spawned. */
-    readonly spawned: boolean;
-    /** Whether ECC AgentShield is installed (regardless of whether it was spawned). */
-    readonly installed: boolean;
-    /** Why the subprocess was or was not spawned. */
-    readonly reason: 'enabled-and-installed' | 'disabled-by-preference' | 'flag-disabled' | 'flag-enabled-but-ecc-missing' | 'disabled-and-ecc-missing';
-    /** The merged ECC findings (empty if not spawned). */
-    readonly findings: readonly EnforcerFinding[];
-}
-/**
- * Subprocess runner interface — the only seam tests need to
- * mock the `npx ecc-agentshield` subprocess. Production callers
- * leave `subprocessRunner` undefined; the default delegates to
- * `child_process.spawnSync` (synchronous, captures stdout).
- */
-export interface SubprocessRunner {
-    run(command: string, args: readonly string[], timeoutMs: number): SubprocessResult;
-}
-export interface SubprocessResult {
-    readonly status: number | null;
-    readonly stdout: string;
-    readonly stderr: string;
-    readonly error?: Error;
-}
-export declare function runStaticAudit(input: StaticAuditInput): StaticAuditResult;

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

@@ -1,130 +0,0 @@
-/**
- * Static audit service — `peaks audit static`.
- *
- * Slice #6 L2.3 P2-a: soft-optional ECC AgentShield integration.
- *
- * Per spec §5.3, the audit framework integrates with ECC AgentShield
- * (102 lint rules) on a soft-optional basis. When ECC is installed
- * AND `agentShieldEnabled: true`, the audit subprocess spawns the
- * ECC scanner and merges its findings; when either is missing, the
- * audit completes with peaks-loop-only findings.
- *
- * The subprocess is **observability enhancement**, not a structural
- * gate — every soft-fail path returns a well-formed audit report.
- */
-import { spawnSync } from 'node:child_process';
-import { runRedLinesAudit } from './red-lines-service.js';
-import { loadPreferences } from '../preferences/preferences-service.js';
-import { computeProseRatio } from './prose-ratio-calculator.js';
-const ECC_DETECT_TIMEOUT_MS = 5000;
-const ECC_SCAN_TIMEOUT_MS = 30000;
-const defaultSubprocessRunner = {
-    run(command, args, timeoutMs) {
-        try {
-            const r = spawnSync(command, args, {
-                timeout: timeoutMs,
-                encoding: 'utf8',
-                stdio: ['ignore', 'pipe', 'pipe'],
-                maxBuffer: 16 * 1024 * 1024,
-            });
-            return {
-                status: r.status,
-                stdout: r.stdout ?? '',
-                stderr: r.stderr ?? '',
-            };
-        }
-        catch (err) {
-            return {
-                status: null,
-                stdout: '',
-                stderr: '',
-                error: err,
-            };
-        }
-    },
-};
-function isEccInstalled(runner) {
-    const result = runner.run('npx', ['ecc-agentshield', '--version'], ECC_DETECT_TIMEOUT_MS);
-    if (result.error)
-        return false;
-    return result.status === 0;
-}
-function runEccScan(projectRoot, runner) {
-    try {
-        // Per spec §7.2 line 828: the canonical ECC subprocess call uses
-        // `--target <path>`, NOT `--project`. The peaks-loop CLI flag
-        // (`peaks audit static --project <path>`) follows peaks-loop
-        // convention; the inner ecc-agentshield call follows the
-        // upstream ECC contract.
-        const result = runner.run('npx', ['ecc-agentshield', 'scan', '--json', '--target', projectRoot], ECC_SCAN_TIMEOUT_MS);
-        if (result.error || result.status !== 0)
-            return [];
-        const stdout = result.stdout;
-        let parsed;
-        try {
-            parsed = JSON.parse(stdout);
-        }
-        catch {
-            return [];
-        }
-        if (!parsed.findings)
-            return [];
-        return parsed.findings.map((f, idx) => ({
-            enforcerId: `ecc-agentshield:${f.ruleId ?? `unknown-${idx}`}`,
-            rule: f.rule ?? 'ECC AgentShield rule',
-            severity: f.severity ?? 'warn',
-            file: f.file ?? '(unknown)',
-            detail: f.detail ?? '',
-        }));
-    }
-    catch {
-        return [];
-    }
-}
-export function runStaticAudit(input) {
-    // Read the project-local preferences; the CLI flag overrides.
-    const prefs = loadPreferences(input.projectRoot);
-    const prefEnabled = prefs.agentShieldEnabled;
-    const flagEnabled = input.enableAgentShield;
-    const runner = input.subprocessRunner ?? defaultSubprocessRunner;
-    // Resolve the effective "should spawn" decision.
-    // flagEnabled (CLI override) > preference > false
-    const shouldSpawn = flagEnabled ?? prefEnabled;
-    // Detect ECC.
-    const installed = isEccInstalled(runner);
-    const warnings = [];
-    let state;
-    if (!shouldSpawn) {
-        // Disabled path — no subprocess, no warnings.
-        const reason = flagEnabled === false
-            ? 'flag-disabled'
-            : 'disabled-by-preference';
-        state = { spawned: false, installed, reason, findings: [] };
-    }
-    else if (!installed) {
-        // Enabled but ECC missing — soft-fail with a warning.
-        warnings.push('agentShieldEnabled is true but `npx ecc-agentshield --version` failed. ' +
-            'Run `npx ecc-agentshield --help` to install. Audit ran with peaks-loop findings only.');
-        state = { spawned: false, installed: false, reason: 'flag-enabled-but-ecc-missing', findings: [] };
-    }
-    else {
-        // Enabled and installed — spawn the subprocess.
-        const findings = runEccScan(input.projectRoot, runner);
-        state = { spawned: true, installed: true, reason: 'enabled-and-installed', findings };
-    }
-    // Always run the peaks-loop lint layer; merge ECC findings.
-    const peaksResult = runRedLinesAudit({ projectRoot: input.projectRoot });
-    const mergedAudit = {
-        ...peaksResult.audit,
-        enforcerFindings: [...peaksResult.audit.enforcerFindings, ...state.findings],
-    };
-    // v2.14.0 Slice C: compute prose-only ratio with informational
-    // exclusion. Surfaced in the JSON envelope so CI can gate on it.
-    const proseRatio = computeProseRatio(mergedAudit.audit);
-    return {
-        audit: mergedAudit,
-        agentShield: state,
-        warnings,
-        proseRatio,
-    };
-}

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

@@ -1,86 +0,0 @@
-/**
- * Red-line audit framework — types.
- *
- * Spec: docs/superpowers/specs/2026-06-11-peaks-loop-l1-l2-l3-redesign.md §5
- * PRD:  .peaks/_runtime/2026-06-11-session-f0312d/prd/requests/001-001-l2-1-redlines-audit.md
- * OpenSpec: openspec/changes/2026-06-11-l2-1-redlines-audit/
- *
- * The audit framework classifies MANDATORY / BLOCKING / MUST NOT / RED LINE
- * markers across skills/, .claude/rules/, and openspec/changes/. Each
- * discovered red line is tagged with its backing (cli-backed / partial /
- * prose-only) so the L2 redesign can track the prose-only ratio over time.
- */
-export type RedLineMarker = 'MANDATORY' | 'BLOCKING' | 'MUST NOT' | 'RED LINE';
-export type RedLineBacking = 'cli-backed' | 'partial' | 'prose-only';
-export interface RedLineSource {
-    /** Path relative to project root, posix-style (forward slashes). */
-    readonly file: string;
-    readonly line: number;
-    readonly marker: RedLineMarker;
-    /** ±2 lines of surrounding context for human review. */
-    readonly context: string;
-}
-export interface RedLineEntry {
-    /** Stable id, e.g. "rl-solo-code-ban-001". */
-    readonly id: string;
-    /** Human-readable rule name, e.g. "Solo Code-Change Red Line". */
-    readonly rule: string;
-    readonly source: RedLineSource;
-    readonly backing: RedLineBacking;
-    /** Relative path to the enforcement file, or null when prose-only. */
-    readonly enforcerRef: string | null;
-    /**
-     * v2.12.1 catalog governance: `true` for entries that are
-     * advisory / educational / "discovered-but-not-yet-enforced" and
-     * therefore should NOT count toward the prose-only ratio (per spec
-     * §10.2 L2 acceptance ≤ 5%). Defaults to `false`; the classifier
-     * sets it to `true` for auto-discovered prose-only entries (those
-     * without a catalog match, since they have no enforcer template
-     * to promote to). Callers that want strict accounting can still
-     * read `backing === 'prose-only'` and filter manually.
-     *
-     * Why: the pre-v2.12.1 catalog treated every MANDATORY/BLOCKING
-     * phrase in SKILL.md as a "red line", which produced a 60.1%
-     * prose-only ratio (89/148) for what is mostly LLM behavior
-     * guidance, not machine-enforceable rules. See
-     * `.peaks/memory/2026-06-27-prose-only-catalog-followup.md`.
-     */
-    readonly informational?: boolean;
-}
-export interface RedLineAudit {
-    readonly totalRedLines: number;
-    readonly cliBacked: number;
-    readonly partial: number;
-    readonly proseOnly: number;
-    readonly audit: readonly RedLineEntry[];
-    /** Findings from running the 7 file-system enforcers during the scan (L2.4 P2-b). */
-    readonly enforcerFindings: readonly EnforcerFinding[];
-}
-/**
- * Enforcer finding — emitted by an enforcer function that runs as part
- * of the audit scan. Distinct from `RedLineEntry` (which is catalog-matched
- * markdown text). L2.4 P2-b ships this dimension: the audit framework
- * actually invokes the 7 file-system enforcers during a scan, not just
- * catalogs them.
- */
-export type EnforcerFindingSeverity = 'pass' | 'warn' | 'fail';
-export interface EnforcerFinding {
-    readonly enforcerId: string;
-    readonly rule: string;
-    readonly severity: EnforcerFindingSeverity;
-    readonly file: string;
-    readonly detail: string;
-}
-/**
- * A single markdown line discovered by a tree scanner. The classifier turns
- * these into RedLineEntry by matching against the red-line catalog.
- */
-export interface MarkdownLine {
-    readonly file: string;
-    readonly line: number;
-    readonly text: string;
-}
-export interface ScanWarning {
-    readonly file: string;
-    readonly message: string;
-}