peaks-loop 4.0.0-beta.9 → 4.0.1

package/dist/services/audit/enforcers/lint-peaks-skill-runtime.js

@@ -0,0 +1,59 @@
+function buildContract(markers, scopeName) {
+    return (skill) => {
+        if (skill.name !== scopeName)
+            return [];
+        const lines = skill.lines.length > 0 ? skill.lines : skill.body.split(/\r?\n/);
+        const missing = [];
+        for (const m of markers) {
+            if (!lines.some((l) => m.pattern.test(l)))
+                missing.push(m.name);
+        }
+        if (missing.length === 0)
+            return [];
+        return [{
+                catalogId: 'lint-peaks-skill-runtime-' + markers[0]?.name.toLowerCase().replace(/[^a-z0-9]+/g, '-'),
+                rule: `peaks-* SKILL.md must declare the runtime contract (missing markers: ${missing.join(', ')})`,
+                file: skill.path,
+                line: 1,
+                matchedText: `missing markers: ${missing.join(', ')}`
+            }];
+    };
+}
+const PEAKS_AUDIT_MARKERS = Object.freeze([
+    { name: 'Audit log machine-readable', pattern: /audit log is machine-readable/i },
+    { name: 'Six-dimension audit', pattern: /six dimensions|6 dimensions/i },
+    { name: 'Author identity', pattern: /author identity.*local gitconfig/i }
+]);
+const PEAKS_CONTENT_MARKERS = Object.freeze([
+    { name: 'What this skill do', pattern: /what this skill do/i },
+    { name: 'Failure mode', pattern: /failure mode/i },
+    { name: 'Each red line is written', pattern: /each red line is written/i }
+]);
+const PEAKS_IDE_MARKERS = Object.freeze([
+    { name: 'For any consumer', pattern: /for any consumer of the v2 envelope/i },
+    { name: 'What this skill do', pattern: /what this skill do/i },
+    { name: 'General workflow-gating tool', pattern: /general workflow-gating tool/i }
+]);
+export const lintPeaksAuditRuntime = buildContract(PEAKS_AUDIT_MARKERS, 'peaks-audit');
+export const lintPeaksContentRuntime = buildContract(PEAKS_CONTENT_MARKERS, 'peaks-content');
+export const lintPeaksIdeRuntime = buildContract(PEAKS_IDE_MARKERS, 'peaks-ide');
+/** Doctor — single marker, often a one-line contract. */
+const PEAKS_DOCTOR_MARKERS = Object.freeze([
+    { name: 'peaks-loop doctor is a doctor orchestrator', pattern: /peaks-loop doctor is a doctor orchestrator/i }
+]);
+const PEAKS_ISSUE_FIX_ORCHESTRATOR_MARKERS = Object.freeze([
+    { name: 'Deviation note', pattern: /deviation note/i },
+    { name: 'Autonomous work proceed', pattern: /autonomous work proceed/i }
+]);
+const PEAKS_SOP_MARKERS = Object.freeze([
+    { name: 'Each red line below', pattern: /each red line below is written/i },
+    { name: 'sop lint reports findings', pattern: /sop lint reports findings/i }
+]);
+const PEAKS_SLICE_DECOMPOSE_MARKERS = Object.freeze([
+    { name: 'What this skill do', pattern: /what this skill do/i },
+    { name: 'Failure mode ( — read before declaring a', pattern: /failure mode \(/i }
+]);
+export const lintPeaksDoctorRuntime = buildContract(PEAKS_DOCTOR_MARKERS, 'peaks-doctor');
+export const lintPeaksIssueFixOrchestratorRuntime = buildContract(PEAKS_ISSUE_FIX_ORCHESTRATOR_MARKERS, 'peaks-issue-fix-orchestrator');
+export const lintPeaksSopRuntime = buildContract(PEAKS_SOP_MARKERS, 'peaks-sop');
+export const lintPeaksSliceDecomposeRuntime = buildContract(PEAKS_SLICE_DECOMPOSE_MARKERS, 'peaks-slice-decompose');

package/dist/services/audit/enforcers/lint-peaks-ui-sc-txt-runtime.d.ts

@@ -0,0 +1,28 @@
+/**
+ * P2-b sweep 007 — peaks-ui / peaks-txt / peaks-perf-audit runtime
+ * contract enforcers. Closes the remaining 6 discovered lines:
+ *
+ *  - peaks-ui-skill-md-X (3 lines):
+ *      identify ui involvement
+ *      superpowers chain refusal (L1 worktree governance)
+ *      superpowers skills remain available as reference material
+ *  - peaks-txt-skill-md-X (2 lines):
+ *      inspect upstream skill content before applying any method
+ *      memory block embedding rule
+ *  - peaks-perf-audit-skill-md-X (1 line):
+ *      MUST NOT invoke perf-audit for non-perf slices
+ *
+ * Four enforcers in one file (the runtime contract cluster):
+ *  - lintPeaksUiSuperpowersChain — both superpowers-refusal
+ *    + reference-material markers required.
+ *  - lintPeaksTxtUpstreamInspection — the inspect-upstream
+ *    + memory-block markers.
+ *  - lintPeaksPerfAuditScope — the non-perf MUST NOT.
+ *  - lintPeaksUiInvolvement — the ui-involvement identification
+ *    block (peaks-ui only).
+ */
+import type { LintHit, SkillFile } from './lint-style.js';
+export declare function lintPeaksUiSuperpowersChain(skill: SkillFile): ReadonlyArray<LintHit>;
+export declare function lintPeaksUiInvolvement(skill: SkillFile): ReadonlyArray<LintHit>;
+export declare function lintPeaksTxtUpstream(skill: SkillFile): ReadonlyArray<LintHit>;
+export declare function lintPeaksPerfAuditScope(skill: SkillFile): ReadonlyArray<LintHit>;

package/dist/services/audit/enforcers/lint-peaks-ui-sc-txt-runtime.js

@@ -0,0 +1,86 @@
+const SUPERPOWERS_REFUSAL = /MUST NOT follow the superpowers chain/i;
+const SUPERPOWERS_REFERENCE = /superpowers skills remain available as reference material/i;
+const UI_INVOLVEMENT = /identify ui involvement/i;
+const TXT_INSPECT_UPSTREAM = /inspect upstream skill content before applying any method/i;
+const TXT_MEMORY_BLOCK = /memory block embedding rule/i;
+const PERF_AUDIT_NON_PERF = /MUST NOT invoke this skill[\s\S]*?non-perf/i;
+export function lintPeaksUiSuperpowersChain(skill) {
+    if (skill.name !== 'peaks-ui')
+        return [];
+    const lines = skill.lines.length > 0
+        ? skill.lines
+        : skill.body.split(/\r?\n/);
+    const hasRefusal = lines.some((l) => SUPERPOWERS_REFUSAL.test(l));
+    const hasReference = lines.some((l) => SUPERPOWERS_REFERENCE.test(l));
+    if (hasRefusal && hasReference)
+        return [];
+    const missing = [];
+    if (!hasRefusal)
+        missing.push('MUST NOT follow the superpowers chain');
+    if (!hasReference)
+        missing.push('superpowers skills remain available as reference material');
+    return [{
+            catalogId: 'rl-peaks-ui-superpowers-chain-001',
+            rule: 'peaks-ui SKILL.md must declare the superpowers chain refusal + reference-material contract',
+            file: skill.path,
+            line: 1,
+            matchedText: `missing markers: ${missing.join(', ')}`
+        }];
+}
+export function lintPeaksUiInvolvement(skill) {
+    if (skill.name !== 'peaks-ui')
+        return [];
+    const lines = skill.lines.length > 0
+        ? skill.lines
+        : skill.body.split(/\r?\n/);
+    const hasInvolvement = lines.some((l) => UI_INVOLVEMENT.test(l));
+    if (hasInvolvement)
+        return [];
+    return [{
+            catalogId: 'rl-peaks-ui-involvement-001',
+            rule: 'peaks-ui SKILL.md must declare the UI-involvement identification block',
+            file: skill.path,
+            line: 1,
+            matchedText: 'missing "identify ui involvement" marker'
+        }];
+}
+export function lintPeaksTxtUpstream(skill) {
+    if (skill.name !== 'peaks-txt')
+        return [];
+    const lines = skill.lines.length > 0
+        ? skill.lines
+        : skill.body.split(/\r?\n/);
+    const hasInspect = lines.some((l) => TXT_INSPECT_UPSTREAM.test(l));
+    const hasMemoryBlock = lines.some((l) => TXT_MEMORY_BLOCK.test(l));
+    if (hasInspect && hasMemoryBlock)
+        return [];
+    const missing = [];
+    if (!hasInspect)
+        missing.push('inspect upstream skill content before applying any method');
+    if (!hasMemoryBlock)
+        missing.push('memory block embedding rule');
+    return [{
+            catalogId: 'rl-peaks-txt-upstream-001',
+            rule: 'peaks-txt SKILL.md must declare the upstream-inspection + memory-block contract',
+            file: skill.path,
+            line: 1,
+            matchedText: `missing markers: ${missing.join(', ')}`
+        }];
+}
+export function lintPeaksPerfAuditScope(skill) {
+    if (skill.name !== 'peaks-perf-audit')
+        return [];
+    const lines = skill.lines.length > 0
+        ? skill.lines
+        : skill.body.split(/\r?\n/);
+    const hasNonPerf = lines.some((l) => PERF_AUDIT_NON_PERF.test(l));
+    if (hasNonPerf)
+        return [];
+    return [{
+            catalogId: 'rl-peaks-perf-audit-scope-001',
+            rule: 'peaks-perf-audit SKILL.md must declare the non-perf MUST NOT invoke clause',
+            file: skill.path,
+            line: 1,
+            matchedText: 'missing "MUST NOT invoke this skill for non-perf slices" marker'
+        }];
+}

package/dist/services/audit/enforcers/lint-prd-artifact-handoff.d.ts

@@ -0,0 +1,16 @@
+/**
+ * P2-b sweep 004 — PRD artifact handoff enforcer.
+ *
+ * Closes three peaks-prd discovered lines (md-99, md-166, md-193):
+ *  - 99  : preserved behavior section in the PRD template
+ *  - 166 : "5.5 — write the immutable handoff" step
+ *  - 193 : "Transition verification gates" section
+ *
+ * The three are one logical contract (the PRD runbook must
+ * declare these handoff markers). A single enforcer scanning
+ * the SKILL.md for all three closes the cluster in one pass.
+ *
+ * scope: peaks-prd only.
+ */
+import type { LintHit, SkillFile } from './lint-style.js';
+export declare function lintPrdArtifactHandoff(skill: SkillFile): ReadonlyArray<LintHit>;

package/dist/services/audit/enforcers/lint-prd-artifact-handoff.js

@@ -0,0 +1,41 @@
+const PRESERVED_BEHAVIOR = /\bPreserved behavior\b/;
+const HANDOFF_STEP_5_5 = /5\.5\s*—\s*write the immutable handoff/im;
+const TRANSITION_GATES = /Transition verification gates/im;
+function findPrdHandoffContract(lines) {
+    let preserved = false;
+    let handoffStep = false;
+    let transitionGates = false;
+    for (const line of lines) {
+        if (PRESERVED_BEHAVIOR.test(line))
+            preserved = true;
+        if (HANDOFF_STEP_5_5.test(line))
+            handoffStep = true;
+        if (TRANSITION_GATES.test(line))
+            transitionGates = true;
+    }
+    return { preserved, handoffStep, transitionGates };
+}
+export function lintPrdArtifactHandoff(skill) {
+    if (skill.name !== 'peaks-prd')
+        return [];
+    const lines = skill.lines.length > 0
+        ? skill.lines
+        : skill.body.split(/\r?\n/);
+    const { preserved, handoffStep, transitionGates } = findPrdHandoffContract(lines);
+    if (preserved && handoffStep && transitionGates)
+        return [];
+    const missing = [];
+    if (!preserved)
+        missing.push('Preserved behavior');
+    if (!handoffStep)
+        missing.push('step 5.5 (write the immutable handoff)');
+    if (!transitionGates)
+        missing.push('Transition verification gates');
+    return [{
+            catalogId: 'rl-prd-artifact-handoff-001',
+            rule: 'peaks-prd SKILL.md must declare the artifact handoff contract (Preserved behavior + step 5.5 + Transition verification gates)',
+            file: skill.path,
+            line: 1,
+            matchedText: `missing markers: ${missing.join(', ')}`
+        }];
+}

package/dist/services/audit/enforcers/lint-prd-source-snapshot.d.ts

@@ -0,0 +1,27 @@
+/**
+ * P2-b sweep — PRD source-snapshot placement enforcer.
+ *
+ * Targets the BLOCKING markers around the peaks-prd
+ * "Document snapshot placement" + "Prohibited paths" guidance
+ * (rl-discovered-skills-bee-peaks-prd-skill-md-292 + 301).
+ * The contract: PRD source snapshots from external documents
+ * (Feishu / Lark / wiki / web) MUST go to
+ * `.peaks/_runtime/<sessionId>/prd/source/`, never to the
+ * project root.
+ *
+ * The enforcer pattern-scans the peaks-prd SKILL.md for the
+ * required guidance phrasing. Two hits (placement heading +
+  * prohibited-paths line) are both required for a clean
+ * enforcer pass. A single missing item emits a synthetic hit
+ * pointing at the line the user is most likely to look at
+ * (the placement heading line, or line 1 if missing).
+ *
+ * This is the second prose-only enforcer in the sweep
+ * (after lint-skill-presence-mandatory.ts). It demonstrates
+ * the path for the remaining 65 discovered lines: each
+ * enforcer is small, single-purpose, and has its own catalog
+ * entry. The catalog governance ratio will tick down with
+ * every enforcer shipped.
+ */
+import type { LintHit, SkillFile } from './lint-style.js';
+export declare function lintPrdSourceSnapshot(skill: SkillFile): ReadonlyArray<LintHit>;

package/dist/services/audit/enforcers/lint-prd-source-snapshot.js

@@ -0,0 +1,47 @@
+const PLACEMENT_HEADING = /^##\s+.*Document snapshot placement/im;
+const PROHIBITED_PATHS = /Prohibited paths/im;
+const SOURCE_SUBDIR = /\.peaks\/_runtime\/<session-id>\/prd\/source\//;
+function findPrdSourceSnapshotGuidance(lines) {
+    let placementLine = null;
+    let hasProhibited = false;
+    let hasSubdir = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? '';
+        if (PLACEMENT_HEADING.test(line)) {
+            placementLine = i + 1;
+            // Look ahead up to 30 lines for the prohibited-paths
+            // line + the source subdir reference.
+            for (let j = i; j < Math.min(i + 30, lines.length); j++) {
+                const next = lines[j] ?? '';
+                if (PROHIBITED_PATHS.test(next))
+                    hasProhibited = true;
+                if (SOURCE_SUBDIR.test(next))
+                    hasSubdir = true;
+            }
+            break;
+        }
+    }
+    return { placementLine, hasProhibited, hasSubdir };
+}
+export function lintPrdSourceSnapshot(skill) {
+    // Scope: peaks-prd only. Other bee skills do not have the
+    // source-snapshot contract.
+    if (skill.name !== 'peaks-prd')
+        return [];
+    const lines = skill.lines.length > 0
+        ? skill.lines
+        : skill.body.split(/\r?\n/);
+    const { placementLine, hasProhibited, hasSubdir } = findPrdSourceSnapshotGuidance(lines);
+    if (placementLine !== null && hasProhibited && hasSubdir)
+        return [];
+    const detail = placementLine === null
+        ? 'missing `## Document snapshot placement` heading'
+        : `placement heading at line ${placementLine} but guidance incomplete (prohibited=${hasProhibited}, subdir=${hasSubdir})`;
+    return [{
+            catalogId: 'rl-prd-source-snapshot-placement-001',
+            rule: 'PRD source-snapshot placement (BLOCKING): external-document snapshots must land in .peaks/_runtime/<sessionId>/prd/source/, never project root',
+            file: skill.path,
+            line: placementLine ?? 1,
+            matchedText: detail
+        }];
+}

