synergyspec-selfevolving 1.4.0 → 2.1.0

package/dist/core/self-evolution/policy/prediction-reconcile.d.ts

@@ -0,0 +1,54 @@
+import { type PolicyPrediction } from './policy-store.js';
+export declare const POLICY_PREDICTION_RECONCILE_FILE = "prediction-reconcile.ndjson";
+/** One settled prediction: what was bet, and whether the measured delta agreed. */
+export interface PredictionReconcileEntry {
+    schemaVersion: 1;
+    /** ISO-8601 UTC timestamp the prediction was settled. */
+    at: string;
+    episodeId: string;
+    targetId: string;
+    /** The 'evolve' version whose prediction this settles. */
+    predictedAtVersion: number;
+    metric: PolicyPrediction['metric'];
+    direction: PolicyPrediction['direction'];
+    /**
+     * Verifiable `main[metric] − baseline[metric]` for the two arms of the
+     * settling episode; `null` when either arm lacked the measured value.
+     */
+    observedDelta: number | null;
+    /**
+     * `true`  — the measured delta moved in the predicted direction;
+     * `false` — it did not (refuted, incl. no movement);
+     * `null`  — unsettled (a value was unmeasured).
+     */
+    hit: boolean | null;
+}
+/**
+ * Read one target's settled predictions, newest LAST. `[]` when the ledger does
+ * not exist; malformed lines skipped best-effort.
+ */
+export declare function readPredictionReconcile(repoRoot: string, targetId: string): Promise<PredictionReconcileEntry[]>;
+export interface ReconcilePredictionOptions {
+    repoRoot: string;
+    targetId: string;
+    episodeId: string;
+}
+/**
+ * Settle the prediction attached to the version the 主智能体 MAIN AGENT ran this
+ * episode against the two arms' measured metric delta, and append a residual.
+ *
+ * Returns the appended entry, or `null` when there is nothing to settle (the
+ * head version carries no prediction — e.g. v0 init or a rollback content
+ * version), the lineage is unknown, or this episode is already settled
+ * (idempotent). Best-effort: a missing arm objective yields an `unsettled`
+ * (`hit: null`) entry rather than a throw.
+ */
+export declare function reconcilePrediction(opts: ReconcilePredictionOptions): Promise<PredictionReconcileEntry | null>;
+/**
+ * Fold the recent settled predictions into a one-line-plus-bullets advisory note
+ * for the 演进智能体 EVOLVING AGENT's prompt. Counts only SETTLED entries
+ * (`hit !== null`); returns `null` when there is no settled history, so early
+ * episodes render no calibration block (byte-identical prompts).
+ */
+export declare function summarizeCalibration(repoRoot: string, targetId: string, limit?: number): Promise<string | null>;
+//# sourceMappingURL=prediction-reconcile.d.ts.map

package/dist/core/self-evolution/policy/prediction-reconcile.js

