synergyspec-selfevolving 1.1.10 → 1.1.12

package/dist/core/change-readiness.js

@@ -45,6 +45,7 @@ export async function getChangeReadiness(projectRoot, changeName, schemaName) {
     const artifactStatus = deriveArtifactWorkflowStatus(artifactGraph);
     const taskReadiness = await readTaskReadiness(context.changeDir);
     const evidence = await readEvidenceReadiness(context.changeDir);
+    const evolution = await readEvolutionOutcome(context.changeDir);
     const status = deriveChangeReadinessStatus(artifactStatus, taskReadiness.total, taskReadiness.completed);
     return {
         changeName,
@@ -57,6 +58,10 @@ export async function getChangeReadiness(projectRoot, changeName, schemaName) {
         totalTasks: taskReadiness.total,
         incompleteTasks: taskReadiness.incomplete,
         evidence,
+        evolution,
+        // ANNOTATE, do not GATE: a refused/failed self-evolution is surfaced via
+        // `evolution` but never blocks archiving a finished change (change completion
+        // and tool self-evolution are orthogonal).
         isArchiveReady: artifactStatus === 'complete' &&
             taskReadiness.status === 'complete' &&
             evidence.missing.length === 0,
@@ -73,6 +78,7 @@ export function toReadinessJson(readiness) {
         totalTasks: readiness.totalTasks,
         incompleteTasks: readiness.incompleteTasks,
         evidence: readiness.evidence,
+        evolution: readiness.evolution,
         isArchiveReady: readiness.isArchiveReady,
     };
 }
@@ -134,6 +140,47 @@ async function readEvidenceReadiness(changeDir) {
         missing,
     };
 }
+/**
+ * Read the CLI-written evolution outcome for the change, if any. Defensive: any
+ * missing file / parse error / unknown outcome degrades to `'not-run'` (forward
+ * compatible and never throws), so `status` can always render an Evolution line.
+ */
+async function readEvolutionOutcome(changeDir) {
+    const notRun = { status: 'not-run', promoted: false, promotedFiles: [] };
+    let raw;
+    try {
+        raw = await fs.readFile(path.join(changeDir, 'evolution-result.json'), 'utf-8');
+    }
+    catch {
+        return notRun;
+    }
+    try {
+        const record = JSON.parse(raw);
+        const outcome = typeof record.outcome === 'string' ? record.outcome : '';
+        const status = outcome === 'promoted'
+            ? 'promoted'
+            : outcome.startsWith('refused-')
+                ? 'refused'
+                : outcome.startsWith('error-')
+                    ? 'error'
+                    : 'not-run';
+        if (status === 'not-run')
+            return notRun;
+        return {
+            status,
+            reason: typeof record.reason === 'string' ? record.reason : undefined,
+            targetId: typeof record.targetId === 'string' ? record.targetId : undefined,
+            promoted: record.promoted === true,
+            promotedFiles: Array.isArray(record.promotedFiles)
+                ? record.promotedFiles.filter((file) => typeof file === 'string')
+                : [],
+            timestamp: typeof record.timestamp === 'string' ? record.timestamp : undefined,
+        };
+    }
+    catch {
+        return notRun;
+    }
+}
 async function testReportRequiresPlan(testReportPath) {
     try {
         const content = await fs.readFile(testReportPath, 'utf-8');

package/dist/core/config-prompts.js

@@ -29,6 +29,16 @@ export function serializeConfig(config) {
     lines.push('#       - Always include a "Non-goals" section');
     lines.push('#     tasks:');
     lines.push('#       - Break tasks into chunks of max 2 hours');
+    lines.push('');
+    // Code-health scoring for self-evolution (default-on). Feeds the 0.3·health
+    // half of the per-change fitness loss and gates auto-promotion on a measured
+    // health regression. `local` is a dependency-free, multi-language analyzer
+    // (Python, Rust, C, C++) bundled with the tool — it needs Python 3 to run, but
+    // no server and no network. Set `source: stub` to turn health scoring off.
+    lines.push('# Code-health scoring for self-evolution (Python, Rust, C, C++).');
+    lines.push('# Set source: stub to disable. local-python is an alias for local.');
+    lines.push('health:');
+    lines.push('  source: local');
     return lines.join('\n') + '\n';
 }
 //# sourceMappingURL=config-prompts.js.map

package/dist/core/fitness/health/local-source.d.ts

@@ -1,10 +1,13 @@
 /**
- * Self-contained local Python code-health metric source.
+ * Self-contained local code-health metric source (config token `local`, with
+ * `local-python` accepted as a back-compat alias).
  *
- * This is the *fallback* {@link MetricSource} for the self-evolution fitness
- * loop: it shells out to the dependency-free `scripts/code-health.py` analyzer
- * (Python 3 stdlib only) so health metrics can be computed with no SonarQube
- * server, no network, and no third-party packages.
+ * This is the default {@link MetricSource} for the self-evolution fitness loop:
+ * it shells out to the dependency-free, multi-language `scripts/code-health.py`
+ * analyzer (Python 3 stdlib only; reads Python, Rust, C, and C++ source) so
+ * health metrics can be computed with no SonarQube server, no network, and no
+ * third-party packages. Python 3 must be installed to RUN the analyzer, but the
+ * code it measures can be any of the supported languages.
  *
  * Degrades gracefully: if Python is not installed, the spawn errors, or the
  * analyzer emits something that is not the expected JSON, `measure()` resolves
@@ -28,7 +31,7 @@ export interface LocalPythonMetricSourceOptions {
     scriptPath?: string;
 }
 export declare class LocalPythonMetricSource implements MetricSource {
-    readonly name = "local-python";
+    readonly name = "local";
     private readonly pythonBin;
     private readonly spawnImpl;
     private readonly scriptPath;

package/dist/core/fitness/health/local-source.js

@@ -1,10 +1,13 @@
 /**
- * Self-contained local Python code-health metric source.
+ * Self-contained local code-health metric source (config token `local`, with
+ * `local-python` accepted as a back-compat alias).
  *
- * This is the *fallback* {@link MetricSource} for the self-evolution fitness
- * loop: it shells out to the dependency-free `scripts/code-health.py` analyzer
- * (Python 3 stdlib only) so health metrics can be computed with no SonarQube
- * server, no network, and no third-party packages.
+ * This is the default {@link MetricSource} for the self-evolution fitness loop:
+ * it shells out to the dependency-free, multi-language `scripts/code-health.py`
+ * analyzer (Python 3 stdlib only; reads Python, Rust, C, and C++ source) so
+ * health metrics can be computed with no SonarQube server, no network, and no
+ * third-party packages. Python 3 must be installed to RUN the analyzer, but the
+ * code it measures can be any of the supported languages.
  *
  * Degrades gracefully: if Python is not installed, the spawn errors, or the
  * analyzer emits something that is not the expected JSON, `measure()` resolves
@@ -85,7 +88,7 @@ function toRawHealthMetrics(parsed) {
     };
 }
 export class LocalPythonMetricSource {
-    name = 'local-python';
+    name = 'local';
     pythonBin;
     spawnImpl;
     scriptPath;

package/dist/core/fitness/health/resolve-source.d.ts

@@ -20,9 +20,10 @@ import type { MetricSource } from './metric-source.js';
 /**
  * Build the {@link MetricSource} selected by `config.health.source`.
  *
- * - absent / `stub`  → {@link StubMetricSource} (no signal; default).
- * - `local-python`   → {@link LocalPythonMetricSource} (shells out to
- *   `scripts/code-health.py`; needs Python 3 but no network/server).
+ * - absent / `stub`        → {@link StubMetricSource} (no signal).
+ * - `local` / `local-python` → {@link LocalPythonMetricSource} (shells out to
+ *   the bundled multi-language `scripts/code-health.py`; needs Python 3 but no
+ *   network/server). `local-python` is a back-compat alias for `local`.
  * - `sonarqube`      → {@link SonarQubeMetricSource} when `sonarUrl`,
  *   `sonarToken`, and `sonarProjectKey` are all present; otherwise falls back
  *   to the stub (a misconfigured Sonar block must not silently fabricate a

package/dist/core/fitness/health/resolve-source.js

@@ -3,9 +3,10 @@ import { LocalPythonMetricSource } from './local-source.js';
 /**
  * Build the {@link MetricSource} selected by `config.health.source`.
  *
- * - absent / `stub`  → {@link StubMetricSource} (no signal; default).
- * - `local-python`   → {@link LocalPythonMetricSource} (shells out to
- *   `scripts/code-health.py`; needs Python 3 but no network/server).
+ * - absent / `stub`        → {@link StubMetricSource} (no signal).
+ * - `local` / `local-python` → {@link LocalPythonMetricSource} (shells out to
+ *   the bundled multi-language `scripts/code-health.py`; needs Python 3 but no
+ *   network/server). `local-python` is a back-compat alias for `local`.
  * - `sonarqube`      → {@link SonarQubeMetricSource} when `sonarUrl`,
  *   `sonarToken`, and `sonarProjectKey` are all present; otherwise falls back
  *   to the stub (a misconfigured Sonar block must not silently fabricate a
@@ -18,7 +19,7 @@ export function resolveMetricSource(config) {
     if (!health || health.source === 'stub') {
         return new StubMetricSource();
     }
-    if (health.source === 'local-python') {
+    if (health.source === 'local' || health.source === 'local-python') {
         return new LocalPythonMetricSource({ pythonBin: health.pythonBin });
     }
     if (health.source === 'sonarqube') {

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

@@ -19,6 +19,23 @@ export interface FitnessSample {
      * same as all-tests-failing, so we record "no signal" rather than loss = 1.
      */
     loss: PerChangeLoss | null;
+    /**
+     * The RAW code-health penalty in [0,1] from the active {@link MetricSource},
+     * or `null` when there was NO health signal (stub source, analyzer missing/
+     * failed, or no measurable source files). This is deliberately distinct from
+     * `loss.healthPenalty`, which is the `?? 0`-defaulted value folded into the
+     * loss and therefore cannot distinguish "measured a healthy 0" from "no
+     * signal". The default-path health gate keys off THIS field: `null` ⇒ no gate.
+     * Omitted entirely when no metric source was consulted (no test-report), so
+     * the authored-artifact-only path stays byte-identical.
+     */
+    healthSignal?: number | null;
+    /**
+     * Name of the active metric source ('stub' | 'local' | 'sonarqube'); used for
+     * logs and the "configured but no signal" observation. Omitted when no source
+     * was consulted.
+     */
+    healthSource?: string;
     /**
      * Ground-truth facts distilled from the agent's ACTUAL trajectory (which
      * harness, whether a test runner was really observed running, the observed

package/dist/core/learn.d.ts

@@ -86,6 +86,13 @@ export interface LearnObservation {
     }>;
     /** Raw tags forwarded from the source signal; the adapter may interpret them. */
     tags: string[];
+    /**
+     * Optional triage axis. Omitted (the default) for the neutral reflection signals
+     * — keeps their JSON byte-identical. `'defect'` marks an actionable tool defect
+     * the agent must SURFACE (e.g. an unresolved evolution target), distinct from a
+     * safe gate refusal.
+     */
+    severity?: 'info' | 'action' | 'defect';
 }
 export interface LearnReport {
     changeName: string;

package/dist/core/learn.js

@@ -50,8 +50,10 @@ export async function generateLearnReport(args = {}) {
     const testReport = artifacts.evidence.find((f) => /(?:^|[\\/])(?:test-report|run-tests?-report|ci-report)\.md$/i.test(f.relativePath));
     const testMetrics = testReport ? parseTestMetrics(testReport.content) : null;
     let healthPenalty;
+    let healthSourceName;
     if (testMetrics) {
         const metricSource = resolveMetricSource(readProjectConfig(projectRoot));
+        healthSourceName = metricSource.name;
         healthPenalty = (await measureHealthPenalty(metricSource, projectRoot)) ?? undefined;
     }
     // Ground truth: distil the agent's ACTUAL trajectory — main thread AND the
@@ -83,6 +85,15 @@ export async function generateLearnReport(args = {}) {
                 verified: passRateVerified,
             })
             : null,
+        // Record the raw health signal + source ONLY when a NON-STUB source was
+        // consulted (i.e. health is actually configured). `healthSignal` is the
+        // measured penalty or null ("no signal"); the default-path health gate reads
+        // it to tell apart a healthy 0 from an absent measurement. Omitted for the
+        // stub source and the artifact-only path so both stay byte-identical to the
+        // functional-only baseline.
+        ...(healthSourceName && healthSourceName !== 'stub'
+            ? { healthSignal: healthPenalty ?? null, healthSource: healthSourceName }
+            : {}),
         ...(trajectoryFacts ? { trajectoryFacts } : {}),
     };
     const reuse = inferReuseConclusions(summary, artifacts);
@@ -145,6 +156,27 @@ export async function generateLearnReport(args = {}) {
             });
         }
     }