package/dist/services/audit/enforcers/lint-qa-gateguard-and-runtime.d.ts

@@ -0,0 +1,19 @@
+/**
+ * P2-b sweep 006 — peaks-qa gateguard + runtime contract.
+ *
+ * Closes four peaks-qa discovered lines:
+ *  - md-26  : "Pre-flight: gateguard-fact-force conflict" (BLOCKING)
+ *  - md-113 : "Transition verification gates" (MANDATORY)
+ *  - md-165 : "if playwright mcp is unavailable, the llm checks" (BLOCKING)
+ *  - md-201 : "when the target repository has openspec/, qa must" (BLOCKING)
+ *
+ * Two enforcers:
+ *  - lintQaGateguardPreflight: peaks-qa only; checks the
+ *    gateguard-fact-force pre-flight heading.
+ *  - lintQaRuntimeContract: peaks-qa only; checks for
+ *    transition gates + playwright mcp handling + openspec
+ *    integration.
+ */
+import type { LintHit, SkillFile } from './lint-style.js';
+export declare function lintQaGateguardPreflight(skill: SkillFile): ReadonlyArray<LintHit>;
+export declare function lintQaRuntimeContract(skill: SkillFile): ReadonlyArray<LintHit>;

package/dist/services/audit/enforcers/lint-qa-gateguard-and-runtime.js

