synergyspec-selfevolving 1.3.0 → 2.0.0

package/dist/core/trajectory/skeleton.js

@@ -0,0 +1,239 @@
+/**
+ * Action-skeleton projection: a BOUNDED, ordered play-by-play of what the agent
+ * actually did in the observed run — `wrote design.md → ran tests: 3 failed →
+ * edited normalize.py (x4) → ran tests: 0 failed`.
+ *
+ * This is the trajectory the critic reads. It is deliberately a PROJECTION of
+ * the same window-scoped {@link NormalizedTrajectory} the observed-verified
+ * gate grades (one shared implementation over the normalized shape — never
+ * per-adapter, so the three harnesses cannot drift), and deliberately lossy:
+ * only file edits, test runs, and other shell commands survive; reads, prose,
+ * and reasoning are dropped. Ordering is the stitched turn order (main session
+ * first, then subagents) — the exact order `collectRunnerResults` grades in.
+ *
+ * Pure + no throw. `null` in → `null` out.
+ */
+import { parseTestMetrics } from '../fitness/test-metrics.js';
+import { commandText, inputLooksLikeRunner, isExecTool } from './facts.js';
+const MAX_SKELETON_EVENTS = 40;
+const MAX_COMMAND_CHARS = 120;
+/**
+ * Matches the NAME of a file-mutating tool across harnesses — Claude
+ * `Write`/`Edit`/`MultiEdit`/`NotebookEdit`; opencode `write`/`edit`/`patch`;
+ * Codex `apply_patch`; generic `str_replace`/`create_file` variants. Deny by
+ * default (same philosophy as facts.ts's EXEC_TOOL_RE): an unrecognized tool
+ * name degrades to "event skipped", never to a phantom edit. Word-boundaried
+ * on `._-`; `multiedit`/`notebookedit` are single lowercase tokens after
+ * `.toLowerCase()`, so they are listed explicitly.
+ */
+const EDIT_TOOL_RE = /(?:^|[._-])(?:write|edit|multiedit|notebookedit|patch|apply_patch|str_replace|replace|create|update)(?:[._-]|$)/i;
+/** Input fields that carry the edited file path, in preference order. */
+const FILE_FIELDS = ['file_path', 'filePath', 'path', 'notebook_path', 'notebookPath'];
+/** `*** (Add|Update|Delete) File: <path>` lines inside an apply_patch payload. */
+const PATCH_FILE_RE = /^\*{3}\s+(?:Add|Update|Delete)\s+File:\s+(.+)$/gm;
+function toPosix(p) {
+    return p.replace(/\\/g, '/').trim();
+}
+function isEditTool(tool) {
+    return tool !== undefined && EDIT_TOOL_RE.test(tool);
+}
+/** `*** … File:` paths inside an apply_patch-style payload (markers only). */
+function patchFilesFromPayload(input) {
+    if (!input)
+        return [];
+    const files = [];
+    for (const value of Object.values(input)) {
+        if (typeof value !== 'string')
+            continue;
+        for (const m of value.matchAll(PATCH_FILE_RE))
+            files.push(toPosix(m[1]));
+    }
+    return files;
+}
+/**
+ * Extract the edited file path(s) from a FILE-tool call's input: a path field
+ * first, else patch-body markers. Never used for exec tools — their inputs
+ * legitimately carry `path`-like fields (cwd) that are not edits.
+ */
+function editedFiles(input) {
+    if (!input)
+        return [];
+    for (const f of FILE_FIELDS) {
+        const v = input[f];
+        if (typeof v === 'string' && v.trim().length > 0)
+            return [toPosix(v)];
+    }
+    return patchFilesFromPayload(input);
+}
+function capCommand(command) {
+    if (!command)
+        return undefined;
+    const c = command.trim().replace(/\s+/g, ' ');
+    return c.length > MAX_COMMAND_CHARS ? `${c.slice(0, MAX_COMMAND_CHARS - 1)}…` : c;
+}
+/**
+ * Project the bounded action skeleton from a normalized trajectory. One walk,
+ * the same call→result pairing approach as facts.ts's collectRunnerResults
+ * (callId map with a positional fallback).
+ */
+export function toActionSkeleton(trajectory) {
+    if (!trajectory)
+        return null;
+    const pendingByCallId = new Map();
+    let lastPending = null;
+    let totalToolCalls = 0;
+    const events = [];
+    const append = (event) => {
+        // Per-file rollup: consecutive edits to the same file collapse.
+        const prev = events[events.length - 1];
+        if (event.kind === 'file-edit' &&
+            prev?.kind === 'file-edit' &&
+            prev.file === event.file &&
+            prev.sessionId === event.sessionId) {
+            prev.editCount = (prev.editCount ?? 1) + 1;
+            return prev;
+        }
+        events.push(event);
+        return event;
+    };
+    for (const turn of trajectory.turns) {
+        for (const part of turn.parts) {
+            if (part.kind === 'tool_call') {
+                totalToolCalls++;
+                const exec = isExecTool(part.tool);
+                if (exec) {
+                    const command = capCommand(commandText(part.input));
+                    // A shell-driven apply_patch (codex heredoc style) carries
+                    // `*** Update File: <path>` lines in its payload — that's a file
+                    // edit, not a command. Markers only: an exec input's `path`-like
+                    // fields (cwd) must never read as edits.
+                    const patchedFiles = patchFilesFromPayload(part.input);
+                    if (patchedFiles.length > 0) {
+                        for (const file of patchedFiles) {
+                            append({
+                                kind: 'file-edit',
+                                ordinal: 0,
+                                tool: part.tool,
+                                file,
+                                editCount: 1,
+                                ...(turn.sessionId ? { sessionId: turn.sessionId } : {}),
+                            });
+                        }
+                        lastPending = null;
+                        continue;
+                    }
+                    const event = append({
+                        kind: inputLooksLikeRunner(part.input) ? 'test-run' : 'command',
+                        ordinal: 0,
+                        tool: part.tool,
+                        ...(command ? { command } : {}),
+                        ...(turn.sessionId ? { sessionId: turn.sessionId } : {}),
+                    });
+                    const pending = { event };
+                    lastPending = pending;
+                    if (part.callId)
+                        pendingByCallId.set(part.callId, pending);
+                    continue;
+                }
+                if (isEditTool(part.tool)) {
+                    for (const file of editedFiles(part.input)) {
+                        append({
+                            kind: 'file-edit',
+                            ordinal: 0,
+                            tool: part.tool,
+                            file,
+                            editCount: 1,
+                            ...(turn.sessionId ? { sessionId: turn.sessionId } : {}),
+                        });
+                    }
+                }
+                lastPending = null;
+            }
+            else if (part.kind === 'tool_result') {
+                const pending = part.callId && pendingByCallId.has(part.callId)
+                    ? pendingByCallId.get(part.callId)
+                    : !part.callId && lastPending
+                        ? lastPending
+                        : undefined;
+                if (pending) {
+                    const e = pending.event;
+                    if (typeof part.exitCode === 'number')
+                        e.exitCode = part.exitCode;
+                    if (e.kind === 'test-run' && typeof part.output === 'string') {
+                        const metrics = parseTestMetrics(part.output);
+                        if (metrics) {
+                            e.passRate = metrics.passRate;
+                            e.failedCount = metrics.failed;
+                        }
+                    }
+                }
+                lastPending = null;
+            }
+        }
+    }
+    // Stamp ordinals on the full (rolled-up) sequence, then middle-out truncate.
+    events.forEach((e, i) => {
+        e.ordinal = i;
+    });
+    let bounded = events;
+    let truncated = false;
+    if (events.length > MAX_SKELETON_EVENTS) {
+        const head = Math.ceil(MAX_SKELETON_EVENTS / 2);
+        const tail = MAX_SKELETON_EVENTS - head;
+        bounded = [...events.slice(0, head), ...events.slice(events.length - tail)];
+        truncated = true;
+    }
+    return {
+        harness: trajectory.harness,
+        events: bounded,
+        totalToolCalls,
+        truncated,
+    };
+}
+function basename(p) {
+    const parts = p.split('/');
+    return parts[parts.length - 1] || p;
+}
+function renderEvent(e) {
+    if (e.kind === 'file-edit') {
+        const verb = /(?:^|[._-])(?:write|create)(?:[._-]|$)/i.test(e.tool) ? 'wrote' : 'edited';
+        const times = (e.editCount ?? 1) > 1 ? ` (x${e.editCount})` : '';
+        return `${verb} ${basename(e.file ?? '?')}${times}`;
+    }
+    if (e.kind === 'test-run') {
+        if (typeof e.failedCount === 'number') {
+            return `ran tests: ${e.failedCount} failed`;
+        }
+        if (typeof e.exitCode === 'number') {
+            return `ran tests (exit ${e.exitCode})`;
+        }
+        return 'ran tests';
+    }
+    return e.command ? `ran \`${e.command}\`` : `ran ${e.tool}`;
+}
+/**
+ * Human-readable one-line(ish) play-by-play. Deterministic; events are dropped
+ * middle-out (with an elision marker) until the string fits `maxChars`.
+ */
+export function renderActionSkeleton(skeleton, maxChars = 1600) {
+    if (skeleton.events.length === 0)
+        return '(no file edits or shell commands observed)';
+    let omitted = skeleton.truncated ? 1 : 0; // marker for projection-time truncation
+    let items = skeleton.events.map(renderEvent);
+    const join = (parts, elided) => {
+        if (elided <= 0)
+            return parts.join(' → ');
+        const head = parts.slice(0, Math.ceil(parts.length / 2));
+        const tail = parts.slice(Math.ceil(parts.length / 2));
+        return `${head.join(' → ')} → … → ${tail.join(' → ')}`;
+    };
+    let text = join(items, omitted);
+    while (text.length > maxChars && items.length > 2) {
+        // Drop the middle event and re-join with an elision marker.
+        items = [...items.slice(0, Math.floor(items.length / 2)), ...items.slice(Math.floor(items.length / 2) + 1)];
+        omitted++;
+        text = join(items, omitted);
+    }
+    return text.length > maxChars ? `${text.slice(0, maxChars - 1)}…` : text;
+}
+//# sourceMappingURL=skeleton.js.map

