peaks-loop 4.0.0-beta.9 → 4.0.3

package/dist/services/workflow/workflow-autonomous-types.d.ts

@@ -0,0 +1,114 @@
+/**
+ * peaks-workflow — public type declarations for autonomous workflow planning.
+ *
+ * Pure type module. No runtime helpers, no constants. The slimmed
+ * `workflow-autonomous-service.ts` re-exports the types so existing
+ * import paths compile unchanged (rid-006 split).
+ *
+ * Per PRD EC-1, this module is consumed by both
+ * `workflow-autonomous-service.ts` and
+ * `workflow-autonomous-resume-helpers.ts` via `import type`. Importing
+ * this types-only module breaks the existing
+ * resume-helpers ↔ autonomous-service runtime cycle (both modules
+ * previously re-exported `AutonomousResumePlan` from each other).
+ *
+ * File budget: ≤ 400 lines (rid-006 split).
+ */
+import type { CapabilityItemType } from '../recommendations/recommendation-types.js';
+import type { ModelProviderConfig, WorkspaceConfig } from '../config/config-types.js';
+import type { RdPlanResult } from '../rd/rd-service.js';
+import type { CodeMode, WorkflowMode, WorkflowRouterPlan } from './workflow-router-service.js';
+export type CapabilitySurface = 'skill' | 'mcp' | 'plugin' | 'expert';
+export type CapabilityPurpose = 'code-review' | 'security-review' | 'coding-standards' | 'docs-lookup' | 'browser-validation' | 'browser-debug' | 'design-context' | 'design-source' | 'code-search' | 'database-inspection' | 'browser-agent' | 'worker-guidance' | 'memory' | 'context-management' | 'ui-components' | 'spec-workflow' | 'repo-intelligence' | 'openspec' | 'workflow-methodology' | 'workflow-reference' | 'workflow-guidance' | 'product-guidance' | 'design-reference' | 'ui-reference' | 'engineering-guidance' | 'typescript-guidance' | 'quality-guidance' | 'skill-pack' | 'external-skill' | 'design-critique' | 'design-guidance' | 'cloud-skill-pack';
+export type CapabilityActivation = 'available' | 'needs-install' | 'needs-credentials' | 'not-active';
+export type CapabilityTrustLevel = 'local' | 'user-curated' | 'third-party';
+export type CapabilityCandidate = {
+    readonly id: string;
+    readonly source: string;
+    readonly purpose: CapabilityPurpose;
+    readonly surface: CapabilitySurface;
+    readonly kind: CapabilitySurface;
+    readonly sourceType: CapabilityItemType;
+    readonly trustLevel: CapabilityTrustLevel;
+    readonly activation: CapabilityActivation;
+    readonly risk: readonly string[];
+};
+export type AutonomousWorkflowRequest = {
+    readonly mode: WorkflowMode;
+    readonly codeMode?: CodeMode;
+    readonly sessionId: string;
+    readonly goal: string;
+    readonly maxWorkers?: number;
+    readonly dryRun: true;
+    readonly artifactWorkspacePath?: string;
+    readonly workspace?: WorkspaceConfig;
+    readonly config?: {
+        readonly economyMode?: boolean;
+        readonly swarmMode?: boolean;
+        readonly providers?: ModelProviderConfig;
+    };
+};
+export type AutonomousGoalPackage = {
+    readonly sessionId: string;
+    readonly goal: string;
+    readonly nonGoals: readonly string[];
+    readonly preservedBehavior: readonly string[];
+    readonly acceptanceCriteria: readonly string[];
+    readonly doneCondition: string;
+    readonly resumeCondition: string;
+    readonly riskNotes: readonly string[];
+};
+export type AutonomousCapabilityPlan = {
+    readonly sources: readonly string[];
+    readonly policy: readonly string[];
+    readonly candidates: readonly CapabilityCandidate[];
+    readonly surfaces: readonly CapabilitySurface[];
+    readonly surfaceSummary: Record<CapabilitySurface, number>;
+};
+export type AutonomousResumePlan = {
+    readonly status: 'preview' | 'ready';
+    readonly checkpoints: readonly string[];
+    readonly requiredArtifacts: readonly string[];
+    readonly resumeInstructions: string;
+};
+export type AutonomousGoalCommand = {
+    readonly command: string;
+    readonly durable: false;
+    readonly reason: string;
+};
+export type AutonomousStoragePlan = {
+    readonly scope: 'user-local';
+    readonly artifactWorkspacePath: string | null;
+    readonly memoryBackupPath: string | null;
+};
+export type AutonomousMvpPackage = {
+    readonly mode: WorkflowMode;
+    readonly codeMode: CodeMode | undefined;
+    readonly executionMode: 'preview';
+    readonly dryRun: true;
+    readonly routePolicy: WorkflowRouterPlan['routePolicy'];
+    readonly rdWaveNames: readonly string[];
+    readonly capabilitySurfaces: readonly CapabilitySurface[];
+    readonly capabilityCountBySurface: Record<CapabilitySurface, number>;
+    readonly ready: boolean;
+};
+export type AutonomousWorkflowPlan = {
+    readonly available: boolean;
+    readonly behavior: 'preview' | 'ready';
+    readonly sessionId: string;
+    readonly goal: string;
+    readonly mode: WorkflowMode;
+    readonly dryRun: true;
+    readonly goalPackage: AutonomousGoalPackage;
+    readonly goalCommand: AutonomousGoalCommand;
+    readonly capabilityPlan: AutonomousCapabilityPlan;
+    readonly storagePlan: AutonomousStoragePlan;
+    readonly routePlan: WorkflowRouterPlan;
+    readonly modelAssignments: WorkflowRouterPlan['modelAssignments'];
+    readonly rdPlan: RdPlanResult;
+    readonly resumePlan: AutonomousResumePlan;
+    readonly mvpPackage: AutonomousMvpPackage;
+    readonly constraints: readonly string[];
+    readonly blockedReasons: readonly string[];
+    readonly nextActions: readonly string[];
+};