@@ -0,0 +1,191 @@
+/**
+ * 预测校准 prediction-reconcile ledger — closes the propose→observe loop.
+ *
+ * The 演进智能体 EVOLVING AGENT attaches a falsifiable {@link PolicyPrediction}
+ * to every 'evolve' step (which scoreboard metric the edit will move, and in
+ * which direction). Until now that prediction was a DEAD WRITE: recorded on the
+ * 版本账本 ledger, surfaced only as a display string, never compared to what
+ * actually happened.
+ *
+ * This module settles it. When a later episode measures the two arms, the
+ * prediction made for the version the 主智能体 MAIN AGENT just ran is checked
+ * against the VERIFIABLE per-metric delta `main[metric] − baseline[metric]`
+ * (NOT the LLM judge's reward — the settlement is a hard, reproducible signal).
+ * A hit/miss residual is appended to a sibling NDJSON ledger, and
+ * {@link summarizeCalibration} folds the recent record into a one-line advisory
+ * note the orchestrator feeds back to the proposer ("a repeatedly-refuted
+ * direction is a weak bet"). The note is ADVISORY ONLY — it never gates an edit.
+ *
+ * Append-only, one line per settled episode in
+ * `<repoRoot>/.synergyspec-selfevolving/self-evolution/policy/prediction-reconcile.ndjson`,
+ * newest last. Settlement is idempotent per episode (a crash-resume that
+ * re-enters never double-appends); reads skip malformed lines best-effort,
+ * matching the repo's other ndjson readers. Every public call is defensive —
+ * missing arms / no prior prediction / unreadable objective ⇒ a clean
+ * `null`/`[]`, never a throw that could fail the episode.
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import { resolvePolicyLayout, readPolicyLedger } from './policy-store.js';
+import { appendFileDurable } from './fs-safe.js';
+import { episodeDir, readEpisode } from '../episode-store.js';
+export const POLICY_PREDICTION_RECONCILE_FILE = 'prediction-reconcile.ndjson';
+function reconcilePath(repoRoot) {
+    return path.join(resolvePolicyLayout(path.resolve(repoRoot)).baseDir, POLICY_PREDICTION_RECONCILE_FILE);
+}
+function isFiniteNumberOrNull(value) {
+    return value === null || (typeof value === 'number' && Number.isFinite(value));
+}
+const RECONCILE_METRICS = new Set(['loss', 'passRate', 'healthPenalty']);
+function isValidReconcileEntry(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const e = value;
+    if (e.schemaVersion !== 1)
+        return false;
+    if (typeof e.at !== 'string' || e.at.length === 0)
+        return false;
+    if (typeof e.episodeId !== 'string' || e.episodeId.length === 0)
+        return false;
+    if (typeof e.targetId !== 'string' || e.targetId.length === 0)
+        return false;
+    if (typeof e.predictedAtVersion !== 'number' || !Number.isInteger(e.predictedAtVersion)) {
+        return false;
+    }
+    if (typeof e.metric !== 'string' || !RECONCILE_METRICS.has(e.metric))
+        return false;
+    if (e.direction !== 'down' && e.direction !== 'up')
+        return false;
+    if (!isFiniteNumberOrNull(e.observedDelta))
+        return false;
+    if (e.hit !== true && e.hit !== false && e.hit !== null)
+        return false;
+    return true;
+}
+/**
+ * Read one target's settled predictions, newest LAST. `[]` when the ledger does
+ * not exist; malformed lines skipped best-effort.
+ */
+export async function readPredictionReconcile(repoRoot, targetId) {
+    let raw;
+    try {
+        raw = await fs.readFile(reconcilePath(repoRoot), 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return [];
+        throw err;
+    }
+    const out = [];
+    for (const line of raw.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (isValidReconcileEntry(parsed) && parsed.targetId === targetId)
+            out.push(parsed);
+    }
+    return out;
+}
+/** Defensively read one arm's `objective.json` numeric metric value, or `null`. */
+async function readArmMetric(repoRoot, episodeId, arm, metric) {
+    let raw;
+    try {
+        raw = await fs.readFile(path.join(episodeDir(repoRoot, episodeId), arm, 'objective.json'), 'utf8');
+    }
+    catch {
+        return null;
+    }
+    let obj;
+    try {
+        obj = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    const v = obj[metric];
+    return typeof v === 'number' && Number.isFinite(v) ? v : null;
+}
+/**
+ * Settle the prediction attached to the version the 主智能体 MAIN AGENT ran this
+ * episode against the two arms' measured metric delta, and append a residual.
+ *
+ * Returns the appended entry, or `null` when there is nothing to settle (the
+ * head version carries no prediction — e.g. v0 init or a rollback content
+ * version), the lineage is unknown, or this episode is already settled
+ * (idempotent). Best-effort: a missing arm objective yields an `unsettled`
+ * (`hit: null`) entry rather than a throw.
+ */
+export async function reconcilePrediction(opts) {
+    const repoRoot = path.resolve(opts.repoRoot);
+    const { targetId, episodeId } = opts;
+    const ep = await readEpisode(repoRoot, episodeId);
+    const mainVersion = ep.policyVersionMain;
+    if (mainVersion === null)
+        return null;
+    // The prediction to settle is the one on the 'evolve' entry that produced the
+    // version the main arm ran. 'refused' entries reuse the head version and
+    // 'rollback' entries carry no prediction — so match action+version+prediction.
+    const ledger = await readPolicyLedger(repoRoot, targetId);
+    const evolveEntry = ledger.find((e) => e.action === 'evolve' && e.version === mainVersion && e.prediction !== undefined);
+    const prediction = evolveEntry?.prediction;
+    if (!prediction)
+        return null;
+    // Idempotent: never settle the same episode twice (crash-resume safe).
+    const existing = await readPredictionReconcile(repoRoot, targetId);
+    if (existing.some((e) => e.episodeId === episodeId))
+        return null;
+    const main = await readArmMetric(repoRoot, episodeId, 'main-arm', prediction.metric);
+    const baseline = await readArmMetric(repoRoot, episodeId, 'baseline-arm', prediction.metric);
+    const observedDelta = main !== null && baseline !== null ? main - baseline : null;
+    const hit = observedDelta === null
+        ? null
+        : prediction.direction === 'down'
+            ? observedDelta < 0
+            : observedDelta > 0;
+    const entry = {
+        schemaVersion: 1,
+        at: new Date().toISOString(),
+        episodeId,
+        targetId,
+        predictedAtVersion: mainVersion,
+        metric: prediction.metric,
+        direction: prediction.direction,
+        observedDelta,
+        hit,
+    };
+    const layout = resolvePolicyLayout(repoRoot);
+    await fs.mkdir(layout.baseDir, { recursive: true });
+    await appendFileDurable(reconcilePath(repoRoot), `${JSON.stringify(entry)}\n`);
+    return entry;
+}
+/** Most-recent settled predictions surfaced in the calibration note. */
+const CALIBRATION_NOTE_LIMIT = 5;
+/**
+ * Fold the recent settled predictions into a one-line-plus-bullets advisory note
+ * for the 演进智能体 EVOLVING AGENT's prompt. Counts only SETTLED entries
+ * (`hit !== null`); returns `null` when there is no settled history, so early
+ * episodes render no calibration block (byte-identical prompts).
+ */
+export async function summarizeCalibration(repoRoot, targetId, limit = CALIBRATION_NOTE_LIMIT) {
+    const settled = (await readPredictionReconcile(repoRoot, targetId)).filter((e) => e.hit !== null);
+    if (settled.length === 0)
+        return null;
+    const recent = settled.slice(-Math.max(1, limit));
+    const hits = recent.filter((e) => e.hit === true).length;
+    const misses = recent.length - hits;
+    const lines = recent.map((e) => {
+        const arrow = e.direction === 'down' ? '↓' : '↑';
+        const verdict = e.hit ? 'held' : 'refuted';
+        const delta = e.observedDelta === null ? '' : ` (Δ=${e.observedDelta.toFixed(3)})`;
+        return `- v${e.predictedAtVersion}: predicted ${e.metric} ${arrow} — ${verdict}${delta}`;
+    });
+    return [`Last ${recent.length} settled prediction(s): ${hits} held, ${misses} refuted.`, ...lines].join('\n');
+}
+//# sourceMappingURL=prediction-reconcile.js.map

package/dist/core/self-evolution/policy/reject-buffer.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Why the attempted evolve step was rejected:
+ *  - `bad-advantage`     — the 奖励智能体 REWARD AGENT measured a non-positive
+ *                          advantage (主臂 did not beat the 基线臂).
+ *  - `human-reject`      — a human said no.
+ *  - `tamper-suspected`  — the 防作弊 tamper detector flagged the main arm as
+ *                          having "passed" by weakening its own tests.
+ */
+export type RejectBufferReason = 'bad-advantage' | 'human-reject' | 'tamper-suspected';
+/** Compact description of the rejected edit (the files themselves rolled back). */
+export interface RejectBufferEditSummary {
+    /** Repo-relative POSIX paths the rejected edit touched. */
+    files: string[];
+    linesAdded: number;
+    linesRemoved: number;
+    /** Short excerpt of the edit's rationale, for the next episode's context. */
+    rationaleExcerpt: string;
+}
+/** One line of the 否决缓冲 (`reject-buffer.ndjson`). */
+export interface RejectBufferEntry {
+    schemaVersion: 1;
+    /** ISO-8601 UTC timestamp the rejection was recorded. */
+    at: string;
+    episodeId: string;
+    targetId: string;
+    /** The lineage version the rejected edit was based on. */
+    fromVersion: number;
+    /** The (now rolled-back) version the rejected edit had advanced to. */
+    toVersion: number;
+    /** advantage ＝ reward(主臂) − reward(基线臂); null when not measured. */
+    advantage: number | null;
+    rewardMain: number | null;
+    rewardBaseline: number | null;
+    /** The 文本梯度 textual gradient the rejected edit was acting on. */
+    textualGradientTried: string;
+    editSummary: RejectBufferEditSummary;
+    reason: RejectBufferReason;
+}
+/**
+ * Append one rejection to the 否决缓冲. Fail-closed: an invalid entry throws
+ * and nothing is written. Returns the buffer's path.
+ */
+export declare function appendRejectBufferEntry(repoRoot: string, entry: RejectBufferEntry): Promise<string>;
+/**
+ * Read one target's rejections, newest LAST (file/append order). `limit`
+ * returns only the most recent N (still newest last). Returns `[]` when the
+ * buffer does not exist; malformed lines are skipped best-effort.
+ */
+export declare function readRejectBuffer(repoRoot: string, targetId: string, limit?: number): Promise<RejectBufferEntry[]>;
+/**
+ * Read EVERY target's rejections, newest LAST (file/append order). Returns
+ * `[]` when the buffer does not exist; malformed lines are skipped best-effort.
+ */
+export declare function readRejectBufferAll(repoRoot: string): Promise<RejectBufferEntry[]>;
+//# sourceMappingURL=reject-buffer.d.ts.map

package/dist/core/self-evolution/policy/reject-buffer.js

@@ -0,0 +1,170 @@
+/**
+ * 否决缓冲 reject-buffer — the append-only record of evolve attempts the loop
+ * said NO to: a bad advantage measured by the 奖励智能体 REWARD AGENT
+ * (advantage ＝ reward(主臂) − reward(基线臂) came back non-positive), or a
+ * human reject. The 演进智能体 EVOLVING AGENT reads this before
+ * optimizer.step so it does not retry a 文本梯度 textual gradient that
+ * already lost — the rejected edit's summary stays as evidence instead of
+ * being silently discarded with the rolled-back files.
+ *
+ * One NDJSON line per rejection in
+ * `<repoRoot>/.synergyspec-selfevolving/self-evolution/policy/reject-buffer.ndjson`,
+ * newest last. Appends are fail-closed (an invalid entry throws and writes
+ * nothing); reads skip malformed lines best-effort, matching the repo's other
+ * ndjson readers.
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import { resolvePolicyLayout } from './policy-store.js';
+import { appendFileDurable } from './fs-safe.js';
+function isFiniteNumberOrNull(value) {
+    return value === null || (typeof value === 'number' && Number.isFinite(value));
+}
+function isNonNegativeInteger(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0;
+}
+/**
+ * Describe the FIRST shape problem of a would-be entry, or `null` when it is
+ * a valid {@link RejectBufferEntry}. Shared by the fail-closed append and the
+ * skip-corrupt-lines read.
+ */
+function rejectBufferEntryProblem(value) {
+    if (!value || typeof value !== 'object')
+        return 'entry must be an object';
+    const e = value;
+    if (e.schemaVersion !== 1)
+        return 'schemaVersion must be 1';
+    if (typeof e.at !== 'string' || e.at.length === 0)
+        return 'at must be an ISO-8601 string';
+    if (typeof e.episodeId !== 'string' || e.episodeId.length === 0) {
+        return 'episodeId must be a non-empty string';
+    }
+    if (typeof e.targetId !== 'string' || e.targetId.length === 0) {
+        return 'targetId must be a non-empty string';
+    }
+    if (!isNonNegativeInteger(e.fromVersion))
+        return 'fromVersion must be a non-negative integer';
+    if (!isNonNegativeInteger(e.toVersion))
+        return 'toVersion must be a non-negative integer';
+    if (!isFiniteNumberOrNull(e.advantage))
+        return 'advantage must be a finite number or null';
+    if (!isFiniteNumberOrNull(e.rewardMain))
+        return 'rewardMain must be a finite number or null';
+    if (!isFiniteNumberOrNull(e.rewardBaseline)) {
+        return 'rewardBaseline must be a finite number or null';
+    }
+    if (typeof e.textualGradientTried !== 'string') {
+        return 'textualGradientTried must be a string (the 文本梯度 textual gradient that was attempted)';
+    }
+    const summary = e.editSummary;
+    if (!summary || typeof summary !== 'object')
+        return 'editSummary must be an object';
+    if (!Array.isArray(summary.files) || summary.files.some((f) => typeof f !== 'string')) {
+        return 'editSummary.files must be string[]';
+    }
+    if (!isNonNegativeInteger(summary.linesAdded)) {
+        return 'editSummary.linesAdded must be a non-negative integer';
+    }
+    if (!isNonNegativeInteger(summary.linesRemoved)) {
+        return 'editSummary.linesRemoved must be a non-negative integer';
+    }
+    if (typeof summary.rationaleExcerpt !== 'string') {
+        return 'editSummary.rationaleExcerpt must be a string';
+    }
+    if (e.reason !== 'bad-advantage' &&
+        e.reason !== 'human-reject' &&
+        e.reason !== 'tamper-suspected') {
+        return "reason must be 'bad-advantage', 'human-reject', or 'tamper-suspected'";
+    }
+    return null;
+}
+/**
+ * Append one rejection to the 否决缓冲. Fail-closed: an invalid entry throws
+ * and nothing is written. Returns the buffer's path.
+ */
+export async function appendRejectBufferEntry(repoRoot, entry) {
+    const problem = rejectBufferEntryProblem(entry);
+    if (problem !== null) {
+        throw new Error(`Invalid 否决缓冲 reject-buffer entry: ${problem}`);
+    }
+    const layout = resolvePolicyLayout(path.resolve(repoRoot));
+    await fs.mkdir(layout.baseDir, { recursive: true });
+    // Durable append: fsync the fd so a host crash cannot lose a rollback's
+    // reject-buffer record a later separate process (resumeEpisode) relies on.
+    await appendFileDurable(layout.rejectBufferPath, `${JSON.stringify(entry)}\n`);
+    return layout.rejectBufferPath;
+}
+/**
+ * Read one target's rejections, newest LAST (file/append order). `limit`
+ * returns only the most recent N (still newest last). Returns `[]` when the
+ * buffer does not exist; malformed lines are skipped best-effort.
+ */
+export async function readRejectBuffer(repoRoot, targetId, limit) {
+    const layout = resolvePolicyLayout(path.resolve(repoRoot));
+    let raw;
+    try {
+        raw = await fs.readFile(layout.rejectBufferPath, 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return [];
+        throw err;
+    }
+    const entries = [];
+    for (const line of raw.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (rejectBufferEntryProblem(parsed) !== null)
+            continue;
+        const entry = parsed;
+        if (entry.targetId === targetId)
+            entries.push(entry);
+    }
+    if (limit === undefined)
+        return entries;
+    if (limit <= 0)
+        return [];
+    return entries.slice(-limit);
+}
+/**
+ * Read EVERY target's rejections, newest LAST (file/append order). Returns
+ * `[]` when the buffer does not exist; malformed lines are skipped best-effort.
+ */
+export async function readRejectBufferAll(repoRoot) {
+    const layout = resolvePolicyLayout(path.resolve(repoRoot));
+    let raw;
+    try {
+        raw = await fs.readFile(layout.rejectBufferPath, 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return [];
+        throw err;
+    }
+    const entries = [];
+    for (const line of raw.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (rejectBufferEntryProblem(parsed) !== null)
+            continue;
+        entries.push(parsed);
+    }
+    return entries;
+}
+//# sourceMappingURL=reject-buffer.js.map

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

@@ -99,7 +99,7 @@ export interface AutoPromoteDecision {
     reason: string;
 }
 /**
- * Pure auto-promote predicate for one-button auto-evolve. The static gate +
+ * Pure auto-promote predicate for one-button promote. The static gate +
  * per-target switch are hard prerequisites; the fitness comparison is the
  * regression guard.
  *

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

@@ -23,8 +23,8 @@
  */
 import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
-import * as crypto from 'node:crypto';
 import { GATE_DEFINING_FILES } from './candidate-gates.js';
+import { assertWithinRepo, writeFileAtomic } from './policy/fs-safe.js';
 import { resolveTargetLocalFiles } from './local-targets.js';
 import { isCanonicalTargetEvolvable, } from './target-evolution.js';
 import { readCandidatePackage, updateCandidateStatus, } from './candidates.js';
@@ -88,7 +88,7 @@ export async function applyCandidatePromotion(layout, candidateId, opts) {
         assertWithinRepo(repoRoot, abs);
         if (!(await fileExists(abs))) {
             throw new Error(`Refusing to promote ${candidateId}: target file does not exist on disk: ${rel} ` +
-                `(auto-evolve only edits existing local files).`);
+                `(self-evolution only edits existing local files).`);
         }
         resolved.push({ rel, abs, content: edit.content });
     }
@@ -143,11 +143,11 @@ export async function applyCandidatePromotion(layout, candidateId, opts) {
         // Lifecycle bridge: ready-for-eval -> eval-passed -> promoted.
         if (startStatus === 'ready-for-eval') {
             await updateStatus(layout, candidateId, 'eval-passed', {
-                rationale: 'auto-evolve: static gate stands in for the full eval suite (MVP)',
+                rationale: 'promote: static gate stands in for the full eval suite (MVP)',
             });
         }
         promoted = await updateStatus(layout, candidateId, 'promoted', {
-            rationale: `auto-evolve: applied ${appliedFiles.length} file(s) to canonical targets [${candidate.targetIds.join(', ')}]`,
+            rationale: `promote: applied ${appliedFiles.length} file(s) to canonical targets [${candidate.targetIds.join(', ')}]`,
         });
     }
     catch (err) {
@@ -194,7 +194,7 @@ export async function rollbackCandidatePromotion(layout, candidateId, opts) {
         restoredFiles.push(entry.relPath);
     }
     const rolled = await updateCandidateStatus(layout, candidateId, 'rolled-back', {
-        rationale: 'auto-evolve: restored pre-promotion snapshot',
+        rationale: 'rollback: restored pre-promotion snapshot',
     });
     return { candidateId, status: rolled.status, restoredFiles };
 }
@@ -205,7 +205,7 @@ export async function rollbackCandidatePromotion(layout, candidateId, opts) {
  */
 export const DEFAULT_HEALTH_REGRESSION_MARGIN = 0.05;
 /**
- * Pure auto-promote predicate for one-button auto-evolve. The static gate +
+ * Pure auto-promote predicate for one-button promote. The static gate +
  * per-target switch are hard prerequisites; the fitness comparison is the
  * regression guard.
  *
@@ -377,31 +377,4 @@ async function fileExists(abs) {
         return false;
     }
 }
-/** Throw if `abs` resolves outside `repoRoot`. */
-function assertWithinRepo(repoRoot, abs) {
-    const base = path.resolve(repoRoot);
-    const target = path.resolve(abs);
-    const rel = path.relative(base, target);
-    if (rel === '' || rel.startsWith('..') || path.isAbsolute(rel)) {
-        throw new Error(`Refusing to write outside repo root. root=${base} target=${target}`);
-    }
-}
-/** Atomic write via sibling tmp file + rename; cleans up on rename failure. */
-async function writeFileAtomic(abs, content) {
-    const dir = path.dirname(abs);
-    const tmp = path.join(dir, `.${path.basename(abs)}.tmp-${crypto.randomBytes(4).toString('hex')}`);
-    await fs.writeFile(tmp, content, 'utf8');
-    try {
-        await fs.rename(tmp, abs);
-    }
-    catch (err) {
-        try {
-            await fs.rm(tmp, { force: true });
-        }
-        catch {
-            // ignore
-        }
-        throw err;
-    }
-}
 //# sourceMappingURL=promote.js.map

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

@@ -28,8 +28,7 @@ import * as crypto from 'node:crypto';
 import { readCandidatePackage, setCandidateArtifactPath, } from './candidates.js';
 import { lookupCanonicalTarget, } from './canonical-targets.js';
 import { candidateEvalReportSchema } from './eval-report.js';
-import { readCandidateFitness, } from './candidate-fitness.js';
-import { readPromotedBaselineLoss } from './ga-selection.js';
+import { readCandidateFitness, readPromotedBaselineLoss, } from './candidate-fitness.js';
 import { DEFAULT_LOSS_REGRESSION_MARGIN } from './promote.js';
 /** Risk tier ordering used when comparing candidate risk to target risk. */
 const RISK_ORDER = {