package/dist/dashboard/data.d.ts

@@ -1,3 +1,4 @@
+import { type EpisodeRecord, type PolicyLedgerEntry, type RejectBufferEntry } from '../core/self-evolution/index.js';
 export interface ProjectInfo {
     name: string;
     version: string;
@@ -32,39 +33,6 @@ export interface CliHistoryEvent {
     durationMs?: number;
     metadata?: Record<string, unknown>;
 }
-export type EvolveRunStatus = 'completed' | 'errored' | 'pending' | 'empty';
-export interface EvolveRunSummary {
-    schemaVersion?: number;
-    runId: string;
-    benchmarkId?: string;
-    harnessVariant?: string;
-    startedAt?: string;
-    finishedAt?: string;
-    taskCount?: number;
-    verdictCounts?: Record<string, number>;
-    passRate?: number;
-    totalCostUsd?: number;
-    totalWallTimeMs?: number;
-    interrupted?: boolean;
-    isolationMode?: string;
-    budget?: Record<string, unknown>;
-    status?: EvolveRunStatus;
-    failureReasonSummary?: string;
-}
-export interface EvolveArchive {
-    schemaVersion?: number;
-    createdAt?: string;
-    entries: Array<{
-        id: string;
-        parentId: string | null;
-        generation: number;
-        createdAt?: string;
-        snapshotPath?: string;
-        runs?: unknown[];
-        childCount?: number;
-    }>;
-    generations?: unknown[];
-}
 export interface ProjectOverview {
     project: ProjectInfo;
     changes: {
@@ -73,15 +41,25 @@ export interface ProjectOverview {
         inProgress: number;
     };
     evolve: {
-        runs: number;
-        lastRunAt: string | null;
-        lastVerdict: string | null;
+        episodes: number;
+        lastEpisodeAt: string | null;
+        lastStage: string | null;
+        headVersion: number | null;
     };
     cli: {
         totalEvents: number;
         recentFailures: number;
     };
 }
+export interface PolicyLineage {
+    targetId: string;
+    headVersion: number | null;
+    entries: PolicyLedgerEntry[];
+    evolveCount: number;
+    rollbackCount: number;
+    refusedCount: number;
+    lastAt: string | null;
+}
 export interface AgentInterfacePlan {
     schemaVersion: 1;
     generatedAt: string;
@@ -193,21 +171,17 @@ export declare function readProjectInfo(root: string): Promise<ProjectInfo>;
 export declare function readChange(root: string, id: string): Promise<ChangeSummary | null>;
 export declare function listChanges(root: string): Promise<ChangeSummary[]>;
 export declare function readCliHistory(root: string, limit?: number): Promise<CliHistoryEvent[]>;
-export interface EvolveRunDetail extends EvolveRunSummary {
-    tasks: Array<{
-        taskId: string;
-        verdict?: string;
-        wallTimeMs?: number;
-        totalCostUsd?: number;
-        reason?: string;
-    }>;
-    wrapperStderrTail?: string;
-    wrapperStdoutTail?: string;
-    fileListing?: string[];
-}
-export declare function listEvolveRuns(root: string): Promise<EvolveRunSummary[]>;
-export declare function readEvolveRun(root: string, runId: string): Promise<EvolveRunDetail | null>;
-export declare function readEvolveArchive(root: string): Promise<EvolveArchive | null>;
+/**
+ * Read the loop-v2 self-evolution surface: per-episode two-arm forward records,
+ * the policy version ledger grouped into per-target lineages, and the
+ * reject-buffer of rolled-back episodes. Each reader is independently guarded so
+ * a single missing/unreadable store yields an empty slice rather than throwing.
+ */
+export declare function readSelfEvolution(root: string): Promise<{
+    episodes: EpisodeRecord[];
+    policyLineages: PolicyLineage[];
+    rejectBuffer: RejectBufferEntry[];
+}>;
 export declare function readAgentInterfacePlan(root: string): Promise<AgentInterfacePlan>;
 export declare function readOverview(root: string): Promise<ProjectOverview>;
 /**

package/dist/dashboard/data.js

@@ -2,6 +2,7 @@ import { promises as fs } from 'fs';
 import { join, resolve, dirname } from 'path';
 import { readAllJsonLines } from './tail.js';
 import { readAgentCognitiveEvents, summarizeAgentCognitiveTrace, } from '../history/cognitive.js';
+import { listEpisodes, readPolicyLedgerAll, readRejectBufferAll, } from '../core/self-evolution/index.js';
 async function tryReadJson(path) {
     try {
         const raw = await fs.readFile(path, 'utf8');
@@ -137,156 +138,42 @@ export async function readCliHistory(root, limit = 200) {
     const events = await readAllJsonLines(path);
     return events.slice(-limit).reverse();
 }
-const LOG_TAIL_BYTES = 16 * 1024;
-async function tryReadFileTail(path, maxBytes = LOG_TAIL_BYTES) {
-    try {
-        const stat = await fs.stat(path);
-        if (stat.size === 0)
-            return null;
-        if (stat.size <= maxBytes)
-            return await fs.readFile(path, 'utf8');
-        const handle = await fs.open(path, 'r');
-        try {
-            const buf = Buffer.alloc(maxBytes);
-            await handle.read(buf, 0, maxBytes, stat.size - maxBytes);
-            return '…\n' + buf.toString('utf8');
-        }
-        finally {
-            await handle.close();
-        }
-    }
-    catch {
-        return null;
-    }
-}
-async function classifyRunStatus(dir, summary) {
-    if (summary && summary.verdictCounts)
-        return 'completed';
-    let hasAnyFiles = false;
-    let hasWrapperStderr = false;
-    try {
-        const items = await fs.readdir(dir, { withFileTypes: true });
-        hasAnyFiles = items.length > 0;
-        for (const item of items) {
-            if (item.isFile() && item.name === 'wrapper.stderr.log') {
-                const stat = await fs.stat(join(dir, item.name));
-                if (stat.size > 0)
-                    hasWrapperStderr = true;
-            }
-        }
-    }
-    catch {
-        return 'empty';
-    }
-    if (hasWrapperStderr)
-        return 'errored';
-    if (hasAnyFiles)
-        return 'pending';
-    return 'empty';
-}
-function summarizeFailureReason(reason) {
-    if (!reason)
-        return undefined;
-    const lines = reason
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter(Boolean);
-    if (!lines.length)
-        return undefined;
-    const mismatchCount = lines.filter((line) => /sha256 mismatch/i.test(line)).length;
-    if (mismatchCount > 1)
-        return `${mismatchCount} genome file hash mismatches`;
-    return lines[0].replace(/\s+/g, ' ').slice(0, 180);
-}
-async function readRunFailureReasonSummary(runDir) {
-    const tasksDir = join(runDir, 'tasks');
-    let taskNames = [];
-    try {
-        const items = await fs.readdir(tasksDir, { withFileTypes: true });
-        taskNames = items.filter((d) => d.isDirectory()).map((d) => d.name);
-    }
-    catch {
-        return undefined;
-    }
-    for (const taskName of taskNames) {
-        const result = await tryReadJson(join(tasksDir, taskName, 'result.json'));
-        const summary = summarizeFailureReason(result?.reason);
-        if (summary)
-            return summary;
-    }
-    return undefined;
-}
-export async function listEvolveRuns(root) {
-    const dir = join(root, 'evolve', 'runs');
-    let entries = [];
-    try {
-        const items = await fs.readdir(dir, { withFileTypes: true });
-        entries = items.filter((d) => d.isDirectory()).map((d) => d.name);
-    }
-    catch {
-        return [];
-    }
-    const summaries = await Promise.all(entries.map(async (id) => {
-        const runDir = join(dir, id);
-        const summary = await tryReadJson(join(runDir, 'summary.json'));
-        const status = await classifyRunStatus(runDir, summary);
-        const failureReasonSummary = await readRunFailureReasonSummary(runDir);
-        if (!summary)
-            return { runId: id, status, failureReasonSummary };
-        return { ...summary, runId: summary.runId ?? id, status, failureReasonSummary };
-    }));
-    return summaries.sort((a, b) => (b.startedAt ?? '').localeCompare(a.startedAt ?? ''));
-}
-export async function readEvolveRun(root, runId) {
-    const dir = join(root, 'evolve', 'runs', runId);
-    const dirStat = await tryStat(dir);
-    if (!dirStat)
-        return null;
-    const summary = await tryReadJson(join(dir, 'summary.json'));
-    const status = await classifyRunStatus(dir, summary);
-    const tasksDir = join(dir, 'tasks');
-    let taskNames = [];
-    try {
-        const items = await fs.readdir(tasksDir, { withFileTypes: true });
-        taskNames = items.filter((d) => d.isDirectory()).map((d) => d.name);
-    }
-    catch {
-        // No tasks dir.
-    }
-    const tasks = await Promise.all(taskNames.map(async (taskId) => {
-        const result = await tryReadJson(join(tasksDir, taskId, 'result.json'));
-        return {
-            taskId,
-            verdict: result?.verdict,
-            wallTimeMs: result?.telemetry?.wallTimeMs,
-            totalCostUsd: result?.telemetry?.totalCostUsd,
-            reason: result?.reason,
-        };
-    }));
-    const needsDiagnostics = !summary || status !== 'completed';
-    const wrapperStderrTail = needsDiagnostics
-        ? (await tryReadFileTail(join(dir, 'wrapper.stderr.log'))) ?? undefined
-        : undefined;
-    const wrapperStdoutTail = needsDiagnostics
-        ? (await tryReadFileTail(join(dir, 'wrapper.stdout.log'))) ?? undefined
-        : undefined;
-    let fileListing;
-    if (needsDiagnostics) {
-        try {
-            const items = await fs.readdir(dir, { withFileTypes: true });
-            fileListing = items.map((d) => d.name + (d.isDirectory() ? '/' : ''));
-        }
-        catch {
-            fileListing = undefined;
-        }
+/**
+ * Read the loop-v2 self-evolution surface: per-episode two-arm forward records,
+ * the policy version ledger grouped into per-target lineages, and the
+ * reject-buffer of rolled-back episodes. Each reader is independently guarded so
+ * a single missing/unreadable store yields an empty slice rather than throwing.
+ */
+export async function readSelfEvolution(root) {
+    const [episodes, ledger, rejectBuffer] = await Promise.all([
+        listEpisodes(root).catch(() => []),
+        readPolicyLedgerAll(root).catch(() => []),
+        readRejectBufferAll(root).catch(() => []),
+    ]);
+    // Group ledger entries by targetId, preserving append order within each group.
+    const byTarget = new Map();
+    for (const entry of ledger) {
+        const list = byTarget.get(entry.targetId);
+        if (list)
+            list.push(entry);
+        else
+            byTarget.set(entry.targetId, [entry]);
+    }
+    const policyLineages = [];
+    for (const [targetId, entries] of byTarget) {
+        const last = entries[entries.length - 1];
+        policyLineages.push({
+            targetId,
+            headVersion: last ? last.version : null,
+            entries,
+            evolveCount: entries.filter((e) => e.action === 'evolve').length,
+            rollbackCount: entries.filter((e) => e.action === 'rollback').length,
+            refusedCount: entries.filter((e) => e.action === 'refused').length,
+            lastAt: last ? last.at : null,
+        });
     }
-    const base = summary
-        ? { ...summary, runId: summary.runId ?? runId, status }
-        : { runId, status };
-    return { ...base, tasks, wrapperStderrTail, wrapperStdoutTail, fileListing };
-}
-export async function readEvolveArchive(root) {
-    return tryReadJson(join(root, 'evolve', 'archive', 'archive.json'));
+    policyLineages.sort((a, b) => (b.lastAt ?? '').localeCompare(a.lastAt ?? ''));
+    return { episodes, policyLineages, rejectBuffer };
 }
 export async function readAgentInterfacePlan(root) {
     const { events, skippedRecords } = await readAgentCognitiveEvents({
@@ -366,10 +253,10 @@ export async function readAgentInterfacePlan(root) {
                 boundary: 'Same workflow, tool-native syntax.',
             },
             {
-                id: 'lab',
+                id: 'self-evolution',
                 label: 'Self-evolution',
-                command: 'synergyspec-selfevolving self-evolution evolve',
-                purpose: 'Score and rank candidate template variants into a human-gated promotion report.',
+                command: 'synergyspec-selfevolving self-evolution episode',
+                purpose: 'Run one self-evolution episode (main ∥ baseline arms → reward → bounded policy edit).',
                 boundary: 'Maintainer/research surface, not the normal user workflow.',
             },
         ],
@@ -384,15 +271,14 @@ export async function readAgentInterfacePlan(root) {
     };
 }
 export async function readOverview(root) {
-    const [project, changes, runs, cli] = await Promise.all([
+    const [project, changes, se, cli] = await Promise.all([
         readProjectInfo(root),
         listChanges(root),
-        listEvolveRuns(root),
+        readSelfEvolution(root),
         readCliHistory(root, 500),
     ]);
     const completedChanges = changes.filter((c) => c.status === 'completed').length;
     const inProgressChanges = changes.filter((c) => c.status === 'in-progress').length;
-    const lastRun = runs[0];
     const recentFailures = cli.filter((e) => e.outcome === 'failure').length;
     return {
         project,
@@ -402,14 +288,10 @@ export async function readOverview(root) {
             inProgress: inProgressChanges,
         },
         evolve: {
-            runs: runs.length,
-            lastRunAt: lastRun?.startedAt ?? null,
-            lastVerdict: lastRun
-                ? Object.entries(lastRun.verdictCounts ?? {})
-                    .filter(([, n]) => n > 0)
-                    .map(([k]) => k)
-                    .join(', ') || null
-                : null,
+            episodes: se.episodes.length,
+            lastEpisodeAt: se.episodes[0]?.updatedAt ?? null,
+            lastStage: se.episodes[0]?.stage ?? null,
+            headVersion: se.policyLineages[0]?.headVersion ?? null,
         },
         cli: { totalEvents: cli.length, recentFailures },
     };
@@ -604,8 +486,8 @@ export async function readArchitecture(root) {
         const domain = [
             { id: 'change', label: 'Change', role: 'A unit of planned work with its artifacts' },
             { id: 'memory', label: 'Memory', role: 'Durable attributed lessons across runs' },
-            { id: 'evolveRun', label: 'Evolve run', role: 'A benchmark-backed self-evolution attempt' },
-            { id: 'archive', label: 'Archive', role: 'Finalized changes and evolution lineage' },
+            { id: 'episode', label: 'Episode', role: 'One two-arm forward self-evolution episode (main ∥ baseline arms -> graded advantage)' },
+            { id: 'archive', label: 'Archive', role: 'Finalized changes' },
         ];
         logical = { entities: [...artifacts, ...domain] };
     }
@@ -624,20 +506,16 @@ export async function readArchitecture(root) {
     };
     try {
         const plan = await readAgentInterfacePlan(root);
-        const runs = await listEvolveRuns(root);
+        const se = await readSelfEvolution(root);
         const cli = await readCliHistory(root, 500);
-        const lastRun = runs[0];
-        const lastVerdict = lastRun
-            ? Object.entries(lastRun.verdictCounts ?? {})
-                .filter(([, n]) => n > 0)
-                .map(([k]) => k)
-                .join(', ') || null
-            : null;
-        const passRates = runs
-            .map((r) => r.passRate)
+        const lastVerdict = se.episodes[0]?.stage ?? null;
+        // passRate = fraction of GRADED episodes (advantage measured) that were
+        // positive (advantage > 0), over all graded episodes; null when none graded.
+        const gradedAdvantages = se.episodes
+            .map((e) => e.advantage)
             .filter((v) => typeof v === 'number' && Number.isFinite(v));
-        const passRate = passRates.length > 0
-            ? passRates.reduce((sum, v) => sum + v, 0) / passRates.length
+        const passRate = gradedAdvantages.length > 0
+            ? gradedAdvantages.filter((v) => v > 0).length / gradedAdvantages.length
             : null;
         const toolCounts = new Map();
         for (const event of cli) {
@@ -653,7 +531,7 @@ export async function readArchitecture(root) {
             toolDistribution,
             traceEvents: plan.summary.traces,
             decisions: plan.summary.decisions,
-            runs: runs.length,
+            runs: se.episodes.length,
             lastVerdict,
             passRate,
         };
@@ -701,8 +579,18 @@ export async function readArchitecture(root) {
                 rel: '.synergyspec-selfevolving/history/events.ndjson',
                 detail: 'Append-only CLI history event log',
             },
-            { rel: 'evolve/runs', detail: 'Per-run self-evolution outputs' },
-            { rel: 'evolve/archive/archive.json', detail: 'Self-evolution lineage archive' },
+            {
+                rel: '.synergyspec-selfevolving/self-evolution/episodes',
+                detail: 'Per-episode two-arm forward records',
+            },
+            {
+                rel: '.synergyspec-selfevolving/self-evolution/policy/ledger.ndjson',
+                detail: 'Append-only policy version ledger',
+            },
+            {
+                rel: '.synergyspec-selfevolving/self-evolution/policy/reject-buffer.ndjson',
+                detail: 'Rolled-back episodes (reject-buffer)',
+            },
         ];
         const storeSurfaces = [];
         for (const store of storePaths) {