@@ -0,0 +1,47 @@
+const GATEGUARD_HEADING = /Pre-flight:\s*gateguard-fact-force conflict/im;
+const TRANSITION_GATES = /Transition verification gates/im;
+const PLAYWRIGHT_MCP = /if playwright mcp is unavailable/i;
+const OPENSPEC_INTEGRATION = /when the target repository has openspec\//i;
+export function lintQaGateguardPreflight(skill) {
+    if (skill.name !== 'peaks-qa')
+        return [];
+    const lines = skill.lines.length > 0
+        ? skill.lines
+        : skill.body.split(/\r?\n/);
+    const hasGateguard = lines.some((l) => GATEGUARD_HEADING.test(l));
+    if (hasGateguard)
+        return [];
+    return [{
+            catalogId: 'rl-qa-gateguard-preflight-001',
+            rule: 'peaks-qa SKILL.md must declare the `## Pre-flight: gateguard-fact-force conflict (BLOCKING)` section',
+            file: skill.path,
+            line: 1,
+            matchedText: 'missing gateguard pre-flight heading'
+        }];
+}
+export function lintQaRuntimeContract(skill) {
+    if (skill.name !== 'peaks-qa')
+        return [];
+    const lines = skill.lines.length > 0
+        ? skill.lines
+        : skill.body.split(/\r?\n/);
+    const hasTransition = lines.some((l) => TRANSITION_GATES.test(l));
+    const hasPlaywright = lines.some((l) => PLAYWRIGHT_MCP.test(l));
+    const hasOpenSpec = lines.some((l) => OPENSPEC_INTEGRATION.test(l));
+    if (hasTransition && hasPlaywright && hasOpenSpec)
+        return [];
+    const missing = [];
+    if (!hasTransition)
+        missing.push('Transition verification gates');
+    if (!hasPlaywright)
+        missing.push('Playwright MCP unavailability handling');
+    if (!hasOpenSpec)
+        missing.push('OpenSpec integration requirement');
+    return [{
+            catalogId: 'rl-qa-runtime-contract-001',
+            rule: 'peaks-qa SKILL.md must declare the runtime contract (transition gates + Playwright MCP + OpenSpec integration)',
+            file: skill.path,
+            line: 1,
+            matchedText: `missing markers: ${missing.join(', ')}`
+        }];
+}

