peaks-loop 4.0.0-beta.3 → 4.0.0-beta.30

package/dist/src/services/artifacts/workspace-service.js

@@ -1,272 +0,0 @@
-import { existsSync } from 'node:fs';
-import { Buffer } from 'node:buffer';
-import { resolve } from 'node:path';
-import { isInsidePath, stablePath } from '../../shared/path-utils.js';
-import { getWorkspaceConfig, getWorkspaceConfigForCurrentPath } from '../config/config-service.js';
-import { pathExists } from '../../shared/fs.js';
-import { execCommand } from '../../shared/process.js';
-function canonicalPath(path) {
-    return stablePath(path);
-}
-function canonicalChildPath(parentPath, ...segments) {
-    return stablePath(resolve(parentPath, ...segments));
-}
-export function getLocalArtifactPath(workspace) {
-    if (workspace.artifactStorage?.localPath) {
-        return resolve(workspace.artifactStorage.localPath);
-    }
-    return resolve(workspace.rootPath, '.peaks', 'artifacts');
-}
-export function isArtifactWorkspaceOutsideTarget(_workspace, _artifactWorkspacePath) {
-    return true;
-}
-export function hasValidArtifactWorkspace(workspace, artifactWorkspacePath = getLocalArtifactPath(workspace)) {
-    if (!isArtifactWorkspaceOutsideTarget(workspace, artifactWorkspacePath))
-        return false;
-    const artifactRoot = canonicalPath(artifactWorkspacePath);
-    const peaksRoot = canonicalChildPath(artifactWorkspacePath, '.peaks');
-    const changesRoot = canonicalChildPath(artifactWorkspacePath, '.peaks', 'changes');
-    const configPath = canonicalChildPath(artifactWorkspacePath, '.peaks', 'config.json');
-    if (!existsSync(resolve(artifactWorkspacePath, '.peaks', 'config.json')))
-        return false;
-    if (!isInsidePath(peaksRoot, artifactRoot))
-        return false;
-    if (!isInsidePath(changesRoot, artifactRoot))
-        return false;
-    if (!isInsidePath(configPath, artifactRoot))
-        return false;
-    return true;
-}
-export function getArtifactRemoteRepo(workspace) {
-    if (workspace.artifactStorage?.mode === 'local-with-remote-sync') {
-        return workspace.artifactStorage.remote;
-    }
-    if (workspace.artifactStorage?.mode === 'local') {
-        return null;
-    }
-    return workspace.artifactRepo ?? null;
-}
-function getPublicRemoteUrl(artifactRepo) {
-    if (!artifactRepo)
-        return null;
-    return artifactRepo.provider === 'github'
-        ? `https://github.com/${artifactRepo.owner}/${artifactRepo.name}.git`
-        : `https://gitlab.com/${artifactRepo.owner}/${artifactRepo.name}.git`;
-}
-function getGitAuthEnv(artifactRepo) {
-    if (!artifactRepo || artifactRepo.provider !== 'github')
-        return undefined;
-    const token = process.env.GH_TOKEN;
-    if (!token)
-        return undefined;
-    const authValue = Buffer.from(`x-access-token:${token}`, 'utf-8').toString('base64');
-    return {
-        ...process.env,
-        GIT_CONFIG_COUNT: '1',
-        GIT_CONFIG_KEY_0: 'http.https://github.com/.extraheader',
-        GIT_CONFIG_VALUE_0: `AUTHORIZATION: basic ${authValue}`
-    };
-}
-function redactSecrets(message) {
-    const token = process.env.GH_TOKEN;
-    const urlRedacted = message.replace(/https:\/\/x-access-token:[^@]+@/g, 'https://x-access-token:***@');
-    const headerRedacted = urlRedacted.replace(/AUTHORIZATION:\s*basic\s+[A-Za-z0-9+/=]+/gi, 'AUTHORIZATION: basic ***');
-    if (!token)
-        return headerRedacted;
-    const encoded = Buffer.from(`x-access-token:${token}`, 'utf-8').toString('base64');
-    return headerRedacted.replaceAll(token, '***').replaceAll(encoded, '***');
-}
-export async function executeArtifactSync(workspaceId) {
-    const workspace = workspaceId
-        ? getWorkspaceConfig(workspaceId)
-        : getWorkspaceConfigForCurrentPath();
-    if (!workspace) {
-        return {
-            workspaceId: workspaceId ?? 'unknown',
-            success: false,
-            localPath: '.peaks-artifacts',
-            remoteUrl: null,
-            commands: [],
-            output: [],
-            error: 'Workspace not found'
-        };
-    }
-    const localPath = getLocalArtifactPath(workspace);
-    if (!isArtifactWorkspaceOutsideTarget(workspace, localPath)) {
-        return {
-            workspaceId: workspace.workspaceId,
-            success: false,
-            localPath,
-            remoteUrl: null,
-            commands: [],
-            output: [],
-            error: 'Artifact workspace must be outside the target repository'
-        };
-    }
-    const artifactRepo = getArtifactRemoteRepo(workspace);
-    if (!artifactRepo) {
-        return {
-            workspaceId: workspace.workspaceId,
-            success: true,
-            localPath,
-            remoteUrl: null,
-            commands: [],
-            output: ['Local artifact storage is configured']
-        };
-    }
-    const remoteUrl = getPublicRemoteUrl(artifactRepo);
-    const gitAuthEnv = getGitAuthEnv(artifactRepo);
-    if (!remoteUrl) {
-        return {
-            workspaceId: workspace.workspaceId,
-            success: false,
-            localPath,
-            remoteUrl: null,
-            commands: [],
-            output: [],
-            error: 'Invalid artifact repository configuration'
-        };
-    }
-    const commands = [];
-    const output = [];
-    const hasLocalDir = await pathExists(localPath);
-    if (!hasLocalDir) {
-        commands.push(`git clone ${remoteUrl} "${localPath}"`);
-        try {
-            await execCommand('git', ['clone', remoteUrl, localPath], { env: gitAuthEnv });
-            output.push(`Cloned artifact repository to ${localPath}`);
-        }
-        catch (err) {
-            return {
-                workspaceId: workspace.workspaceId,
-                success: false,
-                localPath,
-                remoteUrl,
-                commands,
-                output,
-                error: `Clone failed: ${redactSecrets(err instanceof Error ? err.message : String(err))}`
-            };
-        }
-    }
-    else {
-        commands.push(`cd "${localPath}" && git fetch origin`);
-        commands.push(`cd "${localPath}" && git pull origin main`);
-        try {
-            await execCommand('git', ['fetch', 'origin'], { cwd: localPath, env: gitAuthEnv });
-            output.push('Fetched latest from remote');
-            await execCommand('git', ['pull', 'origin', 'main'], { cwd: localPath, env: gitAuthEnv });
-            output.push('Pulled latest changes');
-        }
-        catch (err) {
-            return {
-                workspaceId: workspace.workspaceId,
-                success: false,
-                localPath,
-                remoteUrl,
-                commands,
-                output,
-                error: `Sync failed: ${redactSecrets(err instanceof Error ? err.message : String(err))}`
-            };
-        }
-    }
-    return {
-        workspaceId: workspace.workspaceId,
-        success: true,
-        localPath,
-        remoteUrl,
-        commands,
-        output
-    };
-}
-export function getArtifactWorkspaceStatus(workspaceId) {
-    const workspace = workspaceId
-        ? getWorkspaceConfig(workspaceId)
-        : getWorkspaceConfigForCurrentPath();
-    if (!workspace) {
-        return {
-            workspaceId: workspaceId ?? 'unknown',
-            localPath: '.peaks-artifacts',
-            configured: false,
-            syncStatus: 'unknown',
-            lastSync: null,
-            hasLocalChanges: false,
-            artifactRepo: null,
-            nextActions: ['Add a workspace with: peaks config workspace add --id <id> --name <name> --path <path>']
-        };
-    }
-    const localPath = getLocalArtifactPath(workspace);
-    const hasLocalDir = existsSync(localPath);
-    const artifactRepo = getArtifactRemoteRepo(workspace);
-    const hasSafeBoundary = isArtifactWorkspaceOutsideTarget(workspace, localPath);
-    const syncStatus = !hasSafeBoundary
-        ? 'unknown'
-        : !hasLocalDir
-            ? 'pending'
-            : 'synced';
-    return {
-        workspaceId: workspace.workspaceId,
-        localPath,
-        configured: hasSafeBoundary,
-        syncStatus,
-        lastSync: null,
-        hasLocalChanges: false,
-        artifactRepo,
-        nextActions: !hasSafeBoundary
-            ? ['Configure artifact workspace outside the target repository.']
-            : artifactRepo
-                ? [`Run peaks artifacts sync --workspace ${workspace.workspaceId} --dry-run`]
-                : [`Local artifact storage ready at ${localPath}`]
-    };
-}
-export function planArtifactSync(workspaceId, dryRun = true) {
-    const workspace = workspaceId
-        ? getWorkspaceConfig(workspaceId)
-        : getWorkspaceConfigForCurrentPath();
-    if (!workspace) {
-        return {
-            workspaceId: workspaceId ?? 'unknown',
-            dryRun,
-            localPath: '.peaks-artifacts',
-            remoteUrl: null,
-            plannedCommands: ['No artifact repo configured — add one with peaks config workspace add --provider github --repo-owner <owner> --repo-name <name>']
-        };
-    }
-    const localPath = getLocalArtifactPath(workspace);
-    if (!isArtifactWorkspaceOutsideTarget(workspace, localPath)) {
-        return {
-            workspaceId: workspace.workspaceId,
-            dryRun,
-            localPath,
-            remoteUrl: null,
-            plannedCommands: ['Artifact workspace must be outside the target repository']
-        };
-    }
-    const artifactRepo = getArtifactRemoteRepo(workspace);
-    const remoteUrl = getPublicRemoteUrl(artifactRepo);
-    const plannedCommands = artifactRepo
-        ? dryRun
-            ? [
-                `# Sync plan for workspace ${workspace.workspaceId}`,
-                `# Local: ${localPath}`,
-                `# Remote: ${remoteUrl}`,
-                '# peaks artifacts sync --workspace ' + workspace.workspaceId,
-                '# (dry-run only — no changes made)'
-            ]
-            : [
-                `# Sync execution for workspace ${workspace.workspaceId}`,
-                `# Confirm: will sync ${localPath} with ${remoteUrl}`,
-                '# Exit 1 if not confirmed'
-            ]
-        : [
-            `# Local artifact storage for workspace ${workspace.workspaceId}`,
-            `# Local: ${localPath}`,
-            '# No remote repository is configured or required'
-        ];
-    return {
-        workspaceId: workspace.workspaceId,
-        dryRun,
-        localPath,
-        remoteUrl,
-        plannedCommands
-    };
-}

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-independent/perf-audit-service.d.ts