+    // Health head is CONFIGURED (a non-stub source was selected) but produced NO
+    // signal: surface it loudly rather than letting the health half of the loss
+    // silently default to 0. Default-on health must never fail invisibly — this
+    // is the same anti-opacity principle as the trajectory observations above.
+    // Operator-actionable (annotate, not gate): NOT a disqualifying code.
+    if (healthSourceName && healthSourceName !== 'stub' && healthPenalty === undefined) {
+        observations.push({
+            code: 'health-signal-unavailable',
+            summary: `code-health source '${healthSourceName}' is configured but produced no signal ` +
+                `(Python 3 missing, the analyzer failed, or there were no measurable source files); ` +
+                `the health half of the per-change loss defaulted to 0.`,
+            evidence: [
+                {
+                    file: 'synergyspec-selfevolving/config.yaml',
+                    detail: `health.source: ${healthSourceName}`,
+                },
+            ],
+            tags: ['health', 'no-signal', 'action-required'],
+            severity: 'action',
+        });
+    }
     return {
         ...reportSoFar,
         observations,
@@ -361,7 +393,12 @@ export function renderLearnReport(report, applied) {
     }
     else {
         for (const observation of report.observations) {
-            lines.push(`- [${observation.code}] ${observation.summary}`);
+            const marker = observation.severity === 'defect'
+                ? 'DEFECT: '
+                : observation.severity === 'action'
+                    ? 'ACTION: '
+                    : '';
+            lines.push(`- ${marker}[${observation.code}] ${observation.summary}`);
             const firstEvidence = observation.evidence[0];
             if (firstEvidence) {
                 lines.push(`  evidence: ${firstEvidence.file}`);
@@ -1396,7 +1433,9 @@ function splitTableCells(line) {
         .map((c) => c.trim().replace(/\*\*/g, '').replace(/`/g, ''));
 }
 /** A single cell whose whole value is a passing/neutral verdict. */
-const PASS_CELL_RE = /^(?:pass(?:ed|es)?|covered|ok|✓|✔|n\/?a|none|-|—)$/i;
+const PASS_CELL_RE = /^(?:pass(?:ed|es)?|covered|ok|✓|✔|✅|n\/?a|none|-|—)$/i;
+/** A single cell whose whole value is an explicit failure/error verdict. */
+const FAIL_CELL_RE = /^(?:fail(?:ed|s|ing|ure)?|error(?:ed|s)?|blocked|incomplete|✗|✘|❌|❎)$/i;
 /**
  * Find lines in a verification artifact that look like UNRESOLVED failure
  * evidence. The hazard (the same prose-keyword trap as the trajectory runner
@@ -1431,13 +1470,26 @@ export function extractFailureEvidence(file) {
             const successor = nextNonEmpty(i);
             if (successor !== null && isTableSeparator(successor))
                 continue;
-            // A data row whose outcome/status cell reads PASS/✓/covered is a PASSING
+            // A data row whose outcome/status cell reads PASS/✓/✅/covered is a PASSING
             // result, even when another cell names the failure scenario it exercises.
             if (cells.some((c) => PASS_CELL_RE.test(c)))
                 continue;
+            // A table row is failure evidence ONLY when some cell is an explicit
+            // FAIL/ERROR verdict. Prose in a scenario/description cell ("Open fails
+            // because the path is invalid") does NOT count — that is how use-case →
+            // test MAPPING tables (e.g. spec-tests.md: ID | Scenario | Layer | Type |
+            // Test) legitimately describe negative-path scenarios with no outcome
+            // column. Deciding structurally here avoids flagging those passing rows.
+            if (cells.some((c) => FAIL_CELL_RE.test(c))) {
+                matches.push({ file: file.relativePath, line: limitText(trimmed, 180) });
+                if (matches.length >= 6)
+                    break;
+            }
+            continue;
         }
-        else if (/^[-*\s]*(?:\*\*)?\s*pass(?:ed|es)?\b/i.test(trimmed)) {
-            // A list item explicitly marked PASS (a passed negative-path scenario).
+        if (/^[-*\s]*(?:✅|✓|✔)/.test(trimmed) || /^[-*\s]*(?:\*\*)?\s*pass(?:ed|es)?\b/i.test(trimmed)) {
+            // A list item explicitly marked PASS (✅/✓/✔ or the word "pass") — a
+            // passed negative-path scenario, even when its prose says "fails".
             continue;
         }
         if (/\b(no|none|zero|0)\s+(failures?|failed|errors?|critical issues)\b/i.test(trimmed)) {

package/dist/core/project-config.d.ts

@@ -28,6 +28,7 @@ export declare const ProjectConfigSchema: z.ZodObject<{
     health: z.ZodOptional<z.ZodObject<{
         source: z.ZodDefault<z.ZodEnum<{
             stub: "stub";
+            local: "local";
             "local-python": "local-python";
             sonarqube: "sonarqube";
         }>>;

package/dist/core/project-config.js

@@ -48,14 +48,17 @@ export const ProjectConfigSchema = z.object({
         .describe('Per-canonical-target self-evolution toggles'),
     // Optional: code-health metric source for the self-evolution fitness loss.
     // `source` selects which MetricSource feeds the 0.3·health term of the
-    // per-change loss. Absent ⇒ `stub` ⇒ no health signal ⇒ loss is
-    // byte-identical to the functional-only baseline (back-compat). See
-    // src/core/fitness/health/resolve-source.ts and
-    // todo/wire-mock-self-evolution-features-plan.md (Fix 1).
+    // per-change loss. New projects scaffold `source: local` (default-on);
+    // set `source: stub` to make the loss byte-identical to the functional-only
+    // baseline (the pre-1.1.12 default). `local-python` is a back-compat alias
+    // for `local`. See src/core/fitness/health/resolve-source.ts.
     health: z
         .object({
-        source: z.enum(['stub', 'local-python', 'sonarqube']).default('stub'),
-        // local-python: interpreter override (else env / 'python').
+        // local: dependency-free multi-language analyzer (Python, Rust, C, C++)
+        //   via the bundled scripts/code-health.py (needs Python 3 to run, but no
+        //   network/server). `local-python` is an accepted alias for `local`.
+        source: z.enum(['stub', 'local', 'local-python', 'sonarqube']).default('stub'),
+        // local: interpreter override for the bundled analyzer (else env / 'python').
         pythonBin: z.string().optional(),
         // sonarqube: server connection + project key.
         sonarUrl: z.string().optional(),
@@ -213,13 +216,13 @@ export function readProjectConfig(projectRoot) {
                 const rawHealth = raw.health;
                 const health = { source: 'stub' };
                 const sourceResult = z
-                    .enum(['stub', 'local-python', 'sonarqube'])
+                    .enum(['stub', 'local', 'local-python', 'sonarqube'])
                     .safeParse(rawHealth.source);
                 if (sourceResult.success) {
                     health.source = sourceResult.data;
                 }
                 else if (rawHealth.source !== undefined) {
-                    console.warn(`Invalid 'health.source' in config (must be 'stub', 'local-python', or 'sonarqube'); using 'stub'`);
+                    console.warn(`Invalid 'health.source' in config (must be 'stub', 'local', 'local-python', or 'sonarqube'); using 'stub'`);
                 }
                 for (const key of ['pythonBin', 'sonarUrl', 'sonarToken', 'sonarProjectKey']) {
                     const strResult = z.string().min(1).safeParse(rawHealth[key]);

package/dist/core/self-evolution/health-baseline.d.ts

@@ -0,0 +1,24 @@
+export declare const HEALTH_BASELINE_FILE = "health-baseline.json";
+export interface HealthBaseline {
+    /** Recorded code-health penalty in [0,1] (lower is better) to compare against. */
+    healthPenalty: number;
+    /** ISO-8601 UTC timestamp the baseline was last updated. */
+    updatedAt: string;
+    /** The change whose measurement set this baseline (provenance; optional). */
+    sourceChange?: string;
+    /** The candidate promoted when this baseline was set (provenance; optional). */
+    candidateId?: string;
+}
+/**
+ * Read the recorded baseline. Returns `null` when the file is absent, unreadable,
+ * unparseable, or carries a non-finite `healthPenalty` (treated as "no baseline
+ * yet" ⇒ the gate does not fire and the first measured run records it).
+ */
+export declare function readHealthBaseline(repoRoot: string): Promise<HealthBaseline | null>;
+/**
+ * Write/overwrite the recorded baseline. Best-effort: creates the parent dir if
+ * needed and swallows any error (a failed baseline write must not fail a promote
+ * that already succeeded). Returns `true` on a successful write, `false` otherwise.
+ */
+export declare function writeHealthBaseline(repoRoot: string, baseline: HealthBaseline): Promise<boolean>;
+//# sourceMappingURL=health-baseline.d.ts.map

package/dist/core/self-evolution/health-baseline.js

@@ -0,0 +1,78 @@
+/**
+ * Per-repo code-health BASELINE for the default-path health gate.
+ *
+ * The self-evolution health gate (see {@link import('./promote.js').shouldAutoPromote})
+ * blocks auto-promotion when a change's measured code-health is WORSE than the
+ * last accepted state. On the everyday (no-replay) path there is no candidate
+ * post-health to measure — a candidate is a template/prompt edit, while health
+ * is measured on generated code — so the honest "pre vs post" comparison is
+ * "this change's measured health" vs "the health recorded at the last accepted
+ * promotion". This module persists that single recorded baseline.
+ *
+ * Stored at `<repoRoot>/.synergyspec-selfevolving/self-evolution/health-baseline.json`
+ * (alongside the `candidates/` dir). One number per repo, because health is
+ * measured over the whole project source, not per-target.
+ *
+ * Defensive by construction: a missing/corrupt file reads as `null` (⇒ no gate,
+ * first run records & allows), and writes are best-effort (a write failure must
+ * never turn a successful promote into an error). Callers supply the timestamp,
+ * so this module never calls Date.now (deterministic + replay-safe).
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+export const HEALTH_BASELINE_FILE = 'health-baseline.json';
+function baselinePath(repoRoot) {
+    return path.join(path.resolve(repoRoot), '.synergyspec-selfevolving', 'self-evolution', HEALTH_BASELINE_FILE);
+}
+function isFiniteNumber(v) {
+    return typeof v === 'number' && Number.isFinite(v);
+}
+/**
+ * Read the recorded baseline. Returns `null` when the file is absent, unreadable,
+ * unparseable, or carries a non-finite `healthPenalty` (treated as "no baseline
+ * yet" ⇒ the gate does not fire and the first measured run records it).
+ */
+export async function readHealthBaseline(repoRoot) {
+    let raw;
+    try {
+        raw = await fs.readFile(baselinePath(repoRoot), 'utf8');
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    const obj = parsed;
+    if (!isFiniteNumber(obj.healthPenalty))
+        return null;
+    return {
+        healthPenalty: obj.healthPenalty,
+        updatedAt: typeof obj.updatedAt === 'string' ? obj.updatedAt : '',
+        ...(typeof obj.sourceChange === 'string' ? { sourceChange: obj.sourceChange } : {}),
+        ...(typeof obj.candidateId === 'string' ? { candidateId: obj.candidateId } : {}),
+    };
+}
+/**
+ * Write/overwrite the recorded baseline. Best-effort: creates the parent dir if
+ * needed and swallows any error (a failed baseline write must not fail a promote
+ * that already succeeded). Returns `true` on a successful write, `false` otherwise.
+ */
+export async function writeHealthBaseline(repoRoot, baseline) {
+    const file = baselinePath(repoRoot);
+    try {
+        await fs.mkdir(path.dirname(file), { recursive: true });
+        await fs.writeFile(file, `${JSON.stringify(baseline, null, 2)}\n`, 'utf8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=health-baseline.js.map

package/dist/core/self-evolution/index.d.ts

@@ -12,6 +12,7 @@ export * from './learn-observation-adapter.js';
 export * from './hints.js';
 export * from './candidates.js';
 export * from './candidate-fitness.js';
+export * from './health-baseline.js';
 export * from './ga-selection.js';
 export * from './host-harness.js';
 export * from './replay.js';

package/dist/core/self-evolution/index.js

@@ -12,6 +12,7 @@ export * from './learn-observation-adapter.js';
 export * from './hints.js';
 export * from './candidates.js';
 export * from './candidate-fitness.js';
+export * from './health-baseline.js';
 export * from './ga-selection.js';
 export * from './host-harness.js';
 export * from './replay.js';

package/dist/core/self-evolution/learn-observation-adapter.d.ts

@@ -1,6 +1,6 @@
 import { type LearnEvolutionHint } from './learn-hints.js';
 import { type TargetEvolutionPolicy } from './target-evolution.js';
-import { type LearnReport } from '../learn.js';
+import { type LearnReport, type LearnObservation } from '../learn.js';
 /** The learn signals the interpreter reads (everything except the neutral observations). */
 type LearnSignals = Omit<LearnReport, 'observations'>;
 /**
@@ -40,6 +40,21 @@ export declare function resolveTargetLocalFilesReadonly(targetId: string, repoRo
  * `target-evolution.ts` and the `add-per-target-evolution-switch` change.
  */
 export declare function generateEvolutionHints(report: LearnSignals, policy?: TargetEvolutionPolicy): LearnEvolutionHint[];
+/**
+ * Surface an UNBINDABLE kind-only evolution hint as an actionable DEFECT
+ * observation. After {@link scopeHintsByPolicy} runs, a hint that still has no
+ * `affectedTargetId` is one that could not be pinned to a concrete target (>1
+ * same-kind target evolvable and none named via `--evolve-target`) — it would
+ * surface as the `<kind>:unspecified` placeholder and yield a "0 surviving hint
+ * group" refusal that is a BINDING DEFECT, not a safe gate refusal. Emitting this
+ * is what lets the agent (and the skill) tell the two apart instead of recording a
+ * binding bug as "the gate correctly refused".
+ *
+ * Reads the SCOPED hints directly (no second pin pass), so it cannot drift from
+ * {@link scopeHintsByPolicy}. Returns `[]` when `policy` is undefined or nothing is
+ * unbindable, keeping learn output byte-identical in the common case.
+ */
+export declare function detectUnbindableHintObservations(hints: LearnEvolutionHint[], policy: TargetEvolutionPolicy | undefined): LearnObservation[];
 /**
  * Persist hints to the canonical handoff path that `propose-canonical
  * --from-learn` reads (`{ evolutionHints: [...] }`). This is the one-motion