package/dist/services/audit/enforcers/lint-rd-handoff-coverage.d.ts

@@ -0,0 +1,18 @@
+/**
+ * P2-b sweep 005 — peaks-rd handoff + coverage enforcers.
+ *
+ * Closes three peaks-rd discovered lines:
+ *  - md-121 : "do not hand off to QA without [tech-doc.md]" (BLOCKING)
+ *  - md-127 : "do not hand off to QA without a perf-baseline" (BLOCKING)
+ *  - md-162 : "100% coverage target on testable files is meaningful"
+ *
+ * Two enforcers (handoff + coverage). The handoff enforcer
+ * checks for both 'tech-doc' and 'perf-baseline' handoff
+ * markers; the coverage enforcer checks for the 100%-target
+ * phrasing + the no-coverage-padding rule.
+ *
+ * scope: peaks-rd only.
+ */
+import type { LintHit, SkillFile } from './lint-style.js';
+export declare function lintRdHandoffContract(skill: SkillFile): ReadonlyArray<LintHit>;
+export declare function lintRdCoverageDiscipline(skill: SkillFile): ReadonlyArray<LintHit>;

package/dist/services/audit/enforcers/lint-rd-handoff-coverage.js

@@ -0,0 +1,70 @@
+const TECH_DOC_HANDOFF = /do not hand off to qa without[^\n]*tech-doc/im;
+const PERF_BASELINE_HANDOFF = /do not hand off to qa without[^\n]*perf-baseline/im;
+const COVERAGE_TARGET = /100%\s*coverage target[^\n]*testable files/i;
+const NO_PADDING = /must not write coverage-padding tests/i;
+function findHandoffContract(lines) {
+    let techDoc = false;
+    let perfBaseline = false;
+    for (const line of lines) {
+        if (TECH_DOC_HANDOFF.test(line))
+            techDoc = true;
+        if (PERF_BASELINE_HANDOFF.test(line))
+            perfBaseline = true;
+    }
+    return { techDoc, perfBaseline };
+}
+function findCoverageContract(lines) {
+    let target = false;
+    let noPadding = false;
+    for (const line of lines) {
+        if (COVERAGE_TARGET.test(line))
+            target = true;
+        if (NO_PADDING.test(line))
+            noPadding = true;
+    }
+    return { target, noPadding };
+}
+export function lintRdHandoffContract(skill) {
+    if (skill.name !== 'peaks-rd')
+        return [];
+    const lines = skill.lines.length > 0
+        ? skill.lines
+        : skill.body.split(/\r?\n/);
+    const { techDoc, perfBaseline } = findHandoffContract(lines);
+    if (techDoc && perfBaseline)
+        return [];
+    const missing = [];
+    if (!techDoc)
+        missing.push('tech-doc handoff BLOCKING');
+    if (!perfBaseline)
+        missing.push('perf-baseline handoff BLOCKING');
+    return [{
+            catalogId: 'rl-rd-handoff-contract-001',
+            rule: 'peaks-rd SKILL.md must declare the QA-handoff BLOCKING contract (tech-doc + perf-baseline)',
+            file: skill.path,
+            line: 1,
+            matchedText: `missing markers: ${missing.join(', ')}`
+        }];
+}
+export function lintRdCoverageDiscipline(skill) {
+    if (skill.name !== 'peaks-rd')
+        return [];
+    const lines = skill.lines.length > 0
+        ? skill.lines
+        : skill.body.split(/\r?\n/);
+    const { target, noPadding } = findCoverageContract(lines);
+    if (target && noPadding)
+        return [];
+    const missing = [];
+    if (!target)
+        missing.push('100% coverage target (testable files) phrasing');
+    if (!noPadding)
+        missing.push('"must not write coverage-padding tests" rule');
+    return [{
+            catalogId: 'rl-rd-coverage-discipline-001',
+            rule: 'peaks-rd SKILL.md must declare the coverage discipline (100% target + no-padding rule)',
+            file: skill.path,
+            line: 1,
+            matchedText: `missing markers: ${missing.join(', ')}`
+        }];
+}

