synergyspec-selfevolving 1.4.0 → 2.1.0

package/dist/dashboard/react-styles.js

@@ -831,7 +831,7 @@ h1 {
 }
 .evolve-main .panel-title,
 .evolve-main .metric-value,
-.evolve-main .benchmark,
+.evolve-main .episode-name,
 .evolve-main .lineage-node strong { color: #fff; }
 .evolve-main .head-meta,
 .evolve-main .metric-label,
@@ -1424,7 +1424,7 @@ h1 {
 }
 .run-card:hover { transform: translateY(-2px); box-shadow: var(--shadow-md); border-color: var(--line-strong); }
 .run-head { display: flex; justify-content: space-between; gap: 12px; align-items: flex-start; }
-.benchmark { color: var(--ink); font-weight: var(--w-semibold); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.episode-name { color: var(--ink); font-weight: var(--w-semibold); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
 .run-id { margin-top: 3px; color: var(--muted); font: 11px/1.35 var(--mono); word-break: break-all; }
 .donut-wrap { width: 66px; height: 66px; position: relative; flex: 0 0 66px; }
 .donut-center { position: absolute; inset: 0; display: grid; place-items: center; color: var(--ink); font-weight: var(--w-semibold); font-size: 13px; }
@@ -2398,7 +2398,7 @@ h1,
 .panel-title,
 .change-name,
 .empty-title,
-.benchmark,
+.episode-name,
 .interface-plan h2,
 .workflow-step strong,
 .agent-phase strong,

package/dist/dashboard/server.js

@@ -5,7 +5,8 @@ import { createRequire } from 'module';
 import { dirname, isAbsolute, relative, resolve } from 'path';
 import { tailFile, readAllJsonLines } from './tail.js';
 import { renderDashboardHtml } from './index-html.js';
-import { readOverview, readProjectInfo, listChanges, readChange, readCliHistory, readAgentInterfacePlan, listEvolveRuns, readEvolveRun, readEvolveArchive, readArchitecture, } from './data.js';
+import { readOverview, readProjectInfo, listChanges, readChange, readCliHistory, readAgentInterfacePlan, readSelfEvolution, readArchitecture, } from './data.js';
+import { listEpisodes, readEpisode, readRejectBufferAll, } from '../core/self-evolution/index.js';
 const requireFromHere = createRequire(import.meta.url);
 const vendorPackageRoots = new Map();
 const vendorAssets = new Map([
@@ -219,12 +220,11 @@ async function handle(req, res, tracePath, projectRoot, clients) {
         }
     }
     if (req.method === 'GET' && url.pathname === '/') {
-        const [project, changes, cliHistory, runs, archive, history, agentInterface, architecture] = await Promise.all([
+        const [project, changes, cliHistory, se, history, agentInterface, architecture] = await Promise.all([
             readProjectInfo(projectRoot).catch(() => ({})),
             listChanges(projectRoot).catch(() => []),
             readCliHistory(projectRoot, 500).catch(() => []),
-            listEvolveRuns(projectRoot).catch(() => []),
-            readEvolveArchive(projectRoot).catch(() => ({ entries: [], generations: [] })),
+            readSelfEvolution(projectRoot).catch(() => ({ episodes: [], policyLineages: [], rejectBuffer: [] })),
             readAllJsonLines(tracePath).catch(() => []),
             readAgentInterfacePlan(projectRoot).catch(() => null),
             readArchitecture(projectRoot).catch(() => null),
@@ -233,8 +233,9 @@ async function handle(req, res, tracePath, projectRoot, clients) {
             project,
             changes,
             cliHistory,
-            runs,
-            archive: archive ?? { entries: [], generations: [] },
+            episodes: se.episodes,
+            policyLineages: se.policyLineages,
+            rejectBuffer: se.rejectBuffer,
             history,
             agentInterface,
             architecture,
@@ -306,24 +307,29 @@ async function handle(req, res, tracePath, projectRoot, clients) {
         sendJson(res, await readArchitecture(projectRoot));
         return;
     }
-    if (req.method === 'GET' && url.pathname === '/api/evolve/runs') {
-        sendJson(res, await listEvolveRuns(projectRoot));
+    if (req.method === 'GET' && url.pathname === '/api/episodes') {
+        sendJson(res, await listEpisodes(projectRoot));
         return;
     }
-    if (req.method === 'GET' && url.pathname.startsWith('/api/evolve/runs/')) {
-        const id = decodeURIComponent(url.pathname.slice('/api/evolve/runs/'.length));
-        const run = await readEvolveRun(projectRoot, id);
-        if (!run) {
+    if (req.method === 'GET' && url.pathname.startsWith('/api/episodes/')) {
+        const id = decodeURIComponent(url.pathname.slice('/api/episodes/'.length));
+        try {
+            const episode = await readEpisode(projectRoot, id);
+            sendJson(res, episode);
+        }
+        catch {
             res.statusCode = 404;
             res.setHeader('content-type', 'application/json; charset=utf-8');
-            res.end(JSON.stringify({ error: 'run not found', id }));
-            return;
+            res.end(JSON.stringify({ error: 'episode not found', id }));
         }
-        sendJson(res, run);
         return;
     }
-    if (req.method === 'GET' && url.pathname === '/api/evolve/archive') {
-        sendJson(res, (await readEvolveArchive(projectRoot)) ?? { entries: [], generations: [] });
+    if (req.method === 'GET' && url.pathname === '/api/policy/ledger') {
+        sendJson(res, (await readSelfEvolution(projectRoot)).policyLineages);
+        return;
+    }
+    if (req.method === 'GET' && url.pathname === '/api/reject-buffer') {
+        sendJson(res, await readRejectBufferAll(projectRoot));
         return;
     }
     if (req.method === 'GET' && url.pathname === '/api/history') {

package/dist/ui/ascii-patterns.d.ts

@@ -1,21 +1,13 @@
 /**
- * ASCII art animation for the `synergyspec-selfevolving init` welcome screen.
- *
- * A self-evolving DNA double-helix: two strands twist continuously while a
- * generation counter and a fitness bar climb — a nod to the genetic-algorithm /
- * fitness machinery that actually drives self-evolution. Deliberately distinct
- * from the upstream diamond logo so the product reads as its own thing.
- *
- * INVARIANT: every frame has the SAME number of rows. `showWelcomeScreen`
- * (welcome-screen.ts) moves the cursor up by a fixed height derived from
- * `frames[0].length` between redraws, so unequal-height frames corrupt the
- * animation. Enforced by test/ui/welcome-animation.test.ts.
+ * ASCII art animation patterns for the welcome screen.
+ * SynergySpec-SelfEvolving logo animation - diamond/rhombus shape with hollow center "O".
  */
 /**
- * Welcome animation frames — a self-evolving double helix.
- * Each frame: 9 helix rows + a generation row + a fitness row (11 rows total).
- * The helix twists, the generation counter climbs 01→08, and the fitness bar
- * fills, then the cycle loops.
+ * Welcome animation frames - SynergySpec-SelfEvolving logo building from center
+ * 7 rows × 6 columns diamond with hollow center "O"
+ * Center bar is 2 cols × 3 rows (rows 3,4,5 cols 3,4)
+ * Each frame is an array of strings (lines of ASCII art)
+ * Grid: 6 cols × 2 chars = 12 chars wide
  */
 export declare const WELCOME_ANIMATION: {
     interval: number;

package/dist/ui/ascii-patterns.js

@@ -1,64 +1,133 @@
 /**
- * ASCII art animation for the `synergyspec-selfevolving init` welcome screen.
- *
- * A self-evolving DNA double-helix: two strands twist continuously while a
- * generation counter and a fitness bar climb — a nod to the genetic-algorithm /
- * fitness machinery that actually drives self-evolution. Deliberately distinct
- * from the upstream diamond logo so the product reads as its own thing.
- *
- * INVARIANT: every frame has the SAME number of rows. `showWelcomeScreen`
- * (welcome-screen.ts) moves the cursor up by a fixed height derived from
- * `frames[0].length` between redraws, so unequal-height frames corrupt the
- * animation. Enforced by test/ui/welcome-animation.test.ts.
+ * ASCII art animation patterns for the welcome screen.
+ * SynergySpec-SelfEvolving logo animation - diamond/rhombus shape with hollow center "O".
  */
-// Detect if full Unicode is supported (Windows Terminal / modern terminals).
+// Detect if full Unicode is supported
 const supportsUnicode = process.platform !== 'win32' ||
     !!process.env.WT_SESSION || // Windows Terminal
     !!process.env.TERM_PROGRAM; // Modern terminal
-// Helix glyphs with an ASCII fallback for legacy terminals (mirrors the old
-// full/dim/empty fallback pattern — never assume Unicode).
-const G = supportsUnicode
-    ? { node: '●', up: '╱', down: '╲', cross: '╳' }
-    : { node: 'o', up: '/', down: '\\', cross: 'X' };
-// Ascending "fuller" glyphs for the fitness bar; ASCII fallback for legacy terms.
-const FITNESS_RAMP = supportsUnicode ? '▁▂▃▄▅▆▇█' : '.:-=+*#@';
-// One vertical slice of the twisting double helix, at four phases. Scrolling
-// these downward one phase per frame reads as a continuous twist.
-const PHASES = [
-    `     ${G.cross}     `, // crossover
-    `    ${G.up} ${G.down}    `, // diverging (just below a crossover)
-    `   ${G.node}   ${G.node}   `, // strands at max separation
-    `    ${G.down} ${G.up}    `, // converging (just above a crossover)
-];
-const HELIX_ROWS = 9;
-const FRAME_COUNT = 8;
-// Nine rows of helix, phase-shifted by `offset` so the braid scrolls/twists.
-function helixFrame(offset) {
-    const rows = [];
-    for (let i = 0; i < HELIX_ROWS; i++) {
-        rows.push(PHASES[(offset + i) % PHASES.length]);
-    }
-    return rows;
-}
-function generationRow(generation) {
-    return `   gen ${String(generation).padStart(2, '0')}`;
-}
-// Fill `step` (1..FRAME_COUNT) ascending cells of the fitness bar.
-function fitnessRow(step) {
-    return `   fit ${FITNESS_RAMP.slice(0, step)}`;
-}
+// Character set based on Unicode support
+// Block characters for pixel-art aesthetic
+const CHARS = supportsUnicode
+    ? { full: '██', dim: '░░', empty: '  ' }
+    : { full: '##', dim: '++', empty: '  ' };
+const _ = CHARS.empty;
+const F = CHARS.full;
+const D = CHARS.dim;
 /**
- * Welcome animation frames — a self-evolving double helix.
- * Each frame: 9 helix rows + a generation row + a fitness row (11 rows total).
- * The helix twists, the generation counter climbs 01→08, and the fitness bar
- * fills, then the cycle loops.
+ * Welcome animation frames - SynergySpec-SelfEvolving logo building from center
+ * 7 rows × 6 columns diamond with hollow center "O"
+ * Center bar is 2 cols × 3 rows (rows 3,4,5 cols 3,4)
+ * Each frame is an array of strings (lines of ASCII art)
+ * Grid: 6 cols × 2 chars = 12 chars wide
  */
 export const WELCOME_ANIMATION = {
-    interval: 110,
-    frames: Array.from({ length: FRAME_COUNT }, (_unused, k) => [
-        ...helixFrame(k),
-        generationRow(k + 1),
-        fitnessRow(k + 1),
-    ]),
+    interval: 120,
+    frames: [
+        // Frame 1: Empty
+        [
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 1
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 2
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 3
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+        ],
+        // Frame 2: Center blocks appear (dim) - 2x3 center bar
+        [
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 1
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 2
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 3
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${D}${D}${_}${_}`,
+            `${_}${_}${_}${_}${D}${D}${_}${_}`,
+            `${_}${_}${_}${_}${D}${D}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+        ],
+        // Frame 3: Center blocks solidify
+        [
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 1
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 2
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 3
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+        ],
+        // Frame 4: Top and bottom points appear
+        [
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 1
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 2
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 3
+            `${_}${_}${_}${_}${D}${D}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${D}${D}${_}${_}`,
+        ],
+        // Frame 5: Inner ring forming
+        [
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 1
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 2
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 3
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${D}${_}${_}${D}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${D}${_}${_}${D}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+        ],
+        // Frame 6: Outer ring appearing
+        [
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 1
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 2
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 3
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${F}${_}${_}${F}${_}`,
+            `${_}${_}${D}${_}${F}${F}${_}${D}`,
+            `${_}${_}${D}${_}${F}${F}${_}${D}`,
+            `${_}${_}${D}${_}${F}${F}${_}${D}`,
+            `${_}${_}${_}${F}${_}${_}${F}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+        ],
+        // Frame 7: Full logo
+        [
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 1
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 2
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 3
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${F}${_}${_}${F}${_}`,
+            `${_}${_}${F}${_}${F}${F}${_}${F}`,
+            `${_}${_}${F}${_}${F}${F}${_}${F}`,
+            `${_}${_}${F}${_}${F}${F}${_}${F}`,
+            `${_}${_}${_}${F}${_}${_}${F}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+        ],
+        // Frame 8: Hold complete logo
+        [
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 1
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 2
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 3
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${F}${_}${_}${F}${_}`,
+            `${_}${_}${F}${_}${F}${F}${_}${F}`,
+            `${_}${_}${F}${_}${F}${F}${_}${F}`,
+            `${_}${_}${F}${_}${F}${F}${_}${F}`,
+            `${_}${_}${_}${F}${_}${_}${F}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+        ],
+    ],
 };
 //# sourceMappingURL=ascii-patterns.js.map

package/dist/ui/welcome-screen.d.ts

@@ -2,20 +2,6 @@
  * Animated welcome screen for the experimental artifact workflow setup.
  * Shows side-by-side layout with animated ASCII art on left and welcome text on right.
  */
-/**
- * Welcome text content (right column).
- * Leads with the self-evolving loop — the thing that sets this apart.
- * Keep each line ≤ 35 visible chars so it never wraps at the 60-col MIN_WIDTH
- * after the 24-col art gutter (locked by test/ui/welcome-animation.test.ts).
- */
-export declare function getWelcomeText(): string[];
-/**
- * Renders a single frame with side-by-side layout.
- * `artColor` lets the caller pulse the helix color per frame; the raw art is
- * padded to the column width BEFORE coloring so ANSI codes never count toward
- * the width and the text column stays aligned.
- */
-export declare function renderFrame(artLines: string[], textLines: string[], artColor?: (s: string) => string): string;
 /**
  * Shows the animated welcome screen.
  * Returns when user presses Enter.

package/dist/ui/welcome-screen.js

@@ -9,61 +9,43 @@ const MIN_WIDTH = 60;
 // Width of the ASCII art column (with padding)
 const ART_COLUMN_WIDTH = 24;
 /**
- * Welcome text content (right column).
- * Leads with the self-evolving loop — the thing that sets this apart.
- * Keep each line ≤ 35 visible chars so it never wraps at the 60-col MIN_WIDTH
- * after the 24-col art gutter (locked by test/ui/welcome-animation.test.ts).
+ * Welcome text content (right column)
  */
-export function getWelcomeText() {
+function getWelcomeText() {
     return [
         chalk.white.bold('Welcome to SynergySpec-SelfEvolving'),
-        chalk.dim('Specs that evolve as you work'),
+        chalk.dim('A lightweight spec-driven framework'),
         '',
         chalk.white('This setup will configure:'),
         chalk.dim('  • Agent Skills for AI tools'),
         chalk.dim('  • /synspec:* slash commands'),
-        chalk.green('  • A self-evolution loop'),
-        chalk.dim('    that improves its own prompts'),
         '',
         chalk.white('Quick start after setup:'),
-        `  ${chalk.yellow('/synspec:propose')} ${chalk.dim('Start a change')}`,
-        `  ${chalk.yellow('/synspec:apply')}   ${chalk.dim('Implement tasks')}`,
-        `  ${chalk.yellow('/synspec:learn')}   ${chalk.green('Evolve from runs')}`,
+        `  ${chalk.yellow('/synspec:new')}      ${chalk.dim('Create a change')}`,
+        `  ${chalk.yellow('/synspec:continue')} ${chalk.dim('Next artifact')}`,
+        `  ${chalk.yellow('/synspec:apply')}    ${chalk.dim('Implement tasks')}`,
         '',
         chalk.cyan('Press Enter to select tools...'),
     ];
 }
 /**
- * Renders a single frame with side-by-side layout.
- * `artColor` lets the caller pulse the helix color per frame; the raw art is
- * padded to the column width BEFORE coloring so ANSI codes never count toward
- * the width and the text column stays aligned.
+ * Renders a single frame with side-by-side layout
  */
-export function renderFrame(artLines, textLines, artColor = chalk.cyan) {
+function renderFrame(artLines, textLines) {
     const maxLines = Math.max(artLines.length, textLines.length);
     const lines = [];
     for (let i = 0; i < maxLines; i++) {
         const artLine = artLines[i] || '';
         const textLine = textLines[i] || '';
-        // Pad the art column to fixed width (raw, before color)
+        // Pad the art column to fixed width
         const paddedArt = artLine.padEnd(ART_COLUMN_WIDTH);
-        // Color the helix art (caller-supplied so it can "pulse" between frames)
-        const coloredArt = artColor(paddedArt);
+        // Color the ASCII art with cyan for visual appeal
+        const coloredArt = chalk.cyan(paddedArt);
         // Clear line before writing to prevent residual characters
         lines.push(`\x1b[2K${coloredArt}${textLine}`);
     }
     return lines.join('\n');
 }
-/**
- * Per-frame color cycle that makes the helix look alive/evolving
- * (cyan → bright cyan → green → bright green → …).
- */
-const PULSE_COLORS = [
-    chalk.cyan,
-    chalk.cyanBright,
-    chalk.green,
-    chalk.greenBright,
-];
 /**
  * Checks if the terminal supports animation
  */
@@ -119,9 +101,9 @@ function waitForEnter() {
 export async function showWelcomeScreen() {
     const textLines = getWelcomeText();
     if (!canAnimate()) {
-        // Fallback: show the fully-evolved final frame (greenBright = "evolved").
-        const frame = WELCOME_ANIMATION.frames[WELCOME_ANIMATION.frames.length - 1];
-        process.stdout.write('\n' + renderFrame(frame, textLines, chalk.greenBright) + '\n\n');
+        // Fallback: show static welcome
+        const frame = WELCOME_ANIMATION.frames[3]; // Peak frame
+        process.stdout.write('\n' + renderFrame(frame, textLines) + '\n\n');
         return;
     }
     let frameIndex = 0;
@@ -144,9 +126,8 @@ export async function showWelcomeScreen() {
             process.stdout.write(`\x1b[${frameHeight}A`);
         }
         isFirstRender = false;
-        // Render current frame with a pulsing helix color (alive/evolving)
-        const color = PULSE_COLORS[frameIndex % PULSE_COLORS.length];
-        process.stdout.write(renderFrame(frame, textLines, color) + '\n\n');
+        // Render current frame
+        process.stdout.write(renderFrame(frame, textLines) + '\n\n');
         // Advance to next frame
         frameIndex = (frameIndex + 1) % WELCOME_ANIMATION.frames.length;
     }, WELCOME_ANIMATION.interval);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synergyspec-selfevolving",
-  "version": "1.4.0",
+  "version": "2.1.0",
   "description": "AI-native system for spec-driven development",
   "keywords": [
     "synergyspec-selfevolving",

package/dist/core/self-evolution/ga-selection.d.ts

@@ -1,94 +0,0 @@
-/**
- * GA selection step for the online self-evolution outer loop.
- *
- * When several candidate template-variants compete to evolve the SAME canonical
- * target (e.g. two proposed edits to `artifact-template:design`), the genetic
- * algorithm must rank them by ACCUMULATED real-usage fitness and pick winners.
- * "Fitness" here is the retrospective outcome data each candidate accrues in its
- * `fitness-record.jsonl` sidecar (see {@link readCandidateFitness}): one sample
- * per real change the candidate was active for.
- *
- * Ranking convention (best-first):
- *   1. Lower meanLoss is better. A candidate with no records (count === 0, hence
- *      meanLoss === null) is UNPROVEN and sorts LAST regardless of pass rate.
- *   2. Tie-break by higher meanPassRate.
- *   3. Then by higher count (more evidence behind the same loss/pass numbers).
- *   4. Finally by candidateId (lexicographic) so the order is fully
- *      deterministic even when every fitness signal ties.
- *
- * Pure-ish: the only I/O is reading each candidate's fitness sidecar (and, for
- * {@link groupCandidatesByTarget}, enumerating candidate dirs) via the supplied
- * {@link CandidateRepoLayout}. No timestamps, no randomness.
- */
-import { type CandidateRepoLayout } from './candidates.js';
-/**
- * One row of a per-target candidate ranking. `meanLoss`/`meanPassRate` are
- * `null` for an unproven candidate (no accumulated fitness records yet).
- */
-export interface RankedCandidate {
-    candidateId: string;
-    /**
-     * The canonical target this ranking row is about. Populated by
-     * {@link groupCandidatesByTarget}-driven flows; the plain
-     * {@link rankCandidatesForTarget} entry point leaves it as `''` because it
-     * ranks an explicit candidate list without re-reading their `targetIds`.
-     */
-    targetId: string;
-    /** Accumulated mean loss in [0,1]; null when unproven. Lower is better. */
-    meanLoss: number | null;
-    /** Accumulated mean pass rate in [0,1]; null when unproven. Higher is better. */
-    meanPassRate: number | null;
-    /** Number of accumulated fitness records (evidence count). */
-    count: number;
-    /** Loss trend from the fitness sidecar: improving | stable | declining | unknown. */
-    trend: string;
-}
-/**
- * Read each candidate's accumulated fitness and return the candidates sorted
- * BEST-FIRST (see module doc for the full key order). Deterministic.
- *
- * @param layout       Resolved candidate-repo layout (file I/O happens through it).
- * @param candidateIds The competing candidate ids to rank. Duplicates are
- *                     de-duplicated (first occurrence wins) so the same id is
- *                     never read twice.
- * @param targetId     Optional canonical target id to stamp onto each row.
- */
-export declare function rankCandidatesForTarget(layout: CandidateRepoLayout, candidateIds: string[], targetId?: string): Promise<RankedCandidate[]>;
-/**
- * Convenience: the single best candidate for a target, or `null` when the
- * candidate list is empty.
- */
-export declare function selectBestCandidate(layout: CandidateRepoLayout, candidateIds: string[], targetId?: string): Promise<RankedCandidate | null>;
-/**
- * Enumerate every candidate in the repo (via {@link listCandidates}) and group
- * their ids by the canonical target id they intend to touch. A candidate that
- * declares multiple `targetIds` appears under each of them.
- *
- * The candidateId arrays are sorted lexicographically for determinism. Returns
- * an empty map when there are no candidates (or the base dir does not exist —
- * {@link listCandidates} handles that case).
- */
-export declare function groupCandidatesByTarget(layout: CandidateRepoLayout): Promise<Map<string, string[]>>;
-/**
- * The accumulated baseline reading for a target's de-facto canonical variant:
- * the promoted candidate whose fitness sidecar supplies the baseline loss.
- */
-export interface PromotedBaseline {
-    candidateId: string;
-    meanLoss: number;
-    /** createdAt of the baseline candidate (for reporting). */
-    recordedAt: string;
-}
-/**
- * The de-facto canonical baseline loss for a target: the accumulated mean loss
- * of the MOST RECENTLY promoted candidate that has measured fitness. Returns
- * null when no promoted candidate for the target has a non-null meanLoss (⇒
- * downstream gates/trajectory cannot use a baseline). Rolled-back candidates are
- * excluded automatically (they are status 'rolled-back', not 'promoted').
- *
- * `listCandidates` already returns promoted candidates sorted by `createdAt`
- * DESCENDING (ties by id), so the first proven candidate in iteration order is
- * the most recently promoted one with fitness.
- */
-export declare function readPromotedBaselineLoss(layout: CandidateRepoLayout, targetId: string): Promise<PromotedBaseline | null>;
-//# sourceMappingURL=ga-selection.d.ts.map