peaks-loop 4.0.0-beta.8 → 4.0.1

package/dist/services/audit/enforcers/prototype-fidelity.js

@@ -0,0 +1,75 @@
+/**
+ * prototype-fidelity enforcer (L2.2 P1) — verifies a prototype is
+ * functional (not a stub).
+ *
+ * Two red lines:
+ *   - rl-prototype-fidelity-001: prototype files must not contain TODO/FIXME/XXX
+ *   - rl-prototype-fidelity-002: prototype must have at least 1 passing test
+ *
+ * (L2.2 ships the source-level check; deeper test-running integration is
+ * deferred to a follow-up slice.)
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+const STUB_MARKER_PATTERNS = [
+    /\bTODO\b/,
+    /\bFIXME\b/,
+    /\bXXX\b/,
+    /\bHACK\b/,
+    /\bstub\b\s*[:=]/i,
+    /\bnot implemented\b/i,
+];
+export function findStubMarkers(input) {
+    const markers = [];
+    for (const filePath of input.filePaths) {
+        const abs = join(input.projectRoot, filePath);
+        let content;
+        try {
+            content = readFileSync(abs, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        for (const pattern of STUB_MARKER_PATTERNS) {
+            const match = pattern.exec(content);
+            if (match !== null) {
+                markers.push({ filePath, pattern: pattern.source, snippet: match[0] });
+            }
+        }
+    }
+    return { stubMarkers: markers, testFiles: [] };
+}
+export function findTestFiles(projectRoot, sourceDir) {
+    const testsDir = join(projectRoot, sourceDir.replace(/^src\//, 'tests/'));
+    if (!existsSync(testsDir))
+        return [];
+    try {
+        const stat = statSync(testsDir);
+        if (!stat.isDirectory())
+            return [];
+    }
+    catch {
+        return [];
+    }
+    const result = [];
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(full);
+            }
+            else if (entry.isFile() && /\.(test|spec)\.ts$/.test(entry.name)) {
+                result.push(full);
+            }
+        }
+    };
+    walk(testsDir);
+    return result;
+}

package/dist/services/audit/enforcers/resume-detection.d.ts

@@ -0,0 +1,21 @@
+/**
+ * resume-detection enforcer (L2.2 P1) — verifies a slice can be resumed
+ * before the LLM continues work on it.
+ *
+ * Two red lines:
+ *   - rl-resume-detection-001: session-binding file must exist
+ *   - rl-resume-detection-002: existing rd request state must be in
+ *     {spec-locked, implemented, qa-handoff} (resumable states)
+ */
+export interface ResumeDetectionInput {
+    readonly projectRoot: string;
+    readonly sessionId: string;
+}
+export interface ResumeDetectionResult {
+    readonly sessionBindingExists: boolean;
+    readonly sessionBindingPath: string;
+    readonly requestState: string | null;
+    readonly requestStatePath: string;
+    readonly canResume: boolean;
+}
+export declare function checkResume(input: ResumeDetectionInput): ResumeDetectionResult;

package/dist/services/audit/enforcers/resume-detection.js