package/dist/services/audit/enforcers/lint-skill-presence-mandatory.d.ts

@@ -0,0 +1,25 @@
+/**
+ * P2-b (Slice #6+1) — Skill presence MANDATORY enforcer.
+ *
+ * Targets the `peaks-prd` / `peaks-rd` / `peaks-qa` SKILL.md
+ * "Skill presence (MANDATORY first action)" heading that the
+ * audit classified as `rl-discovered-skills-bee-peaks-prd-skill-md-56`
+ * (and the parallel peaks-rd / peaks-qa lines). The marker
+ * MANDATORY + the phrase "Skill presence" + "first action" are
+ * all required; if any of the three is missing on a `peaks-*`
+ * SKILL.md the enforcer emits a synthetic hit so the audit
+ * report can render the entry.
+ *
+ * This file is a single-purpose enforcer (one enforcerRef per
+ * catalog entry). It deliberately does NOT cover every
+ * discovered prose-only line — the next rid (catalog
+ * governance sweep) is the right place to add the rest. This
+ * commit's goal is to close the first one and prove the
+ * catalog-entry + enforcerRef + test path works end-to-end.
+ *
+ * No new deps. No shell-out. No FS writes. The enforcer
+ * function is sync + side-effect-free so the audit hot path
+ * stays fast.
+ */
+import type { LintHit, SkillFile } from './lint-style.js';
+export declare function lintSkillPresenceMandatory(skill: SkillFile): ReadonlyArray<LintHit>;