package/dist/services/workflow/workflow-autonomous-types.js

@@ -0,0 +1,21 @@
+/**
+ * peaks-workflow — public type declarations for autonomous workflow planning.
+ *
+ * Pure type module. No runtime helpers, no constants. The slimmed
+ * `workflow-autonomous-service.ts` re-exports the types so existing
+ * import paths compile unchanged (rid-006 split).
+ *
+ * Per PRD EC-1, this module is consumed by both
+ * `workflow-autonomous-service.ts` and
+ * `workflow-autonomous-resume-helpers.ts` via `import type`. Importing
+ * this types-only module breaks the existing
+ * resume-helpers ↔ autonomous-service runtime cycle (both modules
+ * previously re-exported `AutonomousResumePlan` from each other).
+ *
+ * File budget: ≤ 400 lines (rid-006 split).
+ */
+export {};
+// Note: `CapabilityAvailabilityStatus` is referenced by the orchestrator's
+// helper functions. It is imported (not re-exported) from the
+// recommendation-types module — keep this types module pure to the
+// declarations originally declared in `workflow-autonomous-service.ts`.

package/dist/services/workflow/workflow-router-service.js

@@ -78,30 +78,32 @@ function annotateSteps(steps, codeMode) {
         };
     });
 }
-function createSoloSteps(executionModelId, strongestModelId) {
+function createSoloSteps(executionModelId, strongestModelId, economyMode) {
+    const executionTier = economyMode === false ? 'top-tier' : 'mid-tier';
     return [
         step({ id: 'code-product-direction', stage: 'product-direction', owner: 'peaks-code', modelTier: 'top-tier', reason: 'Product direction needs strong judgment before execution work is delegated.', dependsOn: [] }, executionModelId, strongestModelId),
         step({ id: 'code-design-direction', stage: 'design-direction', owner: 'peaks-code', modelTier: 'top-tier', reason: 'Design direction uses the recommended default before cheaper implementation work.', dependsOn: ['code-product-direction'] }, executionModelId, strongestModelId),
         step({ id: 'code-tech-direction', stage: 'tech-direction', owner: 'peaks-tech', modelTier: 'top-tier', reason: 'Technical boundaries and approval gates use the recommended default with high-confidence planning.', dependsOn: ['code-design-direction'] }, executionModelId, strongestModelId),
         step({ id: 'code-tech-review', stage: 'tech-review', owner: 'peaks-tech', modelTier: 'top-tier', reason: 'Tech artifacts and gate decisions require strong review and a recommended default path.', dependsOn: ['code-tech-direction'] }, executionModelId, strongestModelId),
         step({ id: 'code-rd-planning', stage: 'rd-planning', owner: 'peaks-rd', modelTier: 'top-tier', reason: 'RD task decomposition and acceptance criteria use the recommended default before execution delegation.', dependsOn: ['code-tech-review'] }, executionModelId, strongestModelId),
-        step({ id: 'code-coding-execution', stage: 'coding-execution', owner: 'peaks-rd', modelTier: executionModelId === strongestModelId ? 'top-tier' : 'mid-tier', reason: `Coding and routine refactoring must use the configured execution worker model ${executionModelId}.`, dependsOn: ['code-rd-planning'] }, executionModelId, strongestModelId),
-        step({ id: 'code-unit-test-execution', stage: 'unit-test-execution', owner: 'peaks-rd', modelTier: executionModelId === strongestModelId ? 'top-tier' : 'mid-tier', reason: `Unit test authoring and focused test runs must use the configured execution worker model ${executionModelId}.`, dependsOn: ['code-coding-execution'] }, executionModelId, strongestModelId),
+        step({ id: 'code-coding-execution', stage: 'coding-execution', owner: 'peaks-rd', modelTier: executionTier, reason: `Coding and routine refactoring must use the configured execution worker model ${executionModelId}.`, dependsOn: ['code-rd-planning'] }, executionModelId, strongestModelId),
+        step({ id: 'code-unit-test-execution', stage: 'unit-test-execution', owner: 'peaks-rd', modelTier: executionTier, reason: `Unit test authoring and focused test runs must use the configured execution worker model ${executionModelId}.`, dependsOn: ['code-coding-execution'] }, executionModelId, strongestModelId),
         step({ id: 'code-quality-review', stage: 'quality-review', owner: 'peaks-code', modelTier: 'top-tier', reason: 'Reducer and final quality gates need strong synthesis and risk review.', dependsOn: ['code-unit-test-execution'] }, executionModelId, strongestModelId)
     ];
 }
-function createSoloStepsForMode(codeMode, executionModelId, strongestModelId) {
-    return annotateSteps(createSoloSteps(executionModelId, strongestModelId), codeMode);
+function createSoloStepsForMode(codeMode, executionModelId, strongestModelId, economyMode) {
+    return annotateSteps(createSoloSteps(executionModelId, strongestModelId, economyMode), codeMode);
 }
-function createTeamSteps(executionModelId, strongestModelId) {
+function createTeamSteps(executionModelId, strongestModelId, economyMode) {
+    const executionTier = economyMode === false ? 'top-tier' : 'mid-tier';
     return [
         step({ id: 'team-product-direction', stage: 'product-direction', owner: 'human', modelTier: 'top-tier', reason: 'Team product direction should stay on the governed planning path.', dependsOn: [] }, executionModelId, strongestModelId),
         step({ id: 'team-design-direction', stage: 'design-direction', owner: 'human', modelTier: 'top-tier', reason: 'Team design direction should preserve reviewability and accountability.', dependsOn: ['team-product-direction'] }, executionModelId, strongestModelId),
         step({ id: 'team-tech-direction', stage: 'tech-direction', owner: 'peaks-tech', modelTier: 'top-tier', reason: 'Team technical plans should remain strongly governed before RD execution.', dependsOn: ['team-design-direction'] }, executionModelId, strongestModelId),
         step({ id: 'team-tech-review', stage: 'tech-review', owner: 'peaks-tech', modelTier: 'top-tier', reason: 'Team tech approval requires strong review before execution.', dependsOn: ['team-tech-direction'] }, executionModelId, strongestModelId),
         step({ id: 'team-rd-planning', stage: 'rd-planning', owner: 'peaks-rd', modelTier: 'top-tier', reason: 'Team RD task decomposition remains on the governed strongest-model path.', dependsOn: ['team-tech-review'] }, executionModelId, strongestModelId),
-        step({ id: 'team-coding-execution', stage: 'coding-execution', owner: 'peaks-rd', modelTier: executionModelId === strongestModelId ? 'top-tier' : 'mid-tier', reason: `Bounded coding tasks must use the configured execution worker model ${executionModelId}.`, dependsOn: ['team-rd-planning'] }, executionModelId, strongestModelId),
-        step({ id: 'team-unit-test-execution', stage: 'unit-test-execution', owner: 'peaks-rd', modelTier: executionModelId === strongestModelId ? 'top-tier' : 'mid-tier', reason: `Unit-test tasks must use the configured execution worker model ${executionModelId}.`, dependsOn: ['team-coding-execution'] }, executionModelId, strongestModelId),
+        step({ id: 'team-coding-execution', stage: 'coding-execution', owner: 'peaks-rd', modelTier: executionTier, reason: `Bounded coding tasks must use the configured execution worker model ${executionModelId}.`, dependsOn: ['team-rd-planning'] }, executionModelId, strongestModelId),
+        step({ id: 'team-unit-test-execution', stage: 'unit-test-execution', owner: 'peaks-rd', modelTier: executionTier, reason: `Unit-test tasks must use the configured execution worker model ${executionModelId}.`, dependsOn: ['team-coding-execution'] }, executionModelId, strongestModelId),
         step({ id: 'team-quality-review', stage: 'quality-review', owner: 'peaks-rd', modelTier: 'top-tier', reason: 'Team RD outputs still need reducer and quality review gates.', dependsOn: ['team-unit-test-execution'] }, executionModelId, strongestModelId)
     ];
 }
@@ -176,13 +178,13 @@ export function createWorkflowRouterPlan(request) {
     // "enabled" (matches the pre-2.0.1 implicit default).
     const economyMode = request.config?.economyMode ?? true;
     const swarmMode = request.config?.swarmMode ?? true;
-    // Pre-2.0.1 DEFAULT_CONFIG carried an implicit `minimax-2.7` provider
-    // for test fixtures that did not pass `config.providers`. The slim
-    // DEFAULT_CONFIG removed that field, so we re-supply it here only when
-    // the caller did not pass any providers at all. An explicit empty
-    // object (`config: { providers: {} }`) still surfaces the "must be
-    // configured" error from `getConfiguredExecutionModelId`.
-    const effectiveProviders = request.config?.providers ?? { minimax: { model: 'minimax-2.7' } };
+    // Pre-2.0.1 DEFAULT_CONFIG carried an implicit provider for test fixtures
+    // that did not pass `config.providers`. The slim DEFAULT_CONFIG removed that
+    // field, so we re-supply it here only when the caller did not pass any
+    // providers at all. An explicit empty object (`config: { providers: {} }`)
+    // still surfaces the "must be configured" error from
+    // `getConfiguredExecutionModelId`.
+    const effectiveProviders = request.config?.providers ?? { anthropic: { model: 'claude-opus-4-7' } };
     // Slice 2026-07-09 add-zcode-adapter (A.3): the strongest
     // planner/reviewer model is now resolved via `getStrongestModelId`,
     // which reads `config.model` (if present) or falls back to the
@@ -201,7 +203,7 @@ export function createWorkflowRouterPlan(request) {
     const techStatus = getTechStatus({ sessionId: request.sessionId, ...sharedWorkspaceOptions });
     const techPlan = createTechPlan({ sessionId: request.sessionId, goal, swarm: swarmMode, dryRun: true, ...sharedWorkspaceOptions });
     const rdPlan = createRdSwarmPlan({ skill: 'rd', sessionId: request.sessionId, goal, maxWorkers, swarmMode, executionModelId, dryRun: true, ...sharedWorkspaceOptions });
-    const steps = codeMode ? createSoloStepsForMode(codeMode, executionModelId, strongestModelId) : createTeamSteps(executionModelId, strongestModelId);
+    const steps = codeMode ? createSoloStepsForMode(codeMode, executionModelId, strongestModelId, economyMode) : createTeamSteps(executionModelId, strongestModelId, economyMode);
     const blockedReasons = uniqueStrings([
         ...techStatus.blockedReasons,
         ...getTechPlanBlockedReasons(techPlan),

package/dist/services/workflow/workflow-spec-lint.d.ts

@@ -0,0 +1,13 @@
+/**
+ * peaks-workflow v3.0.0 — `lintWorkflowSpec` (moved verbatim per rid-006)
+ *
+ * Pure lint over a typed `WorkflowSpec`. No parser/build helpers, no
+ * YAML helpers — lint is pure on the typed spec. The slimmed
+ * `workflow-spec.ts` re-exports `lintWorkflowSpec` under its original
+ * name so existing call sites compile unchanged.
+ *
+ * File budget: ≤ 400 lines (rid-006 split).
+ */
+import type { WorkflowLintReport, WorkflowSpec } from './workflow-spec-types.js';
+/** Lint a parsed spec — returns a report with semantic errors / warnings. */
+export declare function lintWorkflowSpec(spec: WorkflowSpec): WorkflowLintReport;

package/dist/services/workflow/workflow-spec-lint.js

@@ -0,0 +1,75 @@
+/**
+ * peaks-workflow v3.0.0 — `lintWorkflowSpec` (moved verbatim per rid-006)
+ *
+ * Pure lint over a typed `WorkflowSpec`. No parser/build helpers, no
+ * YAML helpers — lint is pure on the typed spec. The slimmed
+ * `workflow-spec.ts` re-exports `lintWorkflowSpec` under its original
+ * name so existing call sites compile unchanged.
+ *
+ * File budget: ≤ 400 lines (rid-006 split).
+ */
+/** Lint a parsed spec — returns a report with semantic errors / warnings. */
+export function lintWorkflowSpec(spec) {
+    const errors = [];
+    const warnings = [];
+    // Phase ids must be unique.
+    const seen = new Set();
+    for (const phase of spec.phases) {
+        if (seen.has(phase.id))
+            errors.push(`duplicate phase id "${phase.id}"`);
+        seen.add(phase.id);
+    }
+    // Gate references in phases must exist in the gates list (or be a known
+    // built-in like "Gate B3").
+    const gateIds = new Set(spec.gates.map((g) => g.id));
+    for (const phase of spec.phases) {
+        for (const gateRef of phase.gates) {
+            if (!gateIds.has(gateRef) && !gateRef.startsWith('Gate ')) {
+                warnings.push(`phase "${phase.id}" references unknown gate "${gateRef}" (not in gates[] and not a built-in "Gate …" label)`);
+            }
+        }
+    }
+    // Evaluator gates must match a gate id when present.
+    for (const ev of spec.evaluators) {
+        if (ev.gate !== undefined && !gateIds.has(ev.gate) && !ev.gate.startsWith('Gate ')) {
+            warnings.push(`evaluator "${ev.type}" references unknown gate "${ev.gate}"`);
+        }
+    }
+    // dependsOn references must resolve.
+    const phaseIds = new Set(spec.phases.map((p) => p.id));
+    for (const phase of spec.phases) {
+        if (phase.dependsOn !== undefined) {
+            for (const dep of phase.dependsOn) {
+                if (!phaseIds.has(dep))
+                    errors.push(`phase "${phase.id}" depends on missing phase "${dep}"`);
+            }
+        }
+    }
+    // Parallel groups must contain ≥2 phases.
+    const groupCounts = new Map();
+    for (const phase of spec.phases) {
+        if (phase.parallelGroup !== undefined) {
+            groupCounts.set(phase.parallelGroup, (groupCounts.get(phase.parallelGroup) ?? 0) + 1);
+        }
+    }
+    for (const [group, count] of groupCounts) {
+        if (count < 2)
+            warnings.push(`parallelGroup "${group}" has only ${count} phase(s); parallelism requires ≥2`);
+    }
+    // Budget sanity.
+    if (spec.budget.cycles !== undefined && spec.budget.cycles < 1) {
+        errors.push(`budget.cycles must be ≥1 when set (got ${spec.budget.cycles})`);
+    }
+    if (spec.budget.tokens !== undefined && spec.budget.tokens < 1) {
+        errors.push(`budget.tokens must be ≥1 when set (got ${spec.budget.tokens})`);
+    }
+    if (spec.budget.wallSeconds !== undefined && spec.budget.wallSeconds < 1) {
+        errors.push(`budget.wallSeconds must be ≥1 when set (got ${spec.budget.wallSeconds})`);
+    }
+    return {
+        ok: errors.length === 0,
+        errors,
+        warnings,
+        normalizedSpec: spec
+    };
+}

package/dist/services/workflow/workflow-spec-types.d.ts

@@ -0,0 +1,100 @@
+/**
+ * peaks-workflow v3.0.0 — Slice A.1 + Slice B.1
+ *
+ * Public type and interface declarations for the workflow spec schema.
+ * Pure data shapes only — no constants, no runtime helpers, no
+ * implementations. Constants (`ID_PATTERN`, `VALID_EVALUATORS`)
+ * remain private to `workflow-spec.ts`; the YAML field helpers
+ * live in `workflow-spec-yaml.ts`; the lint function lives in
+ * `workflow-spec-lint.ts`.
+ *
+ * File budget: ≤ 400 lines (rid-006 split).
+ */
+/** A workflow phase = a single step the runtime executes. */
+export interface WorkflowPhase {
+    /** Stable id within the workflow (kebab-case). Used as the SOP gate key. */
+    readonly id: string;
+    /** peaks-* role that runs the phase (e.g. "peaks-rd"). */
+    readonly role: string;
+    /** Free-text prompt template sent to the role. */
+    readonly promptTemplate: string;
+    /** Phase-level gate references; runtime looks up the SOP gate by id. */
+    readonly gates: readonly string[];
+    /** Output contract — keys the runtime should expect in the role's verdict. */
+    readonly outputContract: readonly string[];
+    /** Optional ordered list of sibling phase ids that must complete first. */
+    readonly dependsOn?: readonly string[];
+    /** When true, runtime may run this phase in parallel with siblings at the same depth. */
+    readonly parallelGroup?: string;
+}
+/** A gate entry is a thin pointer to a peaks-sop gate; the gate definition
+ *  itself lives in peaks-sop, never in the workflow yaml. */
+export interface WorkflowGate {
+    /** Gate id (matches peaks-sop gate-id). */
+    readonly id: string;
+    /** SOP id that owns the gate definition. */
+    readonly sopId: string;
+    /** Optional human-readable hint shown when the gate fails. */
+    readonly description?: string;
+}
+/** Native evaluator types — the 4 reviewer fan-out members + verdict aggregator
+ *  + Slice C monotonic-improvement guard + Slice D G13/G14/G15 quality-loop
+ *  primitives. Sketch-grade: the 3 quality-loop evaluators shell out to
+ *  existing `peaks impact scan`, `peaks smoke run`, and
+ *  `peaks release canary` CLI surfaces. The authoritative score
+ *  conversion for the monotonic guard lives in
+ *  `src/services/loop/monotonic-guard.ts`. */
+export type EvaluatorKind = 'karpathy' | 'code-review' | 'security-review' | 'perf-baseline' | 'verdict-aggregate' | 'monotonic-improvement' | 'impact-scan' | 'smoke-run' | 'canary-watch';
+/** Evaluator binding — runtime calls `peaks loop eval` directly, no LLM scheduling. */
+export interface WorkflowEvaluator {
+    readonly type: EvaluatorKind;
+    /** Optional gate id this evaluator produces evidence for (e.g. "Gate B3"). */
+    readonly gate?: string;
+    /** Optional scope expression (path or glob) — kept as string for v3.0.0. */
+    readonly scope?: string;
+    /** Optional SLA threshold (evaluator-specific; evaluators interpret their own scale). */
+    readonly threshold?: string;
+}
+/** Context snapshot — files + scope the role/worker should preload. */
+export interface WorkflowContextSnapshot {
+    /** Files the role should read before running (paths, relative to project root). */
+    readonly files: readonly string[];
+    /** Optional memory anchors (e.g. ".peaks/memory/parked-peaks-workflow-primitive.md"). */
+    readonly memory: readonly string[];
+}
+/** Budget caps — runtime stops the loop when any cap is exceeded. */
+export interface WorkflowBudget {
+    /** Hard token cap (sum of role invocations + evaluator outputs). */
+    readonly tokens?: number;
+    /** Wall-clock cap in seconds. */
+    readonly wallSeconds?: number;
+    /** Cycle cap — maximum repair iterations before guard aborts. */
+    readonly cycles?: number;
+}
+export interface WorkflowSpec {
+    /** Schema version; always 1 for v3.0.0. */
+    readonly schemaVersion: 1;
+    /** Stable id (matches filename `<id>.yaml`). */
+    readonly id: string;
+    /** Human-readable label shown in `peaks workflow list`. */
+    readonly label: string;
+    /** Description; one short paragraph. */
+    readonly description: string;
+    /** Phases in declaration order; runtime may parallelize siblings within a group. */
+    readonly phases: readonly WorkflowPhase[];
+    /** Gates referenced by phases; runtime resolves them via peaks-sop. */
+    readonly gates: readonly WorkflowGate[];
+    /** Native evaluators the runtime should invoke. */
+    readonly evaluators: readonly WorkflowEvaluator[];
+    /** Context snapshot for the workflow. */
+    readonly contextSnapshot: WorkflowContextSnapshot;
+    /** Budget caps. */
+    readonly budget: WorkflowBudget;
+}
+/** Result of `lintWorkflowSpec` — pure data, never throws. */
+export interface WorkflowLintReport {
+    readonly ok: boolean;
+    readonly errors: readonly string[];
+    readonly warnings: readonly string[];
+    readonly normalizedSpec?: WorkflowSpec;
+}

package/dist/services/workflow/workflow-spec-types.js

@@ -0,0 +1,13 @@
+/**
+ * peaks-workflow v3.0.0 — Slice A.1 + Slice B.1
+ *
+ * Public type and interface declarations for the workflow spec schema.
+ * Pure data shapes only — no constants, no runtime helpers, no
+ * implementations. Constants (`ID_PATTERN`, `VALID_EVALUATORS`)
+ * remain private to `workflow-spec.ts`; the YAML field helpers
+ * live in `workflow-spec-yaml.ts`; the lint function lives in
+ * `workflow-spec-lint.ts`.
+ *
+ * File budget: ≤ 400 lines (rid-006 split).
+ */
+export {};

package/dist/services/workflow/workflow-spec-yaml.d.ts

@@ -0,0 +1,17 @@
+/**
+ * peaks-workflow v3.0.0 — YAML field helpers
+ *
+ * Private helpers used by the parser in `workflow-spec.ts`. NOT publicly
+ * re-exported; not part of the public API surface. Kept in a sibling
+ * file so the slimmed `workflow-spec.ts` can stay under the 400-line
+ * file-size cap (rid-006 split).
+ *
+ * File budget: ≤ 400 lines (rid-006 split).
+ */
+export declare function leadingSpaces(line: string): number;
+export declare function parseScalar(raw: string): unknown;
+export declare function stringField(obj: Record<string, unknown>, key: string, fallback?: string): string;
+export declare function numberField(obj: Record<string, unknown>, key: string, fallback?: number): number;
+export declare function arrayField(obj: Record<string, unknown>, key: string): unknown[];
+export declare function objectField(obj: Record<string, unknown>, key: string): Record<string, unknown>;
+export declare function stringArrayField(obj: Record<string, unknown>, key: string): readonly string[];

package/dist/services/workflow/workflow-spec-yaml.js

@@ -0,0 +1,88 @@
+/**
+ * peaks-workflow v3.0.0 — YAML field helpers
+ *
+ * Private helpers used by the parser in `workflow-spec.ts`. NOT publicly
+ * re-exported; not part of the public API surface. Kept in a sibling
+ * file so the slimmed `workflow-spec.ts` can stay under the 400-line
+ * file-size cap (rid-006 split).
+ *
+ * File budget: ≤ 400 lines (rid-006 split).
+ */
+export function leadingSpaces(line) {
+    let n = 0;
+    for (const ch of line) {
+        if (ch === ' ')
+            n++;
+        else
+            break;
+    }
+    return n;
+}
+export function parseScalar(raw) {
+    if (raw === '')
+        return '';
+    if (raw === 'true')
+        return true;
+    if (raw === 'false')
+        return false;
+    if (raw === 'null' || raw === '~')
+        return null;
+    // Inline array form `[a, b, c]`
+    if (raw.startsWith('[') && raw.endsWith(']')) {
+        const inner = raw.slice(1, -1).trim();
+        if (inner === '')
+            return [];
+        return inner.split(',').map((s) => parseScalar(s.trim()));
+    }
+    // Strip optional surrounding quotes.
+    if ((raw.startsWith('"') && raw.endsWith('"')) || (raw.startsWith("'") && raw.endsWith("'"))) {
+        return raw.slice(1, -1);
+    }
+    // Number?
+    if (/^-?\d+$/.test(raw))
+        return parseInt(raw, 10);
+    if (/^-?\d+\.\d+$/.test(raw))
+        return parseFloat(raw);
+    return raw;
+}
+export function stringField(obj, key, fallback) {
+    const v = obj[key];
+    if (typeof v === 'string')
+        return v;
+    if (fallback !== undefined)
+        return fallback;
+    throw new Error(`workflow yaml: missing required string field "${key}"`);
+}
+export function numberField(obj, key, fallback) {
+    const v = obj[key];
+    if (typeof v === 'number' && Number.isFinite(v))
+        return v;
+    if (fallback !== undefined)
+        return fallback;
+    throw new Error(`workflow yaml: missing required number field "${key}"`);
+}
+export function arrayField(obj, key) {
+    const v = obj[key];
+    if (v === undefined)
+        return [];
+    if (!Array.isArray(v))
+        throw new Error(`workflow yaml: field "${key}" must be an array`);
+    return v;
+}
+export function objectField(obj, key) {
+    const v = obj[key];
+    if (v === undefined)
+        return {};
+    if (v === null || typeof v !== 'object' || Array.isArray(v)) {
+        throw new Error(`workflow yaml: field "${key}" must be an object`);
+    }
+    return v;
+}
+export function stringArrayField(obj, key) {
+    const v = obj[key];
+    if (v === undefined)
+        return [];
+    if (!Array.isArray(v))
+        throw new Error(`workflow yaml: field "${key}" must be an array of strings`);
+    return v.map((s) => String(s));
+}

package/dist/services/workflow/workflow-spec.d.ts

@@ -19,98 +19,18 @@
  * pair. Anything more elaborate (e.g. conditionals on outputs) belongs
  * in a future minor.
  *
- * File budget: ≤ 800 lines (Karpathy §2).
+ * File budget: ≤ 400 lines (rid-006 split). This file now holds the
+ * parser + private constants + private build helpers; types live in
+ * `workflow-spec-types.ts`; YAML field helpers live in
+ * `workflow-spec-yaml.ts`; lint lives in `workflow-spec-lint.ts`.
+ * The re-export shim at the bottom preserves the original public
+ * surface so external callers (`workflow-loader.ts`,
+ * `loop-eval-commands.ts`, `evaluator-dispatcher.ts`) compile
+ * unchanged.
  */
-/** A workflow phase = a single step the runtime executes. */
-export interface WorkflowPhase {
-    /** Stable id within the workflow (kebab-case). Used as the SOP gate key. */
-    readonly id: string;
-    /** peaks-* role that runs the phase (e.g. "peaks-rd"). */
-    readonly role: string;
-    /** Free-text prompt template sent to the role. */
-    readonly promptTemplate: string;
-    /** Phase-level gate references; runtime looks up the SOP gate by id. */
-    readonly gates: readonly string[];
-    /** Output contract — keys the runtime should expect in the role's verdict. */
-    readonly outputContract: readonly string[];
-    /** Optional ordered list of sibling phase ids that must complete first. */
-    readonly dependsOn?: readonly string[];
-    /** When true, runtime may run this phase in parallel with siblings at the same depth. */
-    readonly parallelGroup?: string;
-}
-/** A gate entry is a thin pointer to a peaks-sop gate; the gate definition
- *  itself lives in peaks-sop, never in the workflow yaml. */
-export interface WorkflowGate {
-    /** Gate id (matches peaks-sop gate-id). */
-    readonly id: string;
-    /** SOP id that owns the gate definition. */
-    readonly sopId: string;
-    /** Optional human-readable hint shown when the gate fails. */
-    readonly description?: string;
-}
-/** Native evaluator types — the 4 reviewer fan-out members + verdict aggregator
- *  + Slice C monotonic-improvement guard + Slice D G13/G14/G15 quality-loop
- *  primitives. Sketch-grade: the 3 quality-loop evaluators shell out to
- *  existing `peaks impact scan`, `peaks smoke run`, and
- *  `peaks release canary` CLI surfaces. The authoritative score
- *  conversion for the monotonic guard lives in
- *  `src/services/loop/monotonic-guard.ts`. */
-export type EvaluatorKind = 'karpathy' | 'code-review' | 'security-review' | 'perf-baseline' | 'verdict-aggregate' | 'monotonic-improvement' | 'impact-scan' | 'smoke-run' | 'canary-watch';
-/** Evaluator binding — runtime calls `peaks loop eval` directly, no LLM scheduling. */
-export interface WorkflowEvaluator {
-    readonly type: EvaluatorKind;
-    /** Optional gate id this evaluator produces evidence for (e.g. "Gate B3"). */
-    readonly gate?: string;
-    /** Optional scope expression (path or glob) — kept as string for v3.0.0. */
-    readonly scope?: string;
-    /** Optional SLA threshold (evaluator-specific; evaluators interpret their own scale). */
-    readonly threshold?: string;
-}
-/** Context snapshot — files + scope the role/worker should preload. */
-export interface WorkflowContextSnapshot {
-    /** Files the role should read before running (paths, relative to project root). */
-    readonly files: readonly string[];
-    /** Optional memory anchors (e.g. ".peaks/memory/parked-peaks-workflow-primitive.md"). */
-    readonly memory: readonly string[];
-}
-/** Budget caps — runtime stops the loop when any cap is exceeded. */
-export interface WorkflowBudget {
-    /** Hard token cap (sum of role invocations + evaluator outputs). */
-    readonly tokens?: number;
-    /** Wall-clock cap in seconds. */
-    readonly wallSeconds?: number;
-    /** Cycle cap — maximum repair iterations before guard aborts. */
-    readonly cycles?: number;
-}
-export interface WorkflowSpec {
-    /** Schema version; always 1 for v3.0.0. */
-    readonly schemaVersion: 1;
-    /** Stable id (matches filename `<id>.yaml`). */
-    readonly id: string;
-    /** Human-readable label shown in `peaks workflow list`. */
-    readonly label: string;
-    /** Description; one short paragraph. */
-    readonly description: string;
-    /** Phases in declaration order; runtime may parallelize siblings within a group. */
-    readonly phases: readonly WorkflowPhase[];
-    /** Gates referenced by phases; runtime resolves them via peaks-sop. */
-    readonly gates: readonly WorkflowGate[];
-    /** Native evaluators the runtime should invoke. */
-    readonly evaluators: readonly WorkflowEvaluator[];
-    /** Context snapshot for the workflow. */
-    readonly contextSnapshot: WorkflowContextSnapshot;
-    /** Budget caps. */
-    readonly budget: WorkflowBudget;
-}
-/** Result of `lintWorkflowSpec` — pure data, never throws. */
-export interface WorkflowLintReport {
-    readonly ok: boolean;
-    readonly errors: readonly string[];
-    readonly warnings: readonly string[];
-    readonly normalizedSpec?: WorkflowSpec;
-}
+import type { WorkflowSpec } from './workflow-spec-types.js';
 /** Parse a raw yaml string into a workflow spec. Pure (no IO), throws on
  *  unparseable input. Use `lintWorkflowSpec` after parsing for semantic checks. */
 export declare function parseWorkflowYaml(raw: string, expectedId: string): WorkflowSpec;
-/** Lint a parsed spec — returns a report with semantic errors / warnings. */
-export declare function lintWorkflowSpec(spec: WorkflowSpec): WorkflowLintReport;
+export { lintWorkflowSpec } from './workflow-spec-lint.js';
+export type { EvaluatorKind, WorkflowBudget, WorkflowContextSnapshot, WorkflowEvaluator, WorkflowGate, WorkflowLintReport, WorkflowPhase, WorkflowSpec } from './workflow-spec-types.js';