@@ -0,0 +1,52 @@
+/**
+ * resume-detection enforcer (L2.2 P1) — verifies a slice can be resumed
+ * before the LLM continues work on it.
+ *
+ * Two red lines:
+ *   - rl-resume-detection-001: session-binding file must exist
+ *   - rl-resume-detection-002: existing rd request state must be in
+ *     {spec-locked, implemented, qa-handoff} (resumable states)
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const RESUMABLE_STATES = new Set(['spec-locked', 'implemented', 'qa-handoff']);
+export function checkResume(input) {
+    const sessionBindingPath = join(input.projectRoot, '.peaks/_runtime', input.sessionId, 'session.json');
+    const sessionBindingExists = existsSync(sessionBindingPath);
+    // The rd request artifact lives under .peaks/_runtime/<sid>/rd/requests/<rid>.md
+    // (canonical session layout per `src-services-session-canonical-workspace-resolver.md`).
+    // We look at the most-recent rd request to detect state. The full request-artifact
+    // service is the authoritative source; this is a lightweight check for the audit
+    // scanner.
+    const rdDir = join(input.projectRoot, '.peaks/_runtime', input.sessionId, 'rd/requests');
+    let requestState = null;
+    let requestStatePath = '';
+    if (existsSync(rdDir)) {
+        try {
+            const files = require('node:fs').readdirSync(rdDir);
+            for (const file of files) {
+                if (!file.endsWith('.md'))
+                    continue;
+                const path = join(rdDir, file);
+                const content = readFileSync(path, 'utf8');
+                const match = /state:\s*([a-z0-9-]+)/i.exec(content);
+                if (match !== null) {
+                    requestState = match[1] ?? null;
+                    requestStatePath = path;
+                    break;
+                }
+            }
+        }
+        catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+            // ignore read errors
+        }
+    }
+    const canResume = sessionBindingExists && requestState !== null && RESUMABLE_STATES.has(requestState);
+    return {
+        sessionBindingExists,
+        sessionBindingPath,
+        requestState,
+        requestStatePath,
+        canResume,
+    };
+}

package/dist/services/audit/enforcers/sub-agent-sid.d.ts

@@ -0,0 +1,25 @@
+/**
+ * sub-agent-sid enforcer — dogfood of Slice 0.5 sid-naming-guard.
+ *
+ * Per L2 redesign §5.4, "sub-agent-sid" is one of the 5 P0 red lines.
+ * Slice 0.5 (Task 7) shipped `isValidSessionId` in
+ * `src/services/workspace/sid-naming-guard.ts`. This enforcer exposes the
+ * same check to the red-line audit framework, so any invalid sid under
+ * `.peaks/_sub_agents/` shows up as a backable red line in the audit.
+ */
+export interface SubAgentSidCheckResult {
+    readonly invalid: readonly string[];
+    readonly valid: readonly string[];
+    readonly scanned: boolean;
+}
+/**
+ * Find sids under `.peaks/_sub_agents/<sid>/` that fail `isValidSessionId`.
+ * Bare forms (sid-3, unknown-sid) and date-mismatched sids all fail.
+ */
+export declare function findInvalidSubAgentSids(projectRoot: string): SubAgentSidCheckResult;
+/**
+ * Same check, for `.peaks/_runtime/<sid>/`. Slice 0.5's clean-service
+ * already handles the sub-agents dir; the audit framework also wants to
+ * know about invalid runtime sids (which would be a different failure mode).
+ */
+export declare function findInvalidRuntimeSids(projectRoot: string): SubAgentSidCheckResult;

package/dist/services/audit/enforcers/sub-agent-sid.js

