peaks-loop 4.0.0-beta.8 → 4.0.1

package/dist/services/audit/red-line-catalog-p2-b.js

@@ -0,0 +1,225 @@
+/** Theme H — Reference structural shape (3 enforcers) */
+const REF_H1_TITLE_REQUIRED = {
+    id: 'rl-ref-h1-title-required-001',
+    rule: 'Reference shape: every references/*.md starts with `# <title>`',
+    markers: ['MANDATORY'],
+    phrases: ['# ', 'h1 title', 'top heading'],
+    enforcerRef: 'src/services/audit/enforcers/lint-reference-shape.ts',
+};
+const REF_APPLICABLE_TASK_LEVELS = {
+    id: 'rl-ref-applicable-task-levels-declared-001',
+    rule: 'Reference shape: every references/*.md declares applicableTaskLevels',
+    markers: ['MANDATORY'],
+    phrases: ['applicable task levels', 'applies to', 'task levels:'],
+    enforcerRef: 'src/services/audit/enforcers/lint-reference-shape.ts',
+};
+const REF_SEE_ALSO_SECTION = {
+    id: 'rl-ref-see-also-section-001',
+    rule: 'Reference shape: every references/*.md has a `## See also` section',
+    markers: ['MANDATORY'],
+    phrases: ['see also', 'related references', '## see also'],
+    enforcerRef: 'src/services/audit/enforcers/lint-reference-shape.ts',
+};
+/** Theme I — Reference cross-references (3 enforcers) */
+const REF_CROSS_REF_RESOLVES = {
+    id: 'rl-ref-cross-ref-resolves-001',
+    rule: 'Reference integrity: every `../<file>.md` link from a reference resolves',
+    markers: ['MANDATORY'],
+    phrases: ['cross-reference', 'see also', 'see ./'],
+    enforcerRef: 'src/services/audit/enforcers/lint-reference-shape.ts',
+};
+const REF_NO_SELF_REFERENCE = {
+    id: 'rl-ref-no-self-reference-001',
+    rule: 'Reference integrity: no reference file links to itself',
+    markers: ['MUST NOT'],
+    phrases: ['self reference', 'circular reference', 'recursive link'],
+    enforcerRef: 'src/services/audit/enforcers/lint-reference-shape.ts',
+};
+const REF_NO_ORPHAN_LINK = {
+    id: 'rl-ref-no-orphan-link-001',
+    rule: 'Reference integrity: no link to a non-existent file or section',
+    markers: ['MUST NOT'],
+    phrases: ['orphan link', 'broken link', 'dead link'],
+    enforcerRef: 'src/services/audit/enforcers/lint-reference-shape.ts',
+};
+/** Theme J — Reference size + structure (3 enforcers) */
+const REF_LINE_COUNT_LE_800 = {
+    id: 'rl-ref-line-count-le-800-001',
+    rule: 'Reference size: each reference ≤ 800 lines (Karpathy Guidelines §2 Simplicity First)',
+    markers: ['MANDATORY'],
+    phrases: ['800 lines', 'line count', 'karpathy cap', 'file size'],
+    enforcerRef: 'src/services/audit/enforcers/lint-reference-shape.ts',
+};
+const REF_H2_COUNT_LE_12 = {
+    id: 'rl-ref-h2-count-le-12-001',
+    rule: 'Reference size: at most 12 `## <heading>` per reference',
+    markers: ['MANDATORY'],
+    phrases: ['h2 count', '12 h2', 'depth cap'],
+    enforcerRef: 'src/services/audit/enforcers/lint-reference-shape.ts',
+};
+const REF_OVERVIEW_SECTION_NEAR_TOP = {
+    id: 'rl-ref-overview-section-near-top-001',
+    rule: 'Reference size: long references (>200 lines) must have `## Overview` within the first 30 lines',
+    markers: ['MANDATORY'],
+    phrases: ['overview section', 'top of file', '## overview'],
+    enforcerRef: 'src/services/audit/enforcers/lint-reference-shape.ts',
+};
+/** Theme K — loadStrategy behavior (2 enforcers) */
+const REF_LOADSTRATEGY_ON_DEMAND_FALLBACK = {
+    id: 'rl-ref-loadstrategy-on-demand-fallback-001',
+    rule: 'loadStrategy: on-demand references must declare a fallback path',
+    markers: ['MANDATORY'],
+    phrases: ['on-demand fallback', 'fallback path', 'loadstrategy: on-demand'],
+    enforcerRef: 'src/services/audit/enforcers/lint-reference-shape.ts',
+};
+const REF_LOADSTRATEGY_ALWAYS_CACHEABLE = {
+    id: 'rl-ref-loadstrategy-always-cacheable-001',
+    rule: 'loadStrategy: always references must be safe to load unconditionally',
+    markers: ['MANDATORY'],
+    phrases: ['always-cacheable', 'unconditional load', 'loadstrategy: always'],
+    enforcerRef: 'src/services/audit/enforcers/lint-reference-shape.ts',
+};
+/** Theme L — Audit regression (4 enforcers) */
+const AUDIT_CATALOG_STABILITY = {
+    id: 'rl-audit-catalog-stability-001',
+    rule: 'Audit regression: catalog size has not grown > 20% in the last 90 days',
+    markers: ['MANDATORY'],
+    phrases: ['catalog stability', 'catalog growth', 'catalog drift'],
+    enforcerRef: 'src/services/audit/enforcers/lint-audit-regression.ts',
+};
+const AUDIT_NO_ORPHAN_ENFORCER = {
+    id: 'rl-audit-no-orphan-enforcer-001',
+    rule: 'Audit regression: every enforcerRef points to a real file',
+    markers: ['MUST NOT'],
+    phrases: ['orphan enforcer', 'missing enforcer file', 'enforcerref'],
+    enforcerRef: 'src/services/audit/enforcers/lint-audit-regression.ts',
+};
+const AUDIT_NO_ORPHAN_CATALOG = {
+    id: 'rl-audit-no-orphan-catalog-001',
+    rule: 'Audit regression: every catalog entry has a non-null enforcerRef (or a documented reason)',
+    markers: ['MUST NOT'],
+    phrases: ['orphan catalog', 'prose-only entry', 'enforcerref: null'],
+    enforcerRef: 'src/services/audit/enforcers/lint-audit-regression.ts',
+};
+const AUDIT_RUNTIME_BUDGET = {
+    id: 'rl-audit-runtime-budget-001',
+    rule: 'Audit regression: peaks audit red-lines completes in < 2 seconds on a 100-reference project',
+    markers: ['MANDATORY'],
+    phrases: ['runtime budget', 'audit performance', '2 second budget'],
+    enforcerRef: 'src/services/audit/enforcers/lint-audit-regression.ts',
+};
+/** Theme M — Inline shell patterns (3 enforcers) */
+const REF_NO_BASH_HEREDOC = {
+    id: 'rl-ref-no-bash-heredoc-001',
+    rule: 'Reference inline shell: no `cat <<EOF` (YAGNI for the demo skill)',
+    markers: ['MUST NOT'],
+    phrases: ['bash heredoc', 'cat <<eof', 'heredoc pattern'],
+    enforcerRef: 'src/services/audit/enforcers/lint-reference-shape.ts',
+};
+const REF_NO_SUDO = {
+    id: 'rl-ref-no-sudo-001',
+    rule: 'Reference inline shell: no `sudo` (peaks-loop is user-scope)',
+    markers: ['MUST NOT'],
+    phrases: ['no sudo', 'user-scope', 'sudo command'],
+    enforcerRef: 'src/services/audit/enforcers/lint-reference-shape.ts',
+};
+const REF_NO_CURL_PIPE_BASH = {
+    id: 'rl-ref-no-curl-pipe-bash-001',
+    rule: 'Reference inline shell: no `curl ... | bash` (LLM supply-chain attack vector)',
+    markers: ['MUST NOT'],
+    phrases: ['curl pipe bash', 'remote code execution', 'supply-chain'],
+    enforcerRef: 'src/services/audit/enforcers/lint-reference-shape.ts',
+};
+/** Theme N — Code blocks (3 enforcers) */
+const REF_CODE_BLOCK_LANGUAGE = {
+    id: 'rl-ref-code-block-language-declared-001',
+    rule: 'Reference code blocks: every fenced block has a language tag',
+    markers: ['MANDATORY'],
+    phrases: ['fenced code block', 'language tag', 'typescript | bash | json'],
+    enforcerRef: 'src/services/audit/enforcers/lint-reference-shape.ts',
+};
+const REF_NO_FAKE_PROMPT = {
+    id: 'rl-ref-no-fake-prompt-001',
+    rule: 'Reference code blocks: no `# fake prompt` / `$ fake` markers',
+    markers: ['MUST NOT'],
+    phrases: ['fake prompt', 'placeholder code', 'demo marker'],
+    enforcerRef: 'src/services/audit/enforcers/lint-reference-shape.ts',
+};
+const REF_NO_ABSOLUTE_PATHS = {
+    id: 'rl-ref-no-absolute-paths-001',
+    rule: 'Reference code blocks: no `C:\\` or `/usr/local` (use peaks-loop primitives)',
+    markers: ['MUST NOT'],
+    phrases: ['absolute path', 'c:\\', '/usr/local', 'machine-specific'],
+    enforcerRef: 'src/services/audit/enforcers/lint-reference-shape.ts',
+};
+/** Theme O — Permissions + numbers (2 enforcers) */
+const REF_NO_CHMOD_777 = {
+    id: 'rl-ref-no-chmod-777-001',
+    rule: 'Reference inline shell: no `chmod 777` (security red flag)',
+    markers: ['MUST NOT'],
+    phrases: ['chmod 777', 'world-writable', 'insecure permission'],
+    enforcerRef: 'src/services/audit/enforcers/lint-reference-shape.ts',
+};
+const REF_NO_MAGIC_NUMBERS = {
+    id: 'rl-ref-no-magic-numbers-001',
+    rule: 'Reference code blocks: no unsigned integer ≥ 100 that is not a named constant',
+    markers: ['MUST NOT'],
+    phrases: ['magic number', 'named constant', 'hard-coded threshold'],
+    enforcerRef: 'src/services/audit/enforcers/lint-reference-shape.ts',
+};
+/** Theme P — Dogfooding (2 enforcers) */
+const REF_SKILL_CITES_EVERY_EXISTING = {
+    id: 'rl-ref-skill-cites-every-existing-reference-001',
+    rule: 'Reference dogfooding: every reference file IS cited in its parent SKILL.md',
+    markers: ['MANDATORY'],
+    phrases: ['uncited reference', 'dead reference', 'reference not cited'],
+    enforcerRef: 'src/services/audit/enforcers/lint-reference-shape.ts',
+};
+const REF_LOADSTRATEGY_MATCHES_SIZE = {
+    id: 'rl-ref-loadstrategy-matches-size-001',
+    rule: 'Reference dogfooding: loadStrategy matches file size (>5KB → on-demand)',
+    markers: ['MANDATORY'],
+    phrases: ['loadstrategy matches size', 'context budget', 'on-demand for large'],
+    enforcerRef: 'src/services/audit/enforcers/lint-reference-shape.ts',
+};
+/**
+ * The 25 P2-b entries, in stable display order. Spread into
+ * RED_LINE_CATALOG (after P2-a's block) so future slices can
+ * append without touching this file.
+ */
+export const RED_LINE_CATALOG_P2_B = [
+    // Theme H
+    REF_H1_TITLE_REQUIRED,
+    REF_APPLICABLE_TASK_LEVELS,
+    REF_SEE_ALSO_SECTION,
+    // Theme I
+    REF_CROSS_REF_RESOLVES,
+    REF_NO_SELF_REFERENCE,
+    REF_NO_ORPHAN_LINK,
+    // Theme J
+    REF_LINE_COUNT_LE_800,
+    REF_H2_COUNT_LE_12,
+    REF_OVERVIEW_SECTION_NEAR_TOP,
+    // Theme K
+    REF_LOADSTRATEGY_ON_DEMAND_FALLBACK,
+    REF_LOADSTRATEGY_ALWAYS_CACHEABLE,
+    // Theme L
+    AUDIT_CATALOG_STABILITY,
+    AUDIT_NO_ORPHAN_ENFORCER,
+    AUDIT_NO_ORPHAN_CATALOG,
+    AUDIT_RUNTIME_BUDGET,
+    // Theme M
+    REF_NO_BASH_HEREDOC,
+    REF_NO_SUDO,
+    REF_NO_CURL_PIPE_BASH,
+    // Theme N
+    REF_CODE_BLOCK_LANGUAGE,
+    REF_NO_FAKE_PROMPT,
+    REF_NO_ABSOLUTE_PATHS,
+    // Theme O
+    REF_NO_CHMOD_777,
+    REF_NO_MAGIC_NUMBERS,
+    // Theme P
+    REF_SKILL_CITES_EVERY_EXISTING,
+    REF_LOADSTRATEGY_MATCHES_SIZE,
+];

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

