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

package/dist/services/preferences/preferences-types.d.ts

@@ -0,0 +1,148 @@
+/**
+ * peaks-loop 2.0 project-local preferences schema.
+ * Per spec §8.4 — per-project state lives in `.peaks/preferences.json`,
+ * NOT in `~/.peaks/config.json` (which is slim global).
+ *
+ * Spec reference: docs/superpowers/specs/2026-06-11-peaks-loop-l1-l2-l3-redesign.md §8.4
+ */
+export declare const PREFERENCES_SCHEMA_VERSION = "2.0.0";
+/**
+ * Per-task-level UA install UX prompt decision.
+ * Values:
+ *   - 'unset'              — ask every session (default)
+ *   - 'skip-this-session'  — skip prompt for current session only
+ *   - 'skip-forever'       — never ask, never install
+ */
+export type UaPromptDecision = 'unset' | 'skip-this-session' | 'skip-forever';
+/**
+ * L1a task classification conservatism.
+ * Values:
+ *   - 'default'  — use default signal thresholds
+ *   - 'strict'   — always upgrade to next level (slower, safer)
+ *   - 'lax'      — always downgrade to previous level (faster, riskier)
+ */
+export type ClassifyConservatism = 'default' | 'strict' | 'lax';
+/**
+ * Per-touchpoint headroom-AI mode override.
+ * Spec §7.4 — default 'balanced'.
+ */
+export type HeadroomMode = 'balanced' | 'aggressive' | 'conservative';
+export interface HeadroomPreferences {
+    /** Whether headroom integration is enabled globally. Default: true */
+    readonly enabled: boolean;
+    /** Default mode if a touchpoint doesn't override. Default: 'balanced' */
+    readonly defaultMode: HeadroomMode;
+    /** Per-touchpoint mode overrides */
+    readonly perTouchpoint: {
+        subAgentDispatch: HeadroomMode;
+        memorySearch: HeadroomMode;
+        retrospectiveSearch: HeadroomMode;
+        doctorScan: HeadroomMode;
+        doctorRoute: HeadroomMode;
+    };
+    /** Minimum joined-result byte count before search-touchpoint compression runs. Default: 4096. */
+    readonly compressMinBytes: number;
+}
+export interface ClassifyRuleOverrides {
+    /** File count threshold above which a task is promoted to 'feature' */
+    readonly feature_threshold_files?: number;
+    /** Line count threshold above which a task is promoted to 'feature' */
+    readonly feature_threshold_lines?: number;
+    /** Whether to require a 24h grace before cleaning recently-active sessions */
+    readonly runtime_clean_grace_hours?: number;
+}
+export interface SwarmSpeculativePreferences {
+    /** Whether speculative dispatch is enabled. Default: true */
+    readonly enabled: boolean;
+    /** Max concurrent speculative sub-agents. Default: 3 (slice 2026-06-24-efficiency-4p-bundle, G3/P1.1) */
+    readonly maxConcurrent: number;
+    /** Min hit rate below which speculative auto-disables. Default: 0.5 */
+    readonly minHitRate: number;
+}
+export interface ProjectPreferences {
+    /**
+     * On-disk schema version. The JSON key is `schema_version` (snake_case) — this matches the
+     * raw on-disk key in `.peaks/preferences.json`, NOT the camelCase used by the rest of this
+     * interface. preferences-service.ts validates this value against PREFERENCES_SCHEMA_VERSION
+     * on load and writes the current value on save. Any mismatch throws PREFERENCES_SCHEMA_MISMATCH.
+     */
+    readonly schema_version: typeof PREFERENCES_SCHEMA_VERSION;
+    /**
+     * Slice 2026-06-28-code-mode-bypass-fix: economyMode is a
+     * **MODEL-SELECTION** knob only — it chooses between the cheap
+     * configured provider (`getConfiguredExecutionModelId`) and the
+     * strongest planner/reviewer model (`getStrongestModelId(...)`). It does
+     * NOT throttle concurrency, fan-out, or worker count. Per user
+     * direction 2026-06-28: "效率比省钱更重要，是在效率达到最大值的时
+     * 候，再去考虑经济问题" (efficiency first; economy is only considered
+     * after efficiency is maxed out).
+     *
+     * Concurrency is governed by:
+     *   - `swarmMode` (project-policy opt-out for the swarm subgraph),
+     *   - `fanout.defaultMode` (HARD constraint: `'fan-out'` per slice
+     *     2026-06-24-audit-5th-p2),
+     *   - the slice DAG leaf count (≥ 2 leaves at one topological level
+     *     forces parallel dispatch via `peaks sub-agent dispatch --from-dag`).
+     *
+     * Even with `economyMode: true` AND `swarmMode: false`, a 2-leaf DAG
+     * MUST dispatch in parallel — the `fanout-mandatory` rule is
+     * unconditional. Economy ≠ concurrency.
+     */
+    readonly economyMode: boolean;
+    /**
+     * Slice 2026-06-28: swarmMode controls whether the swarm subgraph
+     * (peaks-rd/qa worker graph) is generated at all. It does NOT
+     * control fan-out. Fan-out is governed by the slice DAG + the
+     * `fanout.defaultMode` preference; swarmMode only decides the
+     * dispatch *shape* (worker graph vs flat dispatch).
+     */
+    readonly swarmMode: boolean;
+    readonly uaPrompt: UaPromptDecision;
+    readonly agentShieldPrompt: UaPromptDecision;
+    readonly classifyConservatism: ClassifyConservatism;
+    readonly classifyRules: ClassifyRuleOverrides;
+    readonly headroom: HeadroomPreferences;
+    readonly swarmSpeculative: SwarmSpeculativePreferences;
+    /** Loop Autonomous (L4 14.5) toggle. Default: false — never auto-enable. */
+    readonly loopAutonomousEnabled: boolean;
+    /**
+     * L2.3 P2-a: ECC AgentShield subprocess toggle. Default: false.
+     *
+     * When true, `peaks audit static` spawns `npx ecc-agentshield scan --json`
+     * and merges its findings into the audit report. When false (default),
+     * the audit runs peaks-loop-only and the subprocess is never spawned.
+     *
+     * The preference is independent of whether ECC is installed — i.e.
+     * `agentShieldEnabled: true` with ECC missing surfaces a soft
+     * "ECC not installed" warning and the audit still completes.
+     */
+    readonly agentShieldEnabled: boolean;
+    /**
+     * Slice 2026-06-24-audit-5th-p2: fan-out is now a HARD constraint.
+     * The previous opt-out (`defaultMode = 'serial'`) is removed by user
+     * direction. Single-sub-agent dispatch is no longer permitted when
+     * the slice DAG has ≥ 2 leaves at the same topological level; the
+     * LLM-side runner MUST use `peaks sub-agent dispatch --from-dag`
+     * (N parallel `buildToolCall` per dispatch).
+     *
+     * The field is kept on `ProjectPreferences` for backward-compatible
+     * load (legacy preferences.json files still parse) but the runtime
+     * shape is fixed: `defaultMode === 'fan-out'`. Any other value in a
+     * saved file is rejected at load time.
+     */
+    readonly fanout: FanoutPreference;
+}
+export type FanoutMode = 'fan-out';
+export declare const FANOUT_MODES: readonly FanoutMode[];
+/**
+ * Runtime type guard for `FanoutMode`. Slice 2026-06-24-audit-5th-p2
+ * narrowed the closed set from `['fan-out','serial']` to `['fan-out']`
+ * — stale preferences.json files with `"serial"` must now fail-fast at
+ * load (see `preferences-service.ts`) instead of being silently coerced.
+ */
+export declare function isFanoutMode(value: unknown): value is FanoutMode;
+export interface FanoutPreference {
+    /** Hard-coded mode. Slice 2026-06-24-audit-5th-p2 removed the serial opt-out. */
+    readonly defaultMode: FanoutMode;
+}
+export declare const DEFAULT_PREFERENCES: ProjectPreferences;

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

@@ -0,0 +1,440 @@
+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, getStrongestModelId } 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 a
+ * legacy provider config; with the slim default that field is
+ * `undefined`, so `getConfiguredExecutionModelId` would throw. We
+ * retain a sensible 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 = 'claude-opus-4-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, strongestModelId) {
+    return modelRole === 'execution' ? executionModelId : strongestModelId;
+}
+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();
+    // Slice 2026-07-09 add-zcode-adapter (A.3): strongest planner/reviewer
+    // model is resolved dynamically (config.model → env-var fallback).
+    const strongestModelId = getStrongestModelId();
+    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, strongestModelId),
+            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/services/rd/standards-diagnostic.d.ts

@@ -0,0 +1,76 @@
+/** 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 / Code 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;