@@ -0,0 +1,63 @@
+/**
+ * sub-agent-sid enforcer — dogfood of Slice 0.5 sid-naming-guard.
+ *
+ * Per L2 redesign §5.4, "sub-agent-sid" is one of the 5 P0 red lines.
+ * Slice 0.5 (Task 7) shipped `isValidSessionId` in
+ * `src/services/workspace/sid-naming-guard.ts`. This enforcer exposes the
+ * same check to the red-line audit framework, so any invalid sid under
+ * `.peaks/_sub_agents/` shows up as a backable red line in the audit.
+ */
+import { existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { isValidSessionId } from '../../workspace/sid-naming-guard.js';
+const SUB_AGENTS_DIR = '.peaks/_sub_agents';
+const RUNTIME_DIR = '.peaks/_runtime';
+/**
+ * Find sids under `.peaks/_sub_agents/<sid>/` that fail `isValidSessionId`.
+ * Bare forms (sid-3, unknown-sid) and date-mismatched sids all fail.
+ */
+export function findInvalidSubAgentSids(projectRoot) {
+    const subAgentsRoot = join(projectRoot, SUB_AGENTS_DIR);
+    if (!existsSync(subAgentsRoot)) {
+        return { invalid: [], valid: [], scanned: false };
+    }
+    const entries = readdirSync(subAgentsRoot, { withFileTypes: true })
+        .filter((e) => e.isDirectory())
+        .map((e) => e.name);
+    const invalid = [];
+    const valid = [];
+    for (const name of entries) {
+        if (isValidSessionId(name)) {
+            valid.push(name);
+        }
+        else {
+            invalid.push(name);
+        }
+    }
+    return { invalid, valid, scanned: true };
+}
+/**
+ * Same check, for `.peaks/_runtime/<sid>/`. Slice 0.5's clean-service
+ * already handles the sub-agents dir; the audit framework also wants to
+ * know about invalid runtime sids (which would be a different failure mode).
+ */
+export function findInvalidRuntimeSids(projectRoot) {
+    const runtimeRoot = join(projectRoot, RUNTIME_DIR);
+    if (!existsSync(runtimeRoot)) {
+        return { invalid: [], valid: [], scanned: false };
+    }
+    const entries = readdirSync(runtimeRoot, { withFileTypes: true })
+        .filter((e) => e.isDirectory())
+        .map((e) => e.name);
+    const invalid = [];
+    const valid = [];
+    for (const name of entries) {
+        if (isValidSessionId(name)) {
+            valid.push(name);
+        }
+        else {
+            invalid.push(name);
+        }
+    }
+    return { invalid, valid, scanned: true };
+}

package/dist/services/audit/prose-ratio-calculator.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Prose-only ratio calculator — Slice C Group G3 (v2.14.0).
+ *
+ * Computes the prose-only ratio for a set of red-line entries. Per
+ * spec §10.2 + the v2.12.1 reform (`.peaks/memory/2026-06-27-
+ * prose-only-catalog-followup.md`), an entry counts as prose-only
+ * only when BOTH:
+ *   1. `backing === 'prose-only'`
+ *   2. `informational !== true`
+ *
+ * The 80 discovered advisory SKILL.md phrases (auto-marked
+ * `informational=true` by `classifier.ts:141`) are excluded from
+ * the ratio so the gate (≤ 5% per slice C AC A3.1) reflects the
+ * actionable backlog.
+ *
+ * Karpathy §2 simplicity: one exported function plus a thin
+ * calculator interface; no I/O. The pure form makes the ≥8
+ * test cases in prose-ratio-calculator.test.ts trivial.
+ */
+import type { RedLineEntry } from './types.js';
+export interface ProseRatioResult {
+    /** Total catalog size (entries.length). */
+    readonly totalRedLines: number;
+    /** Count of entries with backing === 'cli-backed'. */
+    readonly cliBacked: number;
+    /** Count of entries with backing === 'partial'. */
+    readonly partial: number;
+    /** Count of entries with backing === 'prose-only' AND informational !== true. */
+    readonly proseOnly: number;
+    /** Count of entries with informational === true (excluded from ratio). */
+    readonly informational: number;
+    /** proseOnly / totalRedLines. Returns 0 when totalRedLines === 0. */
+    readonly ratio: number;
+    /** Target threshold (default 0.05 per A3.1). */
+    readonly target: number;
+    /** True when ratio > target. */
+    readonly exceeds: boolean;
+}
+export interface ProseRatioOptions {
+    /** Target threshold (default 0.05). */
+    readonly target?: number;
+}
+/** Default target: 5% (per A3.1). */
+export declare const DEFAULT_PROSE_RATIO_TARGET = 0.05;
+export declare function computeProseRatio(entries: readonly RedLineEntry[], options?: ProseRatioOptions): ProseRatioResult;

package/dist/services/audit/prose-ratio-calculator.js

@@ -0,0 +1,52 @@
+/**
+ * Prose-only ratio calculator — Slice C Group G3 (v2.14.0).
+ *
+ * Computes the prose-only ratio for a set of red-line entries. Per
+ * spec §10.2 + the v2.12.1 reform (`.peaks/memory/2026-06-27-
+ * prose-only-catalog-followup.md`), an entry counts as prose-only
+ * only when BOTH:
+ *   1. `backing === 'prose-only'`
+ *   2. `informational !== true`
+ *
+ * The 80 discovered advisory SKILL.md phrases (auto-marked
+ * `informational=true` by `classifier.ts:141`) are excluded from
+ * the ratio so the gate (≤ 5% per slice C AC A3.1) reflects the
+ * actionable backlog.
+ *
+ * Karpathy §2 simplicity: one exported function plus a thin
+ * calculator interface; no I/O. The pure form makes the ≥8
+ * test cases in prose-ratio-calculator.test.ts trivial.
+ */
+/** Default target: 5% (per A3.1). */
+export const DEFAULT_PROSE_RATIO_TARGET = 0.05;
+export function computeProseRatio(entries, options = {}) {
+    const target = options.target ?? DEFAULT_PROSE_RATIO_TARGET;
+    let cliBacked = 0;
+    let partial = 0;
+    let proseOnly = 0;
+    let informational = 0;
+    for (const entry of entries) {
+        if (entry.informational === true) {
+            informational += 1;
+            continue;
+        }
+        if (entry.backing === 'cli-backed')
+            cliBacked += 1;
+        else if (entry.backing === 'partial')
+            partial += 1;
+        else if (entry.backing === 'prose-only')
+            proseOnly += 1;
+    }
+    const totalRedLines = entries.length;
+    const ratio = totalRedLines === 0 ? 0 : proseOnly / totalRedLines;
+    return {
+        totalRedLines,
+        cliBacked,
+        partial,
+        proseOnly,
+        informational,
+        ratio,
+        target,
+        exceeds: ratio > target,
+    };
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Red-line catalog — P2-a entries (Slice #6 L2.3).
+ *
+ * These 25 entries close the lint-style gap left by L2.1 (P0) and
+ * L2.2 (P1). Per spec §5.4, P2-a targets 25-40 lint-style red-lines
+ * for SKILL.md, references/, and openspec/. They are small,
+ * pattern-based, and reference the existing CLI surface (no new
+ * runtime dependencies).
+ *
+ * Enforcer functions live in `enforcers/lint-style-*.ts` and are
+ * wired into the audit framework via the same `enforcerRef`
+ * discovery path as the P0 / P1 entries.
+ */
+import type { RedLineCatalogEntry } from './red-line-catalog.js';
+export declare const RED_LINE_CATALOG_P2_A: readonly RedLineCatalogEntry[];