package/dist/services/audit/enforcers/lint-skill-presence-mandatory.js

@@ -0,0 +1,53 @@
+const SKILL_PRESENCE_HEADING = /^##\s+Skill presence\s*\([^)]*MANDATORY[^)]*first action\)/im;
+const SKILL_PRESENCE_BODY = /immediately run:/i;
+const MANDATORY_MARKER = /\bMANDATORY\b/;
+const TARGET_SKILL_PREFIX = 'peaks-';
+function findSkillPresenceSection(lines) {
+    let heading = null;
+    let bodyOk = false;
+    let hasMarker = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? '';
+        if (SKILL_PRESENCE_HEADING.test(line)) {
+            heading = i + 1;
+            // Look ahead up to 8 lines for the body / marker.
+            for (let j = i; j < Math.min(i + 8, lines.length); j++) {
+                const next = lines[j] ?? '';
+                if (SKILL_PRESENCE_BODY.test(next))
+                    bodyOk = true;
+                if (MANDATORY_MARKER.test(next))
+                    hasMarker = true;
+            }
+            break;
+        }
+    }
+    return { heading, bodyOk, hasMarker };
+}
+export function lintSkillPresenceMandatory(skill) {
+    // Scope: peaks-* bee SKILL.md. The path check is the primary
+    // gate; the name check is a defense-in-depth guard for callers
+    // that pass a skill whose name does not match its path
+    // (e.g. tests with a synthetic SkillFile).
+    if (!skill.path.includes('skills/bee/'))
+        return [];
+    if (!skill.name.startsWith(TARGET_SKILL_PREFIX))
+        return [];
+    // Reconstruct lines from body (the SkillFile interface exposes body
+    // and lines; for compatibility, prefer lines if non-empty).
+    const lines = skill.lines.length > 0
+        ? skill.lines
+        : skill.body.split(/\r?\n/);
+    const { heading, bodyOk, hasMarker } = findSkillPresenceSection(lines);
+    if (heading !== null && bodyOk && hasMarker)
+        return [];
+    const detail = heading === null
+        ? 'missing `## Skill presence (MANDATORY first action)` heading'
+        : `heading present at line ${heading} but body/marker incomplete (body=${bodyOk}, marker=${hasMarker})`;
+    return [{
+            catalogId: 'rl-skill-presence-mandatory-001',
+            rule: 'Skill presence (MANDATORY first action) — peaks-* bee SKILL.md must declare the section',
+            file: skill.path,
+            line: heading ?? 1,
+            matchedText: detail
+        }];
+}

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

@@ -12,10 +12,4 @@
  * discovery path as the P0 / P1 entries.
  */
 import type { RedLineCatalogEntry } from './red-line-catalog.js';
-/**
- * The 25 P2-a entries, in stable display order. Appending to a single
- * readonly array keeps the catalog growable: future slices (L2.4, L3.x)
- * can spread this list into RED_LINE_CATALOG and add their own without
- * touching this file.
- */
 export declare const RED_LINE_CATALOG_P2_A: readonly RedLineCatalogEntry[];