@@ -0,0 +1,51 @@
+/**
+ * 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-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 (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/services/audit/red-line-catalog.js

@@ -0,0 +1,195 @@
+/**
+ * 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-code-ban-001',
+        rule: 'Code Commit Ban',
+        markers: ['BLOCKING', 'MANDATORY'],
+        phrases: [
+            'peaks-code',
+            'orchestrator, NOT an implementer',
+            'code',
+        ],
+        enforcerRef: 'src/services/audit/enforcers/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 (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/services/audit/red-lines-service.d.ts

@@ -0,0 +1,23 @@
+/**
+ * red-lines-service — main entry. Orchestrates the three tree scanners,
+ * the classifier, and the backing detector, then assembles the final
+ * RedLineAudit envelope.
+ *
+ * Pipeline (per openspec/changes/2026-06-11-l2-1-redlines-audit/design.md):
+ *   1. Run all 3 scanners in parallel (skills, rules, openspec)
+ *   2. Classifier turns MarkdownLine[] into RedLineEntry[]
+ *   3. Backing detector re-classifies each entry (cli-backed vs partial vs prose-only)
+ *   4. Tally + return RedLineAudit
+ *
+ * Sub-agent-sid enforcer (Task 2) is also invoked here: it dogfoods Slice 0.5
+ * sid-naming-guard and adds any invalid sids as warnings.
+ */
+import type { RedLineAudit, ScanWarning } from './types.js';
+export interface RedLinesServiceInput {
+    readonly projectRoot: string;
+}
+export interface RedLinesServiceResult {
+    readonly audit: RedLineAudit;
+    readonly warnings: readonly ScanWarning[];
+}
+export declare function runRedLinesAudit(input: RedLinesServiceInput): RedLinesServiceResult;