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

package/dist/src/services/rd/rd-service.js

@@ -1,438 +0,0 @@
-import { closeSync, fstatSync, lstatSync, openSync, readSync, statSync } from 'node:fs';
-import { isAbsolute, join, relative, resolve } from 'node:path';
-import { stableRealPath } from '../../shared/path-utils.js';
-import { WORKSPACE_UNAVAILABLE_NEXT_ACTIONS } from '../../shared/planner-response.js';
-import { getLocalArtifactPath, hasValidArtifactWorkspace } from '../artifacts/workspace-service.js';
-import { getSessionDir } from '../session/getSessionDir.js';
-import { getConfiguredExecutionModelId, STRONGEST_MODEL_ID } from '../config/model-routing.js';
-/**
- * 2.0.1-bug1: the slim 2.0 `~/.peaks/config.json` no longer carries a
- * `providers` block (legacy model config lives in
- * `.peaks/preferences.json` per spec §10.4). `buildPlan` is a pure
- * planner function and historically took its execution model from
- * `DEFAULT_CONFIG.providers.minimax.model`; with the slim default
- * that field is `undefined`, so `getConfiguredExecutionModelId`
- * would throw. We retain the pre-2.0 default here as a literal so
- * the planner remains usable when the caller has not passed an
- * explicit `executionModelId` (unit tests, dry-run previews, the
- * `peaks swarm plan` onboarding path). Production callers that
- * have a real `ocr.llm.model` configured pass it via
- * `request.executionModelId` (or via the legacy preferences.json
- * bridge) and bypass this fallback.
- */
-const DEFAULT_EXECUTION_MODEL_ID = 'minimax-2.7';
-import { getTechStatus, TECH_REQUIRED_ARTIFACTS } from '../tech/tech-service.js';
-import { resolveRdStartupStandardsCheck } from './standards-diagnostic.js';
-import { runStrategicStage } from './strategic-stage.js';
-import { runTacticalStage } from './tactical-stage.js';
-/**
- * Plan 3 — sub-stage entry points (strategic + tactical).
- * The existing `createRdSwarmPlan` / swarm-planner surface is unchanged;
- * these thin re-exports give callers a single-import path into the
- * strategic + tactical sub-stages.
- */
-export const runStrategic = runStrategicStage;
-export const runTactical = runTacticalStage;
-function normalizeGoal(goal) {
-    const normalized = goal.trim();
-    if (!normalized) {
-        throw new Error('Goal must be non-empty');
-    }
-    return normalized;
-}
-function isClearLowRiskGoal(goal) {
-    return /^fix\b/i.test(goal) && /\b(typo|spelling|comment|docs?|test|lint|format|copy)\b/i.test(goal);
-}
-const MIN_SAFE_SWARM_WORKERS = 25;
-const MAX_SAFE_SWARM_WORKERS = 80;
-function resolveWorkerTarget(maxWorkers) {
-    if (!Number.isInteger(maxWorkers) || maxWorkers < 1) {
-        throw new Error('max-workers must be a positive integer');
-    }
-    if (maxWorkers < MIN_SAFE_SWARM_WORKERS) {
-        return { workerTarget: maxWorkers, blockedReasons: ['worker-count-below-target'] };
-    }
-    if (maxWorkers > MAX_SAFE_SWARM_WORKERS) {
-        return { workerTarget: MAX_SAFE_SWARM_WORKERS, blockedReasons: ['worker-count-capped'] };
-    }
-    return { workerTarget: maxWorkers, blockedReasons: [] };
-}
-function resolveArtifactWorkspacePath(request) {
-    return request.artifactWorkspacePath ?? (request.workspace ? getLocalArtifactPath(request.workspace) : undefined);
-}
-function hasPlannerArtifactWorkspace(request, artifactWorkspacePath) {
-    return !!request.workspace && !!artifactWorkspacePath && hasValidArtifactWorkspace(request.workspace, artifactWorkspacePath);
-}
-function buildTaskIds(workerTarget) {
-    const fixed = [
-        'rd-discovery-1', 'rd-discovery-2', 'rd-discovery-3', 'rd-discovery-4', 'rd-discovery-5', 'rd-discovery-6', 'rd-discovery-7', 'rd-discovery-8',
-        'rd-planning-1', 'rd-planning-2', 'rd-planning-3', 'rd-planning-4', 'rd-planning-5', 'rd-planning-6', 'rd-planning-7', 'rd-planning-8',
-        'rd-test-1', 'rd-test-2', 'rd-test-3',
-        'peaks-qa-1', 'peaks-qa-2', 'peaks-qa-3', 'peaks-qa-4',
-        'rd-reducer-1',
-    ];
-    const implementationCount = Math.max(workerTarget - fixed.length, 1);
-    const implementation = Array.from({ length: implementationCount }, (_, index) => `rd-impl-${String(index + 1).padStart(3, '0')}`);
-    return [...fixed.slice(0, 16), ...implementation, ...fixed.slice(16)];
-}
-function isInsidePath(childPath, parentPath) {
-    const relativePath = relative(parentPath, childPath);
-    return relativePath === '' || (!relativePath.startsWith('..') && !isAbsolute(relativePath));
-}
-function isSafeRepoRelativePath(candidate) {
-    if (!candidate || candidate.includes('\\') || candidate.startsWith('/') || /^[A-Za-z]:/.test(candidate) || candidate.includes(':') || isAbsolute(candidate)) {
-        return false;
-    }
-    return candidate.split('/').every((segment) => segment.length > 0 && segment !== '.' && segment !== '..');
-}
-function extractCandidatePath(line) {
-    const trimmed = line.trim().replace(/^[-*+]\s+/, '').trim();
-    const codeSpan = trimmed.match(/^`([^`]+)`(?:\s|$)/);
-    const firstToken = trimmed.split(/\s+/)[0];
-    const candidate = codeSpan === null ? firstToken : codeSpan[1];
-    const normalized = candidate.replace(/[),.;:]+$/, '');
-    return normalized.length > 0 ? normalized : null;
-}
-function extractImplementationTargetAreas(content) {
-    const lines = content.split(/\r?\n/);
-    const sectionStart = lines.findIndex((line) => /^#{0,6}\s*Implementation target areas\s*:?\s*$/i.test(line.trim()));
-    if (sectionStart === -1) {
-        return [];
-    }
-    const sectionLines = lines.slice(sectionStart + 1);
-    const sectionEnd = sectionLines.findIndex((line) => /^#{1,6}\s+\S/.test(line.trim()));
-    return (sectionEnd === -1 ? sectionLines : sectionLines.slice(0, sectionEnd))
-        .map(extractCandidatePath)
-        .filter((candidate) => candidate !== null)
-        .filter((candidate) => /^(?:packages|src|tests|apps|libs)\//.test(candidate))
-        .filter(isSafeRepoRelativePath);
-}
-function hasConcreteTargetAreas(targetAreas) {
-    return targetAreas.length > 0;
-}
-function selectConcreteTargetArea(targetAreas, index) {
-    return targetAreas[index % targetAreas.length];
-}
-function getTaskModelRole(wave) {
-    return wave === 'implementation candidates' || wave === 'unit-test execution' ? 'execution' : 'strongest';
-}
-function getTaskModelId(modelRole, executionModelId) {
-    return modelRole === 'execution' ? executionModelId : STRONGEST_MODEL_ID;
-}
-const MAX_ARTIFACT_BYTES = 256_000;
-function readArtifactFile(rootPath, artifactWorkspacePath, artifact) {
-    const artifactPath = resolve(rootPath, artifact);
-    try {
-        const artifactWorkspaceRealPath = stableRealPath(artifactWorkspacePath);
-        const rootRealPath = stableRealPath(rootPath);
-        const rdRootPath = resolve(rootPath, '..');
-        const sessionRootPath = resolve(rdRootPath, '..');
-        if (lstatSync(sessionRootPath).isSymbolicLink() || lstatSync(rdRootPath).isSymbolicLink() || lstatSync(rootPath).isSymbolicLink() || !isInsidePath(rootRealPath, artifactWorkspaceRealPath)) {
-            return null;
-        }
-        const artifactStat = lstatSync(artifactPath);
-        if (artifactStat.isSymbolicLink() || !artifactStat.isFile() || artifactStat.size > MAX_ARTIFACT_BYTES) {
-            return null;
-        }
-        if (!isInsidePath(stableRealPath(artifactPath), rootRealPath)) {
-            return null;
-        }
-        const fd = openSync(artifactPath, 'r');
-        try {
-            const openedStat = fstatSync(fd);
-            const currentStat = statSync(artifactPath);
-            if (!openedStat.isFile() || openedStat.size > MAX_ARTIFACT_BYTES || openedStat.dev !== artifactStat.dev || openedStat.ino !== artifactStat.ino || openedStat.dev !== currentStat.dev || openedStat.ino !== currentStat.ino) {
-                return null;
-            }
-            const buffer = Buffer.alloc(MAX_ARTIFACT_BYTES + 1);
-            const bytesRead = readSync(fd, buffer, 0, buffer.length, 0);
-            if (bytesRead > MAX_ARTIFACT_BYTES) {
-                return null;
-            }
-            const finalStat = fstatSync(fd);
-            if (finalStat.dev !== openedStat.dev || finalStat.ino !== openedStat.ino) {
-                return null;
-            }
-            return buffer.subarray(0, bytesRead).toString('utf8');
-        }
-        finally {
-            closeSync(fd);
-        }
-    }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-        return null;
-    }
-}
-function resolveExecutionModelId() {
-    try {
-        return getConfiguredExecutionModelId(undefined);
-    }
-    catch {
-        // 2.0.1-bug1: with the slim `~/.peaks/config.json` the legacy
-        // `providers` block is gone, so the configured-model lookup is
-        // expected to throw. Fall back to the pre-2.0 default so the
-        // planner remains usable in unit tests and the dry-run path.
-        return DEFAULT_EXECUTION_MODEL_ID;
-    }
-}
-function getConcreteTargetAreas(request, artifactWorkspacePath, hasApprovedTechArtifacts) {
-    if (!artifactWorkspacePath || !hasApprovedTechArtifacts || !hasPlannerArtifactWorkspace(request, artifactWorkspacePath)) {
-        return [];
-    }
-    // Slice 2026-06-29-change-id-root-removal: read path now resolves via
-    // the session-axis `getSessionDir(root, sessionId)` (the change-id
-    // identifier is reused as the session-dir name for tech-artifact
-    // reads, matching the test helper `writeApprovedTechArtifacts` and
-    // `autonomous-resume-writer.ts`).
-    const architectureRoot = join(getSessionDir(artifactWorkspacePath, request.sessionId), 'rd', 'architecture');
-    const candidates = TECH_REQUIRED_ARTIFACTS.flatMap((artifact) => {
-        if (artifact === 'tech-approval-record.md') {
-            return [];
-        }
-        const content = readArtifactFile(architectureRoot, artifactWorkspacePath, artifact);
-        return content ? extractImplementationTargetAreas(content) : [];
-    });
-    return [...new Set(candidates)];
-}
-function withStandardsOverlay(gateStatus, overlay) {
-    return { ...gateStatus, ...overlay };
-}
-function buildStandardsOverlay(request) {
-    if (!request.projectRoot) {
-        return {};
-    }
-    const check = resolveRdStartupStandardsCheck({ projectRoot: request.projectRoot, strict: request.strictStandards === true });
-    // Slice 2026-06-16-peaks-rd-no-gates — Repair cycle 1:
-    // thread BOTH diagnostic and errorCode so strict-mode callers still
-    // surface `EPEAKS_NO_STANDARDS`. The pre-fix version early-returned
-    // on `diagnostic !== null` and dropped `errorCode` (QA#4 AC3 violation).
-    const overlay = { standardsGates: check.gates };
-    const withDiagnostic = check.diagnostic !== null
-        ? { ...overlay, standardsDiagnostic: check.diagnostic }
-        : overlay;
-    return check.errorCode !== null
-        ? { ...withDiagnostic, standardsErrorCode: check.errorCode }
-        : withDiagnostic;
-}
-function buildPlan(request, standardsOverlay) {
-    // Slice 2026-06-29-change-id-root-removal: change-id is metadata-only;
-    // no structural validation gate fires here.
-    const goal = normalizeGoal(request.goal);
-    const swarmMode = request.swarmMode ?? true;
-    const executionModelId = request.executionModelId?.trim() || resolveExecutionModelId();
-    const { workerTarget, blockedReasons } = resolveWorkerTarget(request.maxWorkers);
-    const artifactWorkspacePath = resolveArtifactWorkspacePath(request);
-    const artifactRoot = 'rd/swarm';
-    const techStatus = getTechStatus({
-        sessionId: request.sessionId,
-        ...(artifactWorkspacePath ? { artifactWorkspacePath } : {}),
-        ...(request.workspace ? { workspace: request.workspace } : {}),
-    });
-    const requiresTechApproval = request.requiresTechApproval ?? !isClearLowRiskGoal(goal);
-    const techGateSkipped = !requiresTechApproval;
-    if (!swarmMode) {
-        return {
-            sessionId: request.sessionId,
-            goal,
-            swarmMode,
-            workerTarget,
-            waves: [],
-            tasks: [],
-            conflictGroups: [],
-            artifactRoot,
-            outputs: {
-                taskGraph: 'rd/swarm/task-graph.json',
-                waveManifests: [],
-                workerBriefs: [],
-                reducerReport: 'rd/swarm/reducer-report.md',
-            },
-            gateStatus: withStandardsOverlay({
-                techApprovalRequired: requiresTechApproval,
-                techStatus: techStatus.status,
-                ...(techGateSkipped ? { skipReason: 'tech-gate-skipped-clear-implementation-path' } : {}),
-            }, standardsOverlay),
-            blockedReasons,
-            nextActions: [],
-        };
-    }
-    if (requiresTechApproval && techStatus.status !== 'approved') {
-        return {
-            sessionId: request.sessionId,
-            goal,
-            swarmMode,
-            workerTarget,
-            waves: [],
-            tasks: [],
-            conflictGroups: [],
-            artifactRoot,
-            outputs: {
-                taskGraph: 'rd/swarm/task-graph.json',
-                waveManifests: [],
-                workerBriefs: [],
-                reducerReport: 'rd/swarm/reducer-report.md',
-            },
-            gateStatus: withStandardsOverlay({
-                techApprovalRequired: true,
-                techStatus: techStatus.status,
-            }, standardsOverlay),
-            blockedReasons: ['tech-approval-required', ...blockedReasons],
-            nextActions: ['Run peaks tech plan --dry-run and approve the tech plan before running peaks swarm plan.'],
-        };
-    }
-    if (blockedReasons.includes('worker-count-below-target')) {
-        return {
-            sessionId: request.sessionId,
-            goal,
-            swarmMode,
-            workerTarget,
-            waves: [],
-            tasks: [],
-            conflictGroups: [],
-            artifactRoot,
-            outputs: {
-                taskGraph: 'rd/swarm/task-graph.json',
-                waveManifests: [],
-                workerBriefs: [],
-                reducerReport: 'rd/swarm/reducer-report.md',
-            },
-            gateStatus: withStandardsOverlay({
-                techApprovalRequired: requiresTechApproval,
-                techStatus: techStatus.status,
-                ...(techGateSkipped ? { skipReason: 'tech-gate-skipped-clear-implementation-path' } : {}),
-            }, standardsOverlay),
-            blockedReasons,
-            nextActions: ['Lower max-workers to match the current change scope or accept the capped target.'],
-        };
-    }
-    const taskIds = buildTaskIds(workerTarget);
-    const concreteTargetAreas = getConcreteTargetAreas(request, artifactWorkspacePath, techStatus.status === 'approved');
-    const discoveryTaskIds = taskIds.slice(0, 8);
-    const planningTaskIds = taskIds.slice(8, 16);
-    const implementationTaskIds = taskIds.slice(16, taskIds.length - 8);
-    const unitTestTaskIds = taskIds.slice(taskIds.length - 8, taskIds.length - 5);
-    const qualityTaskIds = taskIds.slice(taskIds.length - 5, taskIds.length - 1);
-    const reducerTaskIds = taskIds.slice(taskIds.length - 1);
-    const waves = [
-        { name: 'discovery', taskIds: [...discoveryTaskIds] },
-        { name: 'planning', taskIds: [...planningTaskIds] },
-        { name: 'implementation candidates', taskIds: [...implementationTaskIds] },
-        { name: 'unit-test execution', taskIds: [...unitTestTaskIds] },
-        { name: 'quality gates', taskIds: [...qualityTaskIds] },
-        { name: 'reducer', taskIds: [...reducerTaskIds] },
-    ];
-    const waveDependencies = {
-        discovery: [],
-        planning: discoveryTaskIds,
-        'implementation candidates': planningTaskIds,
-        'unit-test execution': implementationTaskIds,
-        'quality gates': unitTestTaskIds,
-        reducer: qualityTaskIds,
-    };
-    const tasks = taskIds.map((taskId, index) => {
-        const wave = index < 8 ? 'discovery' : index < 16 ? 'planning' : index < taskIds.length - 8 ? 'implementation candidates' : index < taskIds.length - 5 ? 'unit-test execution' : index < taskIds.length - 1 ? 'quality gates' : 'reducer';
-        const briefPath = `rd/swarm/workers/${taskId}/brief.md`;
-        const implementationIndex = index - 16;
-        const targetArea = wave === 'implementation candidates' && hasConcreteTargetAreas(concreteTargetAreas)
-            ? selectConcreteTargetArea(concreteTargetAreas, implementationIndex)
-            : `area-${wave}`;
-        const modelRole = getTaskModelRole(wave);
-        return {
-            taskId,
-            wave,
-            workerKind: taskId,
-            purpose: `${taskId.replace(/^rd-/, '').replace(/-/g, ' ')} for ${goal}`,
-            modelRole,
-            modelId: getTaskModelId(modelRole, executionModelId),
-            inputs: [goal, artifactRoot],
-            outputs: [briefPath],
-            dependsOn: [...waveDependencies[wave]],
-            conflictGroup: `group-${wave.replace(/\s+/g, '-')}`,
-            targetArea,
-            expectedEvidence: wave === 'reducer'
-                ? 'reducer-report.md'
-                : wave === 'implementation candidates'
-                    ? `${taskId}-patch-summary.md`
-                    : wave === 'unit-test execution'
-                        ? `${taskId}-test-command-result.md`
-                        : wave === 'quality gates'
-                            ? `${taskId}-qa-review.md`
-                            : `${taskId}.md`,
-        };
-    });
-    const conflictGroups = waves.map((wave) => ({
-        groupId: `group-${wave.name.replace(/\s+/g, '-')}`,
-        ownedPaths: wave.taskIds.map((taskId) => `rd/swarm/workers/${taskId}/brief.md`),
-        parallelismPolicy: wave.taskIds.length > 1 ? 'parallel' : 'sequential',
-        reason: `${wave.name} work is isolated by worker output path`,
-    }));
-    return {
-        sessionId: request.sessionId,
-        goal,
-        swarmMode,
-        workerTarget,
-        waves,
-        tasks,
-        conflictGroups,
-        artifactRoot,
-        outputs: {
-            taskGraph: 'rd/swarm/task-graph.json',
-            waveManifests: waves.map((_wave, index) => `rd/swarm/waves/wave-${index + 1}-${_wave.name}.json`),
-            workerBriefs: tasks.map((task) => task.outputs[0]),
-            reducerReport: 'rd/swarm/reducer-report.md',
-        },
-        gateStatus: withStandardsOverlay({
-            techApprovalRequired: requiresTechApproval,
-            techStatus: techStatus.status,
-            ...(techGateSkipped ? { skipReason: 'tech-gate-skipped-clear-implementation-path' } : {}),
-        }, standardsOverlay),
-        blockedReasons,
-        nextActions: blockedReasons.length > 0 ? ['Lower max-workers to match the current change scope or accept the capped target.'] : [],
-    };
-}
-export function createRdSwarmPlan(request) {
-    if (request.skill !== 'rd') {
-        throw new Error('Unsupported skill');
-    }
-    const standardsOverlay = buildStandardsOverlay(request);
-    const result = buildPlan(request, standardsOverlay);
-    const artifactWorkspacePath = resolveArtifactWorkspacePath(request);
-    if (!hasPlannerArtifactWorkspace(request, artifactWorkspacePath)) {
-        return {
-            available: false,
-            behavior: 'preview',
-            reason: 'artifact-workspace-unavailable',
-            swarmMode: result.swarmMode,
-            workerTarget: result.workerTarget,
-            waves: result.waves,
-            tasks: result.tasks,
-            conflictGroups: result.conflictGroups,
-            artifactRoot: result.artifactRoot,
-            outputs: result.outputs,
-            gateStatus: result.gateStatus,
-            blockedReasons: result.blockedReasons,
-            nextActions: [...WORKSPACE_UNAVAILABLE_NEXT_ACTIONS],
-        };
-    }
-    const blockedReason = result.blockedReasons[0];
-    if (blockedReason) {
-        return {
-            available: false,
-            behavior: 'blocked',
-            reason: blockedReason,
-            swarmMode: result.swarmMode,
-            workerTarget: result.workerTarget,
-            waves: result.waves,
-            tasks: result.tasks,
-            conflictGroups: result.conflictGroups,
-            artifactRoot: result.artifactRoot,
-            outputs: result.outputs,
-            gateStatus: result.gateStatus,
-            blockedReasons: result.blockedReasons,
-            nextActions: result.nextActions,
-        };
-    }
-    return {
-        available: true,
-        ...result,
-    };
-}

package/dist/src/services/rd/standards-diagnostic.d.ts

@@ -1,76 +0,0 @@
-/** Stable exit code surfaced to the CLI when `--strict-standards` is set. */
-export declare const EPEAKS_NO_STANDARDS: "EPEAKS_NO_STANDARDS";
-/** Subdirectories of `<projectRoot>/.claude/rules/` that must be populated. */
-export type RdStandardsSubdir = 'common' | 'typescript';
-export declare const RD_STANDARDS_REQUIRED_SUBDIRS: ReadonlyArray<RdStandardsSubdir>;
-/** The three gates the RD bootstrap inspects. */
-export type RdStandardGateName = 'code-review' | 'security-review' | 'performance-review';
-export type RdStandardGateStatus = 'ready' | 'skipped';
-export type RdStandardGate = {
-    readonly name: RdStandardGateName;
-    readonly status: RdStandardGateStatus;
-    readonly reason: string | null;
-};
-export type DetectMissingProjectStandardsInput = {
-    readonly projectRoot: string;
-};
-export type DetectMissingProjectStandardsResult = {
-    readonly missing: boolean;
-    readonly path: string;
-    readonly missingSubdirs: ReadonlyArray<RdStandardsSubdir>;
-    readonly remediation: string;
-};
-export type RenderRdStandardsDiagnosticInput = {
-    readonly projectRoot: string;
-    readonly detection: DetectMissingProjectStandardsResult;
-};
-export type ResolveRdStartupStandardsCheckInput = {
-    readonly projectRoot: string;
-    readonly strict: boolean;
-};
-export type ResolveRdStartupStandardsCheckResult = {
-    readonly exitCode: 0 | 1;
-    readonly errorCode: typeof EPEAKS_NO_STANDARDS | null;
-    readonly diagnostic: string | null;
-    readonly gates: ReadonlyArray<RdStandardGate>;
-};
-/**
- * Pure detection: scan `<projectRoot>/.claude/rules/{common,typescript}/`
- * for at least one `.md` rule file per subdir. Empty subdirs and missing
- * subdirs both count as "missing".
- *
- * Defensive: never throws. Missing projectRoot, permission errors, or a
- * non-directory at the path all collapse to `{ missing: true }`. The caller
- * (CLI bootstrap) is expected to surface the remediation; this function
- * just reports the truth.
- */
-export declare function detectMissingProjectStandards(input: DetectMissingProjectStandardsInput): DetectMissingProjectStandardsResult;
-/**
- * Render the human-readable diagnostic line that goes to stderr.
- * The line is single-line + copy-pasteable so the model can echo it
- * into a Bash command verbatim.
- */
-export declare function renderRdStandardsDiagnostic(input: RenderRdStandardsDiagnosticInput): string;
-/**
- * Build the gate list for the JSON envelope returned by `peaks rd --json`.
- * Mirrors the PRD's AC2 contract: when missing, each gate is
- * `{ name, status: 'skipped', reason: 'no project-local standards' }`.
- */
-export declare function buildRdStandardsGateList(input: {
-    readonly missing: boolean;
-}): ReadonlyArray<RdStandardGate>;
-/**
- * Single entry point for the RD / QA / Solo bootstrap. Returns the
- * exit code + error code + diagnostic + gate list. The CLI wrapper is
- * responsible for `process.stderr.write(diagnostic ?? '')` and
- * `process.exit(result.exitCode)`.
- *
- * - `strict=true`  + missing  → exitCode 1, errorCode EPEAKS_NO_STANDARDS,
- *                                diagnostic + skipped gates emitted.
- * - `strict=false` + missing  → exitCode 0, errorCode null,
- *                                diagnostic + skipped gates emitted
- *                                (warn-and-continue; PRD NG1).
- * - strict any     + present  → exitCode 0, errorCode null,
- *                                diagnostic null, gates ready.
- */
-export declare function resolveRdStartupStandardsCheck(input: ResolveRdStartupStandardsCheckInput): ResolveRdStartupStandardsCheckResult;

package/dist/src/services/rd/standards-diagnostic.js

@@ -1,166 +0,0 @@
-/**
- * Slice 2026-06-16-peaks-rd-no-gates — missing-project-standards diagnostic
- * + JSON gate list shape for the RD bootstrap path.
- *
- * Background: when `peaks-rd` (or `peaks-qa` / `peaks-code`) starts in a
- * project whose `.claude/rules/{common,typescript}/` is missing or empty,
- * the existing code-review / security / performance gates were silently
- * dropped. This module makes the missing-standards condition observable:
- *
- *   G1  `detectMissingProjectStandards` + `renderRdStandardsDiagnostic`
- *       produce a clear stderr/JSON diagnostic with a copy-pasteable
- *       `peaks standards init --project <X> --apply` remediation hint.
- *   G2  `resolveRdStartupStandardsCheck({ strict: true })` returns an
- *       exitCode of 1 with errorCode `EPEAKS_NO_STANDARDS` when standards
- *       are missing. Default (`strict: false`) keeps the warn-and-continue
- *       behavior so existing users with empty rules don't break.
- *   G3  `buildRdStandardsGateList` returns the three gates each marked
- *       `{ status: 'skipped', reason: 'no project-local standards' }` when
- *       standards are missing. When present, gates are `{ status: 'ready' }`.
- *   G4  The remediation string is the exact copy-pasteable CLI invocation.
- *
- * This module is a pure-function helper. The `peaks rd` / `peaks qa` /
- * `peaks solo` runtime hooks call `resolveRdStartupStandardsCheck` at
- * bootstrap and decide whether to write `process.stderr` + JSON envelope
- * + exit. The bootstrap is intentionally side-effect-free here so unit
- * tests can run it without spawning child processes.
- *
- * Cross-platform: `path` field is rendered verbatim from the caller's
- * projectRoot string (we never normalize or rewrite the user's path —
- * Windows users see their `C:\Users\foo` form; macOS / Linux users see
- * their `/Users/foo` form). The remediation command always uses POSIX
- * forward slashes since the CLI is invoked through a shell that
- * double-normalizes on Windows (`peaks standards init --project C:/Users/...`).
- *
- * Out of scope (downstream slices):
- *   - audit-log emission for gate-skip events (see memory
- *     `peaks-ide-skill-ac-10-audit-log-writer-is-a-thin-helper-not-a-separate-cli-primitive`
- *     — the helper is intentionally not surfaced here).
- *   - one-time suppression marker (`peaks standards suppress --project <X>`
- *     or `.peaks/.no-standards`); tracked in PRD#004 R3 as a future slice.
- */
-import { existsSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-/** Stable exit code surfaced to the CLI when `--strict-standards` is set. */
-export const EPEAKS_NO_STANDARDS = 'EPEAKS_NO_STANDARDS';
-export const RD_STANDARDS_REQUIRED_SUBDIRS = ['common', 'typescript'];
-/**
- * Pure detection: scan `<projectRoot>/.claude/rules/{common,typescript}/`
- * for at least one `.md` rule file per subdir. Empty subdirs and missing
- * subdirs both count as "missing".
- *
- * Defensive: never throws. Missing projectRoot, permission errors, or a
- * non-directory at the path all collapse to `{ missing: true }`. The caller
- * (CLI bootstrap) is expected to surface the remediation; this function
- * just reports the truth.
- */
-export function detectMissingProjectStandards(input) {
-    const projectRoot = input.projectRoot;
-    const rulesPath = join(projectRoot, '.claude', 'rules');
-    const missingSubdirs = [];
-    if (!existsSync(rulesPath)) {
-        return {
-            missing: true,
-            path: rulesPath,
-            missingSubdirs: [...RD_STANDARDS_REQUIRED_SUBDIRS],
-            remediation: buildRemediationCommand(projectRoot)
-        };
-    }
-    for (const subdir of RD_STANDARDS_REQUIRED_SUBDIRS) {
-        if (!hasMdRules(join(rulesPath, subdir))) {
-            missingSubdirs.push(subdir);
-        }
-    }
-    return {
-        missing: missingSubdirs.length > 0,
-        path: rulesPath,
-        missingSubdirs,
-        remediation: buildRemediationCommand(projectRoot)
-    };
-}
-/**
- * Render the human-readable diagnostic line that goes to stderr.
- * The line is single-line + copy-pasteable so the model can echo it
- * into a Bash command verbatim.
- */
-export function renderRdStandardsDiagnostic(input) {
-    const { projectRoot: _projectRoot, detection } = input;
-    const missingList = detection.missingSubdirs.length > 0 ? ` (missing: ${detection.missingSubdirs.join(', ')})` : '';
-    return [
-        `⚠ no project-local standards found at ${detection.path}${missingList}`,
-        `— run ${detection.remediation} to scaffold.`,
-        `Gates (code-review, security-review, performance-review) will be skipped.`
-    ].join(' ');
-}
-/**
- * Build the gate list for the JSON envelope returned by `peaks rd --json`.
- * Mirrors the PRD's AC2 contract: when missing, each gate is
- * `{ name, status: 'skipped', reason: 'no project-local standards' }`.
- */
-export function buildRdStandardsGateList(input) {
-    if (input.missing) {
-        return [
-            { name: 'code-review', status: 'skipped', reason: 'no project-local standards' },
-            { name: 'security-review', status: 'skipped', reason: 'no project-local standards' },
-            { name: 'performance-review', status: 'skipped', reason: 'no project-local standards' }
-        ];
-    }
-    return [
-        { name: 'code-review', status: 'ready', reason: null },
-        { name: 'security-review', status: 'ready', reason: null },
-        { name: 'performance-review', status: 'ready', reason: null }
-    ];
-}
-/**
- * Single entry point for the RD / QA / Solo bootstrap. Returns the
- * exit code + error code + diagnostic + gate list. The CLI wrapper is
- * responsible for `process.stderr.write(diagnostic ?? '')` and
- * `process.exit(result.exitCode)`.
- *
- * - `strict=true`  + missing  → exitCode 1, errorCode EPEAKS_NO_STANDARDS,
- *                                diagnostic + skipped gates emitted.
- * - `strict=false` + missing  → exitCode 0, errorCode null,
- *                                diagnostic + skipped gates emitted
- *                                (warn-and-continue; PRD NG1).
- * - strict any     + present  → exitCode 0, errorCode null,
- *                                diagnostic null, gates ready.
- */
-export function resolveRdStartupStandardsCheck(input) {
-    const detection = detectMissingProjectStandards({ projectRoot: input.projectRoot });
-    if (!detection.missing) {
-        return {
-            exitCode: 0,
-            errorCode: null,
-            diagnostic: null,
-            gates: buildRdStandardsGateList({ missing: false })
-        };
-    }
-    const diagnostic = renderRdStandardsDiagnostic({ projectRoot: input.projectRoot, detection });
-    const exitCode = input.strict ? 1 : 0;
-    return {
-        exitCode,
-        errorCode: input.strict ? EPEAKS_NO_STANDARDS : null,
-        diagnostic,
-        gates: buildRdStandardsGateList({ missing: true })
-    };
-}
-// --- internal helpers -------------------------------------------------------
-function buildRemediationCommand(projectRoot) {
-    // The remediation command is always rendered with POSIX forward slashes
-    // because the CLI shell normalizes path separators on Windows anyway,
-    // and users on macOS / Linux will copy this verbatim.
-    const posix = projectRoot.split('\\').join('/');
-    return `peaks standards init --project ${posix} --apply`;
-}
-function hasMdRules(dirPath) {
-    try {
-        if (!existsSync(dirPath)) {
-            return false;
-        }
-        const entries = readdirSync(dirPath);
-        return entries.some((entry) => entry.toLowerCase().endsWith('.md'));
-    }
-    catch {
-        return false;
-    }
-}