@@ -1,151 +0,0 @@
-/**
- * peaks-perf-audit service — independent performance audit skill driver.
- *
- * Slice v2.12.0 (Group A, Tier 3). Symmetric to security-audit-service.ts:
- *   - 5-state detection of the perf-audit runtime
- *   - Loading + sha256 verification of the prd/handoff.md
- *   - Loading the project-level perf-template.md
- *   - Producing the audit envelope (verdict + violations) to write
- *     to `.peaks/_runtime/<sid>/audit/perf-<rid>.md`
- *
- * The actual LLM-in-loop audit step is NOT in this service — the
- * parent LLM (peaks-perf-audit skill prompt) reads the template,
- * runs the audit, and returns a structured envelope. This service
- * is the pure I/O + validation core; the LLM is the judgement core.
- *
- * Cross-references:
- *   - PRD: `.peaks/_runtime/<sid>/prd/handoff.md` (sha256-locked, schemaVersion: 2)
- *   - Template: `.peaks/project-scan/perf-template.md`
- *   - Output: `.peaks/_runtime/<sid>/audit/perf-<rid>.md`
- *   - Schema: `.peaks/project-scan/audit-output-schema.md` (schemaVersion: 1)
- *   - Companion: `src/services/audit-independent/security-audit-service.ts`
- */
-/**
- * 5-state detection result. Mirrors `SecurityAuditDetectState` and
- * the ecc-bridge `detectEcc` shape (slice 7 Group D).
- *
- *   - `ready`              — handoff + template + project all present
- *   - `handoff-missing`    — `.peaks/_runtime/<sid>/prd/handoff.md` absent
- *   - `template-missing`   — `.peaks/project-scan/perf-template.md` absent
- *   - `dispatch-failed`    — parent LLM threw before returning the audit envelope
- *   - `envelope-malformed` — parent LLM returned a value that fails `isPerfAuditEnvelope`
- */
-export type PerfAuditDetectState = 'ready' | 'handoff-missing' | 'template-missing' | 'dispatch-failed' | 'envelope-malformed';
-export interface PerfAuditDetectResult {
-    readonly state: PerfAuditDetectState;
-    readonly handoffPresent: boolean;
-    readonly templatePresent: boolean;
-    readonly warnings: readonly string[];
-    readonly nextActions: readonly string[];
-}
-export type PerfAuditVerdict = 'pass' | 'warn' | 'block';
-export interface PerfAuditViolation {
-    readonly dimension: string;
-    readonly severity: 'CRITICAL' | 'HIGH' | 'MED' | 'LOW';
-    readonly file: string;
-    readonly line: number;
-    readonly hint: string;
-}
-export interface PerfAuditEnvelope {
-    readonly verdict: PerfAuditVerdict;
-    readonly violations: ReadonlyArray<PerfAuditViolation>;
-    readonly summary: string;
-}
-/**
- * Validate a raw value as a PerfAuditEnvelope. Mirrors the
- * `isSecurityAuditEnvelope` strict-shape pattern.
- */
-export declare function isPerfAuditEnvelope(value: unknown): value is PerfAuditEnvelope;
-/**
- * Handoff frontmatter — minimal projection of peaks-prd v2.11.0 handoff
- * frontmatter. We only need sha256 for verification; the rest of the
- * handoff body is consumed by the parent LLM, not by this service.
- *
- * Symmetric to `HandoffFrontmatter` in `security-audit-service.ts`.
- * We duplicate the type (rather than share) so the two services
- * can be independently type-evolved.
- */
-export interface HandoffFrontmatter {
-    readonly sha256: string;
-    readonly schemaVersion: number;
-}
-/**
- * Read the peaks-prd handoff frontmatter + body, verify sha256 matches
- * the body. Returns null on missing file or sha256 mismatch; otherwise
- * returns the parsed frontmatter + body string.
- *
- * Defensive: we read frontmatter via a 1-line regex match, not via
- * a YAML parser. The handoff service (`src/services/prd/handoff-service.ts`)
- * is the canonical writer; we only consume its output here.
- */
-export declare function readAndVerifyHandoff(handoffPath: string, projectRoot: string): {
-    frontmatter: HandoffFrontmatter;
-    body: string;
-} | null;
-/**
- * Read the project-level perf-template.md. Returns the body
- * string (with frontmatter stripped) or null if the file is absent.
- * Does NOT validate the template content; the parent LLM validates
- * by reading.
- */
-export declare function readPerfTemplate(projectRoot: string): string | null;
-/**
- * 5-state detector. The parent skill inspects the state and either
- * proceeds (when `ready`) or records a degradation note and falls
- * back (when any other state).
- *
- * Soft-fail policy mirrors `detectEcc` (slice 7 Group D) and
- * `detectSecurityAudit`: the CLI never throws; it returns a typed
- * detect result.
- */
-export declare function detectPerfAudit(input: {
-    readonly projectRoot: string;
-    readonly sessionId: string;
-    readonly dispatchError?: unknown;
-    readonly envelope?: unknown;
-}): PerfAuditDetectResult;
-/**
- * Render a PerfAuditEnvelope to the canonical audit artifact body
- * (markdown). Mirrors `renderSecurityAuditArtifact` in
- * `security-audit-service.ts` and `adaptEccEnvelopeToRdCodeReview`
- * in ecc-bridge.ts: produce a markdown body with all required
- * sections, ready to write to
- * `.peaks/_runtime/<sid>/audit/perf-<rid>.md`.
- */
-export declare function renderPerfAuditArtifact(env: PerfAuditEnvelope, opts: {
-    rid: string;
-    handoffHash: string;
-    generatedAt: string;
-}): {
-    body: string;
-    violationsCount: number;
-    verdict: PerfAuditVerdict;
-};
-/**
- * Write the rendered audit artifact to
- * `.peaks/_runtime/<sid>/audit/perf-<rid>.md`.
- *
- * Atomic write (tmp + rename) to avoid partial writes on crash.
- * Returns the absolute path on success.
- */
-export declare function writePerfAuditArtifact(projectRoot: string, sessionId: string, rid: string, body: string): string;
-/**
- * Convenience: run `detectPerfAudit` + `renderPerfAuditArtifact`
- * + `writePerfAuditArtifact` in one call.
- *
- * Returns `{ detect, artifactPath, violationsCount, verdict }` or
- * `{ detect, artifactPath: null, ... }` when not ready.
- */
-export declare function runPerfAudit(input: {
-    readonly projectRoot: string;
-    readonly sessionId: string;
-    readonly rid: string;
-    readonly generatedAt: string;
-    readonly dispatchError?: unknown;
-    readonly envelope?: unknown;
-}): {
-    detect: PerfAuditDetectResult;
-    artifactPath: string | null;
-    violationsCount: number;
-    verdict: PerfAuditVerdict | null;
-};