synergyspec-selfevolving 2.1.5 → 2.1.6

package/dist/core/change-readiness.js

@@ -4,6 +4,8 @@ import path from 'path';
 import { formatChangeStatus, loadChangeContext, } from './artifact-graph/index.js';
 import { listEpisodes } from './self-evolution/episode-store.js';
 import { listCandidates, resolveCandidateRepo, } from './self-evolution/candidates.js';
+import { parseTestCollection } from './fitness/test-metrics.js';
+import { extractExpectedTestPaths } from './trajectory/facts.js';
 const TASK_PATTERN = /^[-*]\s+\[([\sx])\]\s*(.*)$/i;
 const REQUIRED_EVIDENCE_FILES = [
     ['specTests', 'spec-tests.md'],
@@ -51,6 +53,7 @@ export async function getChangeReadiness(projectRoot, changeName, schemaName) {
     const evidence = await readEvidenceReadiness(context.changeDir);
     const evolution = await readEvolutionOutcome(projectRoot, context.changeDir, changeName);
     const observedVerification = deriveObservedVerificationReadiness(evolution);
+    const learnEvidence = await readLearnEvidenceReadiness(projectRoot, context.changeDir, evolution);
     const workspaceIdentity = await readWorkspaceIdentityReadiness(projectRoot, context.changeDir, changeName);
     const status = deriveChangeReadinessStatus(artifactStatus, taskReadiness.total, taskReadiness.completed);
     return {
@@ -66,10 +69,15 @@ export async function getChangeReadiness(projectRoot, changeName, schemaName) {
         evidence,
         evolution,
         observedVerification,
+        learnEvidence,
         workspaceIdentity,
         isArchiveReady: artifactStatus === 'complete' &&
             taskReadiness.status === 'complete' &&
             evidence.missing.length === 0 &&
+            observedVerification.ready &&
+            evolution.status !== 'error' &&
+            evolution.status !== 'busy' &&
+            learnEvidence.ready &&
             workspaceIdentity.ready,
         artifactGraph,
     };
@@ -86,6 +94,7 @@ export function toReadinessJson(readiness) {
         evidence: readiness.evidence,
         evolution: readiness.evolution,
         observedVerification: readiness.observedVerification,
+        learnEvidence: readiness.learnEvidence,
         workspaceIdentity: readiness.workspaceIdentity,
         isArchiveReady: readiness.isArchiveReady,
     };
@@ -163,11 +172,11 @@ async function readWorkspaceIdentityReadiness(projectRoot, changeDir, changeName
             current,
         };
     }
-    const exitJsonPath = extractRunnerExitJsonPath(report, projectRoot);
+    const exitJsonPath = await extractRunnerExitJsonPath(report, projectRoot, changeDir);
     if (!exitJsonPath) {
         return {
-            status: 'not-recorded',
-            ready: true,
+            status: 'invalid',
+            ready: false,
             reason: 'test-report.md has no runner-exit.json reference',
             current,
         };
@@ -201,13 +210,23 @@ async function readWorkspaceIdentityReadiness(projectRoot, changeDir, changeName
     const record = asRecord(parsed);
     if (!record || !Object.prototype.hasOwnProperty.call(record, 'workspaceIdentity')) {
         return {
-            status: 'not-recorded',
-            ready: true,
+            status: 'invalid',
+            ready: false,
             reason: 'runner-exit.json has no workspaceIdentity field',
             evidencePath: formatProjectPath(projectRoot, exitJsonPath),
             current,
         };
     }
+    const runnerRecordProblem = await validateRunnerExitRecord(projectRoot, changeDir, record, exitJsonPath);
+    if (runnerRecordProblem) {
+        return {
+            status: 'invalid',
+            ready: false,
+            reason: runnerRecordProblem,
+            evidencePath: formatProjectPath(projectRoot, exitJsonPath),
+            current,
+        };
+    }
     const workspaceIdentity = asRecord(record.workspaceIdentity);
     if (!workspaceIdentity) {
         return {
@@ -219,6 +238,17 @@ async function readWorkspaceIdentityReadiness(projectRoot, changeDir, changeName
         };
     }
     const recorded = workspaceIdentitySnapshotFromRecord(workspaceIdentity);
+    const completenessProblems = validateWorkspaceIdentityCompleteness(recorded, current);
+    if (completenessProblems.length > 0) {
+        return {
+            status: 'invalid',
+            ready: false,
+            reason: `runner-exit.json workspaceIdentity is incomplete: ${completenessProblems.join('; ')}`,
+            evidencePath: formatProjectPath(projectRoot, exitJsonPath),
+            recorded,
+            current,
+        };
+    }
     const mismatches = compareWorkspaceIdentities(projectRoot, changeName, recorded, current);
     if (mismatches.length > 0) {
         return {
@@ -239,18 +269,314 @@ async function readWorkspaceIdentityReadiness(projectRoot, changeDir, changeName
         current,
     };
 }
-function extractRunnerExitJsonPath(report, projectRoot) {
+async function readLearnEvidenceReadiness(projectRoot, changeDir, evolution) {
+    const reportPath = path.join(changeDir, 'learn-report.md');
+    let content;
+    try {
+        content = await fs.readFile(reportPath, 'utf-8');
+    }
+    catch {
+        return {
+            status: 'missing',
+            ready: false,
+            reason: evolution.status === 'not-run'
+                ? 'learn-report.md is required before archive'
+                : `learn/evolution outcome ${evolution.status} is recorded but learn-report.md is absent`,
+            path: formatProjectPath(projectRoot, reportPath),
+        };
+    }
+    const validationProblem = validateLearnReportContent(content);
+    if (validationProblem) {
+        return {
+            status: 'invalid',
+            ready: false,
+            reason: validationProblem,
+            path: formatProjectPath(projectRoot, reportPath),
+        };
+    }
+    const evolutionProblem = validateLearnReportAgainstEvolution(content, evolution);
+    if (evolutionProblem) {
+        return {
+            status: 'invalid',
+            ready: false,
+            reason: evolutionProblem,
+            path: formatProjectPath(projectRoot, reportPath),
+        };
+    }
+    if (content.trim().length > 0) {
+        return {
+            status: 'present',
+            ready: true,
+            reason: 'learn-report.md is present',
+            path: formatProjectPath(projectRoot, reportPath),
+        };
+    }
+    return {
+        status: 'invalid',
+        ready: false,
+        reason: 'learn-report.md is empty',
+        path: formatProjectPath(projectRoot, reportPath),
+    };
+}
+function validateLearnReportContent(content) {
+    const required = [
+        ['## Episode Verdict', /^## Episode Verdict:/m],
+        ['Outcome', /^-\s*Outcome:\s*\S/m],
+        ['Episode id', /^-\s*Episode id:\s*\S/m],
+        ['Decision', /^-\s*Decision:\s*\S/m],
+        ['Evolution', /^-\s*Evolution:\s*\S/m],
+        ['Advantage', /^-\s*Advantage:\s*\S/m],
+        ['Policy version', /^-\s*.*POLICY version:\s*\S/im],
+        ['Evolved target', /^-\s*Evolved target:\s*\S/m],
+        ['Canonical file(s) changed', /^-\s*Canonical file\(s\) changed:\s*\S/m],
+        ['Rollback', /^-\s*Rollback:\s*\S/m],
+        ['Defects to surface', /^-\s*Defects to surface:\s*\S/m],
+        ['Key lessons', /^-\s*Key lessons:\s*\S/m],
+        ['Isolation', /^-\s*Isolation:\s*\S/m],
+    ];
+    const missing = required
+        .filter(([, pattern]) => !pattern.test(content))
+        .map(([label]) => label);
+    if (missing.length === 0)
+        return null;
+    return `learn-report.md is missing required verdict field(s): ${missing.join(', ')}`;
+}
+function parseLearnReportVerdict(content) {
+    return {
+        outcome: lineField(content, 'Outcome'),
+        episodeId: lineField(content, 'Episode id'),
+        evolvedTarget: lineField(content, 'Evolved target'),
+    };
+}
+function lineField(content, label) {
+    const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const match = new RegExp(`^-\\s*${escaped}:\\s*(.+)$`, 'im').exec(content);
+    return match?.[1]?.trim();
+}
+function validateLearnReportAgainstEvolution(content, evolution) {
+    if (evolution.status === 'not-run') {
+        return 'learn-report.md is not bound to a recorded learn/evolution outcome';
+    }
+    const verdict = parseLearnReportVerdict(content);
+    const reportStatus = evolutionOutcomeStatus(verdict.outcome ?? '');
+    if (reportStatus !== evolution.status) {
+        return `learn-report.md outcome ${verdict.outcome ?? 'missing'} does not match latest evolution status ${evolution.status}`;
+    }
+    if (evolution.episodeId) {
+        if (!verdict.episodeId || verdict.episodeId === 'none') {
+            return `learn-report.md is missing the latest episode id ${evolution.episodeId}`;
+        }
+        if (verdict.episodeId !== evolution.episodeId) {
+            return `learn-report.md episode id ${verdict.episodeId} does not match latest episode ${evolution.episodeId}`;
+        }
+    }
+    if (evolution.targetId && verdict.evolvedTarget && verdict.evolvedTarget !== evolution.targetId) {
+        return `learn-report.md target ${verdict.evolvedTarget} does not match latest evolution target ${evolution.targetId}`;
+    }
+    return null;
+}
+async function validateRunnerExitRecord(projectRoot, changeDir, record, exitJsonPath) {
+    const command = stringValue(record.command);
+    if (!command)
+        return 'runner-exit.json command is missing or invalid';
+    const cwd = stringValue(record.cwd);
+    if (!cwd)
+        return 'runner-exit.json cwd is missing or invalid';
+    if (!sameResolvedPath(cwd, projectRoot)) {
+        return `runner cwd changed from ${cwd} to ${path.resolve(projectRoot)}`;
+    }
+    if (!stringValue(record.startedAt))
+        return 'runner-exit.json startedAt is missing or invalid';
+    if (!stringValue(record.finishedAt))
+        return 'runner-exit.json finishedAt is missing or invalid';
+    const exitCode = typeof record.exitCode === 'number' && Number.isInteger(record.exitCode)
+        ? record.exitCode
+        : null;
+    if (exitCode === null)
+        return 'runner-exit.json exitCode is missing or invalid';
+    if (exitCode !== 0)
+        return `runner-exit.json exitCode is ${exitCode}`;
+    const testMetricsProblem = validateStructuredTestMetrics(record.testMetrics);
+    if (testMetricsProblem)
+        return testMetricsProblem;
+    const stdoutLog = stringValue(record.stdoutLog);
+    const stderrLog = stringValue(record.stderrLog);
+    if (!stdoutLog)
+        return 'runner-exit.json stdoutLog is missing or invalid';
+    if (!stderrLog)
+        return 'runner-exit.json stderrLog is missing or invalid';
+    const requiredPathProblem = (await validateEvidencePath(projectRoot, changeDir, stdoutLog, 'stdoutLog')) ??
+        (await validateEvidencePath(projectRoot, changeDir, stderrLog, 'stderrLog')) ??
+        (await validateEvidenceHash(projectRoot, changeDir, stdoutLog, record.stdoutLogSha256, 'stdoutLogSha256')) ??
+        (await validateEvidenceHash(projectRoot, changeDir, stderrLog, record.stderrLogSha256, 'stderrLogSha256'));
+    if (requiredPathProblem)
+        return requiredPathProblem;
+    const scopeProblem = await validateRunnerScope(projectRoot, changeDir, record, stdoutLog, stderrLog);
+    if (scopeProblem)
+        return scopeProblem;
+    for (const field of ['junitXml', 'coverageSummary', 'coverageLcov', 'coverageHtml']) {
+        const value = record[field];
+        if (value === null || value === undefined)
+            continue;
+        const pathValue = stringValue(value);
+        if (!pathValue)
+            return `runner-exit.json ${field} must be a path string or null`;
+        const problem = await validateEvidencePath(projectRoot, changeDir, pathValue, field);
+        if (problem)
+            return problem;
+    }
+    if (!path.resolve(exitJsonPath).startsWith(path.resolve(projectRoot) + path.sep)) {
+        return `runner-exit.json is outside project root: ${exitJsonPath}`;
+    }
+    return null;
+}
+function validateStructuredTestMetrics(value) {
+    if (value === null || value === undefined)
+        return null;
+    const record = asRecord(value);
+    if (!record)
+        return 'runner-exit.json testMetrics must be an object';
+    const total = metricNumber(record.total);
+    const passed = metricNumber(record.passed);
+    const failed = metricNumber(record.failed);
+    if (total === null || passed === null || failed === null) {
+        return 'runner-exit.json testMetrics total, passed, and failed must be finite numbers';
+    }
+    if (total < 0 || passed < 0 || failed < 0) {
+        return 'runner-exit.json testMetrics counts must be non-negative';
+    }
+    if (passed + failed !== total) {
+        return 'runner-exit.json testMetrics total must equal passed + failed';
+    }
+    if (Object.prototype.hasOwnProperty.call(record, 'passRate')) {
+        const passRate = metricNumber(record.passRate);
+        if (passRate === null)
+            return 'runner-exit.json testMetrics passRate must be a finite number';
+        const expected = total > 0 ? passed / total : 0;
+        if (Math.abs(passRate - expected) > 1e-9) {
+            return 'runner-exit.json testMetrics passRate does not match passed / total';
+        }
+    }
+    return null;
+}
+async function validateRunnerScope(projectRoot, changeDir, record, stdoutLog, stderrLog) {
+    const specTests = await fs
+        .readFile(path.join(changeDir, 'spec-tests.md'), 'utf-8')
+        .catch(() => undefined);
+    const expected = extractExpectedTestPaths(specTests).map(normPath).filter(Boolean);
+    if (expected.length === 0)
+        return null;
+    const stdoutPath = await resolveEvidencePath(projectRoot, changeDir, stdoutLog);
+    const stderrPath = await resolveEvidencePath(projectRoot, changeDir, stderrLog);
+    const outputText = [
+        stdoutPath ? await fs.readFile(stdoutPath, 'utf-8').catch(() => '') : '',
+        stderrPath ? await fs.readFile(stderrPath, 'utf-8').catch(() => '') : '',
+    ]
+        .filter((text) => text.length > 0)
+        .join('\n');
+    const collection = parseTestCollection(outputText);
+    const observed = collection?.paths ?? [];
+    if (observed.length > 0) {
+        return pathsIntersect(observed, expected)
+            ? null
+            : 'runner-exit.json green run is out-of-scope for spec-tests.md';
+    }
+    const commandPaths = commandTestPaths(stringValue(record.command));
+    if (pathsIntersect(commandPaths, expected))
+        return null;
+    const knownScope = collection !== null && collection.collected !== null;
+    return knownScope ? 'runner-exit.json green run is out-of-scope for spec-tests.md' : null;
+}
+async function validateEvidencePath(projectRoot, changeDir, rawPath, field) {
+    const fullPath = await resolveEvidencePath(projectRoot, changeDir, rawPath);
+    if (!fullPath) {
+        return `runner-exit.json ${field} points outside project root`;
+    }
+    try {
+        await fs.access(fullPath);
+    }
+    catch {
+        return `runner-exit.json ${field} is missing: ${formatProjectPath(projectRoot, fullPath)}`;
+    }
+    return null;
+}
+async function validateEvidenceHash(projectRoot, changeDir, rawPath, rawExpected, field) {
+    const expected = stringValue(rawExpected);
+    if (!expected)
+        return `runner-exit.json ${field} is missing or invalid`;
+    const fullPath = await resolveEvidencePath(projectRoot, changeDir, rawPath);
+    if (!fullPath) {
+        return `runner-exit.json ${field} path points outside project root`;
+    }
+    let content;
+    try {
+        content = await fs.readFile(fullPath);
+    }
+    catch {
+        return `runner-exit.json ${field} cannot hash missing evidence: ${formatProjectPath(projectRoot, fullPath)}`;
+    }
+    const actual = createHash('sha256').update(content).digest('hex');
+    if (actual !== expected)
+        return `runner-exit.json ${field} does not match current log content`;
+    return null;
+}
+async function extractRunnerExitJsonPath(report, projectRoot, changeDir) {
     RUNNER_EXIT_JSON_PATTERN.lastIndex = 0;
+    let latest = null;
     for (const match of report.matchAll(RUNNER_EXIT_JSON_PATTERN)) {
         const value = (match[1] ?? match[2] ?? '').trim();
         if (!value)
             continue;
         const withoutMdLink = value.replace(/^\((.*)\)$/, '$1');
-        return path.isAbsolute(withoutMdLink)
-            ? path.normalize(withoutMdLink)
-            : path.resolve(projectRoot, withoutMdLink);
+        latest = {
+            direct: resolveProjectPath(projectRoot, withoutMdLink),
+            remapped: resolveChangeDirTestEvidencePath(projectRoot, changeDir, withoutMdLink),
+        };
     }
-    return null;
+    if (!latest)
+        return null;
+    if (latest.direct && (await fileExists(latest.direct)))
+        return latest.direct;
+    if (latest.remapped && (await fileExists(latest.remapped)))
+        return latest.remapped;
+    return latest.direct ?? latest.remapped;
+}
+function resolveProjectPath(projectRoot, rawPath) {
+    if (!rawPath)
+        return null;
+    const resolved = path.isAbsolute(rawPath)
+        ? path.normalize(rawPath)
+        : path.resolve(projectRoot, rawPath);
+    const root = path.resolve(projectRoot);
+    return resolved === root || resolved.startsWith(root + path.sep) ? resolved : null;
+}
+function resolveChangeDirTestEvidencePath(projectRoot, changeDir, rawPath) {
+    if (path.isAbsolute(rawPath))
+        return null;
+    const normalized = rawPath.replace(/\\/g, '/');
+    const marker = '/test-evidence/';
+    const markerIndex = normalized.indexOf(marker);
+    const bareMarkerIndex = normalized.startsWith('test-evidence/') ? 0 : -1;
+    const suffix = markerIndex >= 0
+        ? normalized.slice(markerIndex + marker.length)
+        : bareMarkerIndex === 0
+            ? normalized.slice('test-evidence/'.length)
+            : null;
+    if (!suffix)
+        return null;
+    const resolved = path.resolve(changeDir, 'test-evidence', ...suffix.split('/'));
+    return isInside(projectRoot, resolved) && isInside(changeDir, resolved) ? resolved : null;
+}
+async function resolveEvidencePath(projectRoot, changeDir, rawPath) {
+    if (!rawPath)
+        return null;
+    const direct = resolveProjectPath(projectRoot, rawPath);
+    if (direct && (await fileExists(direct)))
+        return direct;
+    const remapped = resolveChangeDirTestEvidencePath(projectRoot, changeDir, rawPath);
+    if (remapped && (await fileExists(remapped)))
+        return remapped;
+    return direct ?? remapped;
 }
 async function readCurrentWorkspaceIdentity(projectRoot, changeName) {
     return {
@@ -347,7 +673,7 @@ function fileSnapshotFromUnknown(value) {
 }
 function compareWorkspaceIdentities(projectRoot, changeName, recorded, current) {
     const mismatches = [];
-    if (recorded.changeName && recorded.changeName !== changeName) {
+    if (recorded.changeName && !changeNamesEquivalent(recorded.changeName, changeName)) {
         mismatches.push(`change name changed from ${recorded.changeName} to ${changeName}`);
     }
     if (recorded.cwd && !sameResolvedPath(recorded.cwd, projectRoot)) {
@@ -374,6 +700,39 @@ function compareIdentityFile(label, recorded, current, mismatches) {
         mismatches.push(`${label} content changed since runner evidence was captured`);
     }
 }
+function validateWorkspaceIdentityCompleteness(recorded, current) {
+    const problems = [];
+    if (!recorded.cwd)
+        problems.push('cwd is missing');
+    if (!recorded.changeName)
+        problems.push('changeName is missing');
+    const currentFiles = [
+        ['pyproject', 'pyproject.toml', current.pyproject],
+        ['packageJson', 'package.json', current.packageJson],
+    ];
+    for (const [key, label, currentFile] of currentFiles) {
+        if (!currentFile)
+            continue;
+        const recordedFile = recorded[key];
+        if (!recordedFile) {
+            problems.push(`${label} identity is missing`);
+            continue;
+        }
+        if (!recordedFile.path)
+            problems.push(`${label} path is missing`);
+        if (currentFile.name && !recordedFile.name)
+            problems.push(`${label} name is missing`);
+        if (!recordedFile.sha256)
+            problems.push(`${label} sha256 is missing`);
+    }
+    return problems;
+}
+function changeNamesEquivalent(recorded, current) {
+    if (recorded === current)
+        return true;
+    const archived = current.match(/^\d{4}-\d{2}-\d{2}-(.+)$/);
+    return archived?.[1] === recorded;
+}
 function sameResolvedPath(left, right) {
     const normalizedLeft = path.resolve(left);
     const normalizedRight = path.resolve(right);
@@ -385,11 +744,51 @@ function sameResolvedPath(left, right) {
 function stringValue(value) {
     return typeof value === 'string' && value.length > 0 ? value : undefined;
 }
+function metricNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
 function asRecord(value) {
     return value && typeof value === 'object' && !Array.isArray(value)
         ? value
         : null;
 }
+function pathsIntersect(observed, expected) {
+    if (observed.length === 0 || expected.length === 0)
+        return false;
+    for (const o of observed.map(normPath)) {
+        for (const e of expected) {
+            if (o === e || o.endsWith('/' + e) || e.endsWith('/' + o)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function commandTestPaths(command) {
+    if (!command)
+        return [];
+    const paths = new Set();
+    const afterRunner = command.replace(/\b(?:pytest|py\.test|python\s+-m\s+pytest|vitest|npm\s+test|pnpm\s+test|yarn\s+test|go\s+test)\b/i, ' ');
+    for (const raw of afterRunner.split(/\s+/)) {
+        const tok = raw.trim().replace(/^['"]|['"]$/g, '');
+        if (!tok || tok.startsWith('-'))
+            continue;
+        const looksLikePath = /[\\/]/.test(tok) || /\b(?:tests?|spec|specs|benchmark_tests)\b/i.test(tok);
+        if (!looksLikePath)
+            continue;
+        if (/\.[a-z]+$/i.test(tok) && !/\.(?:py|[tj]sx?)$/i.test(tok))
+            continue;
+        paths.add(normPath(tok));
+    }
+    return [...paths];
+}
+function normPath(p) {
+    return p.replace(/\\/g, '/').toLowerCase().replace(/^\.\//, '').replace(/::.*/, '');
+}
+function isInside(root, candidate) {
+    const relative = path.relative(path.resolve(root), path.resolve(candidate));
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
 function formatProjectPath(projectRoot, filePath) {
     const relative = path.relative(projectRoot, filePath);
     if (relative && !relative.startsWith('..') && !path.isAbsolute(relative)) {
@@ -410,7 +809,14 @@ function deriveObservedVerificationReadiness(evolution) {
     if (evolution.status === 'promoted' && evolution.promoted) {
         return { status: 'verified', ready: true };
     }
-    return { status: 'not-assessed', ready: true };
+    if (isObservedVerifiedOutcome(evolution)) {
+        return { status: 'verified', ready: true, reason: evolution.reason ?? evolution.outcome };
+    }
+    return {
+        status: 'not-assessed',
+        ready: false,
+        reason: 'learn/evolution has not recorded observed-verified evidence',
+    };
 }
 function isObservedVerificationBlocker(evolution) {
     const raw = `${evolution.outcome ?? ''} ${evolution.reason ?? ''}`.toLowerCase();
@@ -418,9 +824,8 @@ function isObservedVerificationBlocker(evolution) {
         return false;
     const mentionsUnverified = raw.includes('refused-unverified-evidence') ||
         raw.includes('not observed-verified') ||
-        raw.includes('observed-verified') ||
         raw.includes('observed-green gate failed') ||
-        raw.includes('observed-green') ||
+        raw.includes('observed-green failed') ||
         raw.includes('trajectory not verified') ||
         raw.includes('not verified') ||
         raw.includes('unverified') ||
@@ -432,6 +837,20 @@ function isObservedVerificationBlocker(evolution) {
         evolution.status === 'rolled-back' ||
         evolution.status === 'error');
 }
+function isObservedVerifiedOutcome(evolution) {
+    const raw = `${evolution.outcome ?? ''} ${evolution.reason ?? ''}`.toLowerCase();
+    if (!raw)
+        return false;
+    const mentionsVerified = raw.includes('observed-verified') ||
+        raw.includes('observed verified') ||
+        raw.includes('verified-green') ||
+        raw.includes('verified green');
+    const mentionsUnverified = raw.includes('unverified') ||
+        raw.includes('not observed-verified') ||
+        raw.includes('observed-green gate failed') ||
+        raw.includes('not verified');
+    return mentionsVerified && !mentionsUnverified;
+}
 /**
  * Read the CLI-written evolution outcome for the change, if any. When the manual
  * evolution-result file is absent, fall back to the durable loop-v2 episode store
@@ -484,7 +903,7 @@ async function readEvolutionOutcome(projectRoot, changeDir, changeName) {
     }
 }
 function evolutionOutcomeStatus(outcome) {
-    if (outcome === 'promoted')
+    if (outcome === 'promoted' || outcome === 'evolved')
         return 'promoted';
     if (outcome === 'rolled-back')
         return 'rolled-back';
@@ -599,6 +1018,7 @@ async function readLatestEpisodeOutcome(projectRoot, changeDir, changeName) {
             outcome: 'episode-error',
             reason: episode.terminalError,
             targetId: episode.targetId,
+            episodeId: episode.episodeId,
             promoted: false,
             promotedFiles: [],
             timestamp: episode.updatedAt,
@@ -610,6 +1030,7 @@ async function readLatestEpisodeOutcome(projectRoot, changeDir, changeName) {
             outcome: 'episode-evolution-refused',
             reason: episode.evolutionOutcomeReason ?? 'evolution refused',
             targetId: episode.targetId,
+            episodeId: episode.episodeId,
             promoted: false,
             promotedFiles: [],
             timestamp: episode.updatedAt,
@@ -620,6 +1041,7 @@ async function readLatestEpisodeOutcome(projectRoot, changeDir, changeName) {
             status: 'promoted',
             outcome: 'episode-evolved',
             targetId: episode.targetId,
+            episodeId: episode.episodeId,
             promoted: true,
             promotedFiles: [],
             timestamp: episode.updatedAt,
@@ -631,6 +1053,7 @@ async function readLatestEpisodeOutcome(projectRoot, changeDir, changeName) {
             outcome: 'episode-abstained',
             reason: episode.evolutionOutcomeReason ?? 'reward agent abstained; no policy promotion',
             targetId: episode.targetId,
+            episodeId: episode.episodeId,
             promoted: false,
             promotedFiles: [],
             timestamp: episode.updatedAt,
@@ -642,6 +1065,7 @@ async function readLatestEpisodeOutcome(projectRoot, changeDir, changeName) {
             outcome: 'episode-not-spawned',
             reason: episode.evolutionOutcomeReason ?? 'episode rolled back before policy evolution',
             targetId: episode.targetId,
+            episodeId: episode.episodeId,
             promoted: false,
             promotedFiles: [],
             timestamp: episode.updatedAt,
@@ -653,6 +1077,7 @@ async function readLatestEpisodeOutcome(projectRoot, changeDir, changeName) {
             outcome: 'episode-not-spawned',
             reason: episode.evolutionOutcomeReason ?? 'episode closed without policy promotion',
             targetId: episode.targetId,
+            episodeId: episode.episodeId,
             promoted: false,
             promotedFiles: [],
             timestamp: episode.updatedAt,
@@ -664,6 +1089,7 @@ async function readLatestEpisodeOutcome(projectRoot, changeDir, changeName) {
             outcome: 'episode-in-progress',
             reason: `episode currently at stage ${stage}`,
             targetId: episode.targetId,
+            episodeId: episode.episodeId,
             promoted: false,
             promotedFiles: [],
             timestamp: episode.updatedAt,

package/dist/core/fitness/loss.d.ts

@@ -47,11 +47,9 @@ export interface ComputeLossInput {
      */
     verified?: boolean;
     /**
-     * Weight on the unverified soft-penalty term; default 0 (OBSERVE-ONLY). At 0
-     * the loss is byte-identical to the functional⊕health baseline regardless of
-     * `verified` — the trajectory signal is recorded on the FitnessSample for
-     * auditing without yet moving selection. Raise it to let unverified
-     * candidates be down-weighted (never hard-disqualified) when comparing them.
+     * Weight on the unverified soft-penalty term; defaults to a small nonzero
+     * penalty so authored green reports are visibly non-green unless corroborated
+     * by runner evidence. Set it to 0 explicitly to make the signal observe-only.
      */
     unverifiedWeight?: number;
 }

package/dist/core/fitness/loss.js

@@ -20,8 +20,8 @@ function clamp01(v) {
 export function computePerChangeLoss(input) {
     const wf = input.functionalWeight ?? 0.7;
     const wh = input.healthWeight ?? 0.3;
-    // Default 0 ⇒ observe-only: the unverified term vanishes and the returned
-    // loss/shape stay identical to the functional⊕health baseline.
+    // Default-on soft penalty: authored green reports are not treated as fully
+    // measured green unless runner evidence corroborates them.
     const wu = input.unverifiedWeight ?? DEFAULT_UNVERIFIED_WEIGHT;
     const functionalLoss = clamp01(1 - clamp01(input.passRate));
     const healthPenalty = clamp01(input.healthPenalty ?? 0);

package/dist/core/fitness/test-metrics.d.ts

@@ -28,6 +28,7 @@ export interface TestMetrics {
  *              "1 failed, 9 passed in 0.4s"         (order-independent)
  *   - SynergySpec reports: table/status prose like
  *              "Passed; 85 tests collected and passed"
+ *              "Summary: 29 collected, 29 passed, 0 failed, 0 skipped, 0 collection errors."
  * A bare "N passed" line that is not a recognized summary (e.g. prose or a
  * per-suite tally) is ignored. Pytest "errors" count toward `failed`.
  * Returns null when no recognized summary is found.