synergyspec-selfevolving 1.4.0 → 2.0.0

package/dist/core/self-evolution/episode-orchestrator.js

@@ -0,0 +1,534 @@
+import { toActionSkeleton } from '../trajectory/skeleton.js';
+import { getTrajectoryForChange } from '../trajectory/registry.js';
+import { acquireInFlight, releaseInFlight, currentPolicyVersion, readPolicyLedger, initPolicyLineage, rollbackPolicyVersion, } from './policy/policy-store.js';
+import { appendRejectBufferEntry, readRejectBuffer, } from './policy/reject-buffer.js';
+import { createEpisode, advanceEpisodeStage, writeArmCapture, readEpisode, episodeDir, } from './episode-store.js';
+import { shouldRunCriticAgent, runCriticAgent, } from './critic-agent.js';
+import { runRewardAgent } from './reward-agent.js';
+import { runEvolvingAgent, DEFAULT_EVOLVING_AGENT_EDIT_BUDGET, } from './evolving-agent.js';
+/**
+ * Build the 主智能体 MAIN AGENT arm `{transcript?, skeleton?, objective}` from an
+ * already-computed learn report's {@link FitnessSample} + the discovered
+ * trajectory.
+ *
+ * REUSES the learn/fitness grading verbatim — it never re-grades:
+ *   - `objective.passRate` prefers the OBSERVED pass rate
+ *     (`fitnessSample.trajectoryFacts.observedPassRate` when a runner ran), else
+ *     the authored `testMetrics.passRate`, else `null` (never fabricated);
+ *   - `objective.healthPenalty` is `fitnessSample.healthSignal` (the raw
+ *     "no signal ⇒ null" health reading, distinct from the `?? 0`-defaulted
+ *     `loss.healthPenalty`);
+ *   - `objective.loss` is the blended `fitnessSample.loss.loss` (or `null`);
+ *   - `verified` / `observedStatus` come from `trajectoryFacts`.
+ * The shape is byte-identical to {@link ArmObjective} so both arms read uniformly.
+ */
+export async function captureMainArm(opts) {
+    const sample = opts.report.fitnessSample;
+    const facts = sample?.trajectoryFacts;
+    // Honesty: prefer the OBSERVED pass rate (a real runner ran), else the
+    // authored test-report summary; null when neither parsed (never fabricated) —
+    // the exact precedence learn.ts uses to compute the loss.
+    const observedPassRate = facts?.testRunObserved && facts.observedPassRate !== null
+        ? facts.observedPassRate
+        : null;
+    const passRate = observedPassRate ?? sample?.testMetrics?.passRate ?? null;
+    const objective = {
+        passRate,
+        ...(sample?.testMetrics
+            ? { testsTotal: sample.testMetrics.total, testsFailed: sample.testMetrics.failed }
+            : {}),
+        // The raw health signal — the same "no signal ⇒ null" reading learn records,
+        // NOT the `?? 0`-defaulted loss.healthPenalty.
+        healthPenalty: sample?.healthSignal ?? null,
+        // The blended functional⊕health per-change loss; null when no functional signal.
+        loss: sample?.loss ? sample.loss.loss : null,
+        verified: facts ? facts.verified : false,
+        observedStatus: facts ? facts.observedStatus : null,
+        measuredAt: new Date().toISOString(),
+    };
+    // Transcript + skeleton: prefer the handles / the report's own observedRun;
+    // re-discover the trajectory's skeleton only when none was handed in. The raw
+    // transcript jsonl is the CALLER's to pass (the objective already folds in the
+    // graded facts) — we never re-read session files here.
+    const transcript = opts.trajectoryHandles?.transcript;
+    let skeleton = opts.trajectoryHandles?.skeleton ?? opts.report.observedRun ?? undefined;
+    if (skeleton === undefined) {
+        const trajectory = opts.trajectoryHandles?.trajectorySource
+            ? await opts.trajectoryHandles.trajectorySource
+                .getTrajectory(opts.changeName)
+                .catch(() => null)
+            : await getTrajectoryForChange(opts.repoRoot, opts.changeName);
+        if (trajectory) {
+            const derived = toActionSkeleton(trajectory);
+            if (derived)
+                skeleton = derived;
+        }
+    }
+    return {
+        ...(transcript !== undefined ? { transcript } : {}),
+        ...(skeleton !== undefined ? { skeleton } : {}),
+        objective,
+    };
+}
+/**
+ * Derive the deterministic episode id seed up front (same recipe as
+ * {@link createEpisode}'s default: `<changeName>-<compact UTC yyyyMMddTHHmmss>`
+ * sanitized to `[a-z0-9-]`). Computing it before the lock lets us acquire the
+ * in-flight slot WITHOUT first creating an episode dir, so the busy path leaves
+ * no inert dir behind.
+ */
+function deriveEpisodeId(changeName, now) {
+    const pad = (n, width = 2) => String(n).padStart(width, '0');
+    const ts = `${pad(now.getUTCFullYear(), 4)}${pad(now.getUTCMonth() + 1)}${pad(now.getUTCDate())}` +
+        `T${pad(now.getUTCHours())}${pad(now.getUTCMinutes())}${pad(now.getUTCSeconds())}`;
+    return `${changeName}-${ts}`
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, '-')
+        .replace(/-{2,}/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+/**
+ * Run ONE episode through the loop in the strict, durably-persisted order
+ * documented at the top of this module. See {@link RunEpisodeResult}.
+ *
+ * The in-flight lock is released in a finally guard so a throw mid-episode never
+ * wedges the target's slot.
+ */
+export async function runEpisode(opts) {
+    const repoRoot = opts.repoRoot;
+    const targetId = opts.targetId;
+    const now = opts.now ?? new Date();
+    const threshold = opts.advantageRollbackThreshold ?? 0;
+    const editBudget = opts.editBudget ?? DEFAULT_EVOLVING_AGENT_EDIT_BUDGET;
+    // ── b (pre-lock half): ensure the 单一血统 single lineage exists ────────────
+    // initPolicyLineage must precede acquireInFlight: the lock records the lineage
+    // head as `sinceVersion`, which requires an initialized lineage.
+    if ((await currentPolicyVersion(repoRoot, targetId)) === null) {
+        await initPolicyLineage({
+            repoRoot,
+            targetId,
+            ...(opts.resolveFiles ? { resolveFiles: opts.resolveFiles } : {}),
+        });
+    }
+    const policyVersionMain = await currentPolicyVersion(repoRoot, targetId);
+    // The episode id is fixed up front (deterministic seed) so the lock entry and
+    // the episode dir agree and no inert episode dir is created on the busy path.
+    const episodeId = deriveEpisodeId(opts.changeName, now);
+    // ── a: acquireInFlight FIRST (one in-flight per target). A non-stale lock for
+    // the target ⇒ clean 'busy' result, BEFORE any episode dir is created. ───────
+    try {
+        await acquireInFlight({ repoRoot, targetId, episodeId, now });
+    }
+    catch (err) {
+        return {
+            episodeId: null,
+            busy: true,
+            reason: err instanceof Error ? err.message : String(err),
+        };
+    }
+    // From here the lock is HELD; release in the finally guard. `lockEpisodeId`
+    // tracks WHICH episode id currently owns the lock (re-keyed on a rare
+    // collision suffix) so the release always matches the holder.
+    let lockEpisodeId = episodeId;
+    try {
+        // ── b/c: create the episode (with the pre-acquired id). createEpisode
+        // collision-suffixes only if the dir already exists; the freshly-acquired
+        // lock + deterministic seed make a collision practically impossible, but if
+        // it does suffix we re-key the lock to the real id so they stay consistent. ─
+        const created = await createEpisode({
+            repoRoot,
+            changeName: opts.changeName,
+            changeDirPath: opts.changeDirPath,
+            targetId,
+            policyVersionMain,
+            episodeId,
+            now,
+        });
+        const realEpisodeId = created.episode.episodeId;
+        if (realEpisodeId !== episodeId) {
+            await releaseInFlight({ repoRoot, targetId, episodeId }).catch(() => { });
+            await acquireInFlight({ repoRoot, targetId, episodeId: realEpisodeId, now });
+            lockEpisodeId = realEpisodeId;
+        }
+        return await runEpisodeAfterCreate({
+            ...opts,
+            episodeId: realEpisodeId,
+            now,
+            threshold,
+            editBudget,
+        });
+    }
+    finally {
+        // ── h (lock half): release the in-flight slot ALWAYS, even on error. ───────
+        await releaseInFlight({ repoRoot, targetId, episodeId: lockEpisodeId }).catch(() => { });
+    }
+}
+/**
+ * The body of {@link runEpisode} AFTER the episode dir exists and the lock is
+ * held: steps c→h (arm capture through close). Split out so {@link runEpisode}'s
+ * outer try/finally owns the lock and the collision re-key cleanly.
+ */
+async function runEpisodeAfterCreate(opts) {
+    const { repoRoot, targetId, episodeId, threshold, editBudget } = opts;
+    let decision = 'kept';
+    let advantage = null;
+    let baselineSkipped = false;
+    let evolution = null;
+    // ── c: record the 主智能体 MAIN AGENT arm ────────────────────────────────────
+    await writeArmCapture({
+        repoRoot,
+        episodeId,
+        arm: 'main-arm',
+        ...(opts.mainArm.transcript !== undefined
+            ? { transcript: { fileName: 'transcript.jsonl', content: opts.mainArm.transcript } }
+            : {}),
+        ...(opts.mainArm.skeleton !== undefined ? { skeleton: opts.mainArm.skeleton } : {}),
+        objective: opts.mainArm.objective,
+    });
+    await advanceEpisodeStage({ repoRoot, episodeId, stage: 'main-arm-captured' });
+    // ── d: CRITIC AGENT（基线智能体 baseline agent）or skip ───────────────────────
+    const shouldCritic = await shouldRunCriticAgent({ repoRoot, targetId });
+    if (shouldCritic.run && shouldCritic.baselineVersion !== null) {
+        // runCriticAgent advances the episode to 'baseline-arm-captured'.
+        await runCriticAgent({
+            repoRoot,
+            targetId,
+            changeName: opts.changeName,
+            episodeId,
+            baselineVersion: shouldCritic.baselineVersion,
+            spawn: opts.spawn,
+        });
+    }
+    else {
+        baselineSkipped = true;
+        await advanceEpisodeStage({
+            repoRoot,
+            episodeId,
+            stage: 'baseline-skipped',
+            patch: { baselineSkippedReason: shouldCritic.reason },
+        });
+    }
+    // ── e: 奖励智能体 REWARD AGENT — score + diagnosis.json + advance 'scored' ────
+    const reward = await runRewardAgent({ repoRoot, episodeId, spawn: opts.spawn });
+    const diagnosis = reward.diagnosis;
+    advantage = diagnosis.advantage;
+    // ── f: DECISION (every step durably persisted before the next) ───────────────
+    if (diagnosis.abstained || diagnosis.gaps.length === 0) {
+        // 弃权 abstained / no nameable gap → no rollback decision; SKIP evolution.
+        decision = 'abstained';
+        await advanceEpisodeStage({ repoRoot, episodeId, stage: 'abstained' });
+    }
+    else {
+        const badAdvantage = advantage !== null && advantage < threshold;
+        const ep = await readEpisode(repoRoot, episodeId);
+        const headBeforeRollback = await currentPolicyVersion(repoRoot, targetId);
+        // Resolve the rollback target: the policy the CRITIC AGENT reran
+        // (`policyVersionBaseline`) when it is a valid EARLIER version, else the
+        // version immediately before the head (the prior good policy the bad edit
+        // advanced past). `rollbackPolicyVersion` requires `toVersion < head`.
+        const rollbackTarget = resolveRollbackTarget(ep.policyVersionBaseline, headBeforeRollback);
+        if (badAdvantage && rollbackTarget !== null && headBeforeRollback !== null) {
+            // (i) ROLLBACK first — durable on disk. `advantage` is non-null inside the
+            // badAdvantage branch; `?? undefined` satisfies the optional `number` param.
+            await rollbackPolicyVersion({
+                repoRoot,
+                targetId,
+                episodeId,
+                toVersion: rollbackTarget,
+                advantage: advantage ?? undefined,
+            });
+            // (ii) THEN append the 否决缓冲 reject-buffer entry — durable on disk —
+            // BEFORE the 演进智能体 EVOLVING AGENT is even called, so the entry written
+            // THIS episode is in its fresh-from-disk prompt.
+            const rejectEntry = {
+                schemaVersion: 1,
+                at: new Date().toISOString(),
+                episodeId,
+                targetId,
+                // fromVersion = the version we rolled back TO (the prior good policy);
+                // toVersion = the (now rolled-back) version the rejected edit reached.
+                fromVersion: rollbackTarget,
+                toVersion: headBeforeRollback,
+                advantage,
+                rewardMain: diagnosis.rewardMain,
+                rewardBaseline: diagnosis.rewardBaseline,
+                textualGradientTried: diagnosis.textualGradient ?? '',
+                editSummary: buildRejectEditSummary(diagnosis),
+                reason: 'bad-advantage',
+            };
+            await appendRejectBufferEntry(repoRoot, rejectEntry);
+            decision = 'rolled-back';
+            await advanceEpisodeStage({ repoRoot, episodeId, stage: 'rolled-back' });
+        }
+        else {
+            // Good advantage, OR no earlier version to roll back to (e.g. head is v0):
+            // keep the current head.
+            decision = 'kept';
+            await advanceEpisodeStage({ repoRoot, episodeId, stage: 'kept' });
+        }
+        // ── g: ONLY AFTER (f) persisted 'rolled-back'/'kept' ───────────────────────
+        // runEvolvingAgent reads the reject-buffer FRESH from disk (the entry just
+        // written THIS episode is in its prompt). Never parallelized with (f).
+        evolution = await runEvolvingAgent({
+            repoRoot,
+            episodeId,
+            targetId,
+            editBudget,
+            spawn: opts.spawn,
+        });
+    }
+    // ── h (stage half): advance 'closed' (best-effort) ───────────────────────────
+    await closeEpisodeBestEffort(repoRoot, episodeId);
+    const newPolicyVersion = await currentPolicyVersion(repoRoot, targetId);
+    return { episodeId, baselineSkipped, advantage, decision, evolution, newPolicyVersion };
+}
+/**
+ * Advance the episode to 'closed' from whatever terminal-ish stage it reached
+ * (evolved | evolution-refused | abstained), best-effort: a stage that cannot
+ * legally reach 'closed' (e.g. the evolving agent was not-spawned, leaving the
+ * episode at 'kept'/'rolled-back') is left as-is rather than throwing, so the
+ * close never masks the real episode outcome.
+ */
+async function closeEpisodeBestEffort(repoRoot, episodeId) {
+    const ep = await readEpisode(repoRoot, episodeId);
+    const closable = new Set([
+        'evolved',
+        'evolution-refused',
+        'abstained',
+    ]);
+    if (closable.has(ep.stage)) {
+        await advanceEpisodeStage({ repoRoot, episodeId, stage: 'closed' });
+    }
+}
+/**
+ * Resolve the version a bad-advantage rollback should restore. Prefers the
+ * policy the CRITIC AGENT reran (`policyVersionBaseline`) when it is a valid
+ * EARLIER version than the head; otherwise the version immediately before the
+ * head (the prior good policy the rejected edit advanced past). Returns `null`
+ * when there is no earlier version to roll back to (head is v0, or the head is
+ * unknown) — the caller then keeps the head.
+ */
+function resolveRollbackTarget(baselineVersion, head) {
+    if (head === null || head < 1)
+        return null;
+    if (baselineVersion !== null &&
+        Number.isInteger(baselineVersion) &&
+        baselineVersion >= 0 &&
+        baselineVersion < head) {
+        return baselineVersion;
+    }
+    return head - 1;
+}
+/**
+ * Derive the 否决缓冲 reject-buffer `editSummary` from the diagnosis. The
+ * rejected edit's files were already rolled back (产物即弃), so the durable
+ * record is the diagnosed gap files (the edit's intended surface) + the 文本梯度
+ * textual gradient that lost (its rationale).
+ */
+function buildRejectEditSummary(diagnosis) {
+    const files = uniqueStrings(diagnosis.gaps.map((g) => g.file));
+    return {
+        files,
+        linesAdded: 0,
+        linesRemoved: 0,
+        rationaleExcerpt: (diagnosis.textualGradient ?? '').slice(0, 280),
+    };
+}
+function uniqueStrings(values) {
+    const seen = new Set();
+    const out = [];
+    for (const v of values) {
+        if (v.length === 0 || seen.has(v))
+            continue;
+        seen.add(v);
+        out.push(v);
+    }
+    return out;
+}
+/**
+ * Append a 'bad-advantage' reject-buffer entry for this episode UNLESS one is
+ * already on disk for this episodeId. Idempotent so a crash-resume that re-enters
+ * the decision (or re-enters AFTER the rollback was applied but BEFORE/AFTER the
+ * reject-buffer write) never duplicates the rejection record — the 演进智能体
+ * EVOLVING AGENT must see exactly one entry per rejected edit. The 文本梯度
+ * textual gradient written here is the diagnosis's, so a freshly-written entry on
+ * resume carries the same gradient the in-process path would have.
+ */
+async function ensureRejectBufferEntry(repoRoot, opts) {
+    const existing = await readRejectBuffer(repoRoot, opts.targetId);
+    if (existing.some((e) => e.episodeId === opts.episodeId))
+        return;
+    const entry = {
+        schemaVersion: 1,
+        at: new Date().toISOString(),
+        episodeId: opts.episodeId,
+        targetId: opts.targetId,
+        fromVersion: opts.fromVersion,
+        toVersion: opts.toVersion,
+        advantage: opts.advantage,
+        rewardMain: opts.diagnosis.rewardMain,
+        rewardBaseline: opts.diagnosis.rewardBaseline,
+        textualGradientTried: opts.diagnosis.textualGradient ?? '',
+        editSummary: buildRejectEditSummary(opts.diagnosis),
+        reason: 'bad-advantage',
+    };
+    await appendRejectBufferEntry(repoRoot, entry);
+}
+/**
+ * Re-enter a partially-run episode at its recorded stage and idempotently run
+ * the REMAINING steps. Best-effort — used by the CLI `episode resume`. The
+ * episode stage machine is monotonic, so this picks up from the first not-yet-
+ * done step rather than re-advancing a stage already entered:
+ *
+ *   - 'scored'                    → run the decision (f) then the 演进智能体 (g).
+ *   - 'rolled-back' / 'kept'      → run the 演进智能体 EVOLVING AGENT (g) then close.
+ *   - 'evolved'/'evolution-refused'/'abstained' → close.
+ *   - earlier stages              → not auto-resumable here (the arms / reward
+ *                                   agent need their own re-entry); reported as-is.
+ *
+ * NOTE: resume does NOT re-acquire the in-flight lock — the original
+ * {@link runEpisode} already released it; a resume is an operator-driven
+ * recovery, not a concurrent run.
+ */
+export async function resumeEpisode(opts) {
+    const { repoRoot, episodeId } = opts;
+    const editBudget = opts.editBudget ?? DEFAULT_EVOLVING_AGENT_EDIT_BUDGET;
+    const threshold = opts.advantageRollbackThreshold ?? 0;
+    const ep = await readEpisode(repoRoot, episodeId);
+    const resumedFrom = ep.stage;
+    const targetId = ep.targetId;
+    let evolution = null;
+    if (ep.stage === 'scored') {
+        // Re-run the decision (f) from the on-disk diagnosis, then (g).
+        const diagnosis = await readDiagnosisForResume(repoRoot, episodeId);
+        if (diagnosis === null || diagnosis.abstained || diagnosis.gaps.length === 0) {
+            await advanceEpisodeStage({ repoRoot, episodeId, stage: 'abstained' });
+        }
+        else {
+            const advantage = diagnosis.advantage;
+            const badAdvantage = advantage !== null && advantage < threshold;
+            // Crash-resume dedup: a 'rollback' ledger entry whose episodeId is THIS
+            // episode means runEpisode already applied the rollback before the host
+            // crashed (the rollback head is monotonic — re-calling rollbackPolicyVersion
+            // would stack a SECOND, duplicate rollback version). When present, reuse its
+            // recorded version axis and SKIP the re-rollback; only ensure the
+            // reject-buffer entry + the 'rolled-back' stage advance complete.
+            const ledger = await readPolicyLedger(repoRoot, targetId);
+            const priorRollback = ledger.find((e) => e.action === 'rollback' && e.episodeId === episodeId);
+            if (priorRollback) {
+                // The prior rollback already advanced to `priorRollback.version`, rolling
+                // FORWARD to the content of the version immediately before the rejected
+                // edit's head. Reconstruct the reject-buffer axis from that entry:
+                //   toVersion   = the (rolled-back) version the rejected edit reached
+                //               = priorRollback.version - 1 (the head before the rollback)
+                //   fromVersion = the prior good policy restored (one before that head)
+                const toVersion = priorRollback.version - 1;
+                const fromVersion = resolveRollbackTarget(ep.policyVersionBaseline, toVersion);
+                await ensureRejectBufferEntry(repoRoot, {
+                    episodeId,
+                    targetId,
+                    fromVersion: fromVersion ?? toVersion,
+                    toVersion,
+                    advantage,
+                    diagnosis,
+                });
+                await advanceEpisodeStage({ repoRoot, episodeId, stage: 'rolled-back' });
+            }
+            else {
+                const headBeforeRollback = await currentPolicyVersion(repoRoot, targetId);
+                const rollbackTarget = resolveRollbackTarget(ep.policyVersionBaseline, headBeforeRollback);
+                if (badAdvantage && rollbackTarget !== null && headBeforeRollback !== null) {
+                    await rollbackPolicyVersion({
+                        repoRoot,
+                        targetId,
+                        episodeId,
+                        toVersion: rollbackTarget,
+                        advantage: advantage ?? undefined,
+                    });
+                    await ensureRejectBufferEntry(repoRoot, {
+                        episodeId,
+                        targetId,
+                        fromVersion: rollbackTarget,
+                        toVersion: headBeforeRollback,
+                        advantage,
+                        diagnosis,
+                    });
+                    await advanceEpisodeStage({ repoRoot, episodeId, stage: 'rolled-back' });
+                }
+                else {
+                    await advanceEpisodeStage({ repoRoot, episodeId, stage: 'kept' });
+                }
+            }
+            evolution = await runEvolvingAgent({
+                repoRoot,
+                episodeId,
+                targetId,
+                editBudget,
+                spawn: opts.spawn,
+            });
+        }
+        await closeEpisodeBestEffort(repoRoot, episodeId);
+    }
+    else if (ep.stage === 'rolled-back' || ep.stage === 'kept') {
+        evolution = await runEvolvingAgent({
+            repoRoot,
+            episodeId,
+            targetId,
+            editBudget,
+            spawn: opts.spawn,
+        });
+        await closeEpisodeBestEffort(repoRoot, episodeId);
+    }
+    else if (ep.stage === 'evolved' ||
+        ep.stage === 'evolution-refused' ||
+        ep.stage === 'abstained') {
+        await closeEpisodeBestEffort(repoRoot, episodeId);
+    }
+    // earlier stages: not auto-resumable here — reported as-is.
+    const after = await readEpisode(repoRoot, episodeId);
+    return { episodeId, resumedFrom, stage: after.stage, evolution };
+}
+/**
+ * Read the episode's diagnosis.json for resume's decision step, normalized to
+ * the minimal slice the decision needs. Returns `null` when unreadable (a
+ * missing/corrupt diagnosis ⇒ treat as abstain, the same fail-safe the EVOLVING
+ * AGENT's reader uses).
+ */
+async function readDiagnosisForResume(repoRoot, episodeId) {
+    const { promises: fs } = await import('node:fs');
+    const pathMod = await import('node:path');
+    const file = pathMod.join(episodeDir(repoRoot, episodeId), 'diagnosis.json');
+    let raw;
+    try {
+        raw = await fs.readFile(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    const gaps = Array.isArray(parsed.gaps)
+        ? parsed.gaps.flatMap((g) => {
+            const o = (g && typeof g === 'object' ? g : {});
+            return typeof o.file === 'string' &&
+                typeof o.section === 'string' &&
+                typeof o.description === 'string'
+                ? [{ file: o.file, section: o.section, description: o.description }]
+                : [];
+        })
+        : [];
+    return {
+        abstained: parsed.abstained === true,
+        gaps,
+        advantage: typeof parsed.advantage === 'number' ? parsed.advantage : null,
+        rewardMain: typeof parsed.rewardMain === 'number' ? parsed.rewardMain : 0,
+        rewardBaseline: typeof parsed.rewardBaseline === 'number' ? parsed.rewardBaseline : null,
+        textualGradient: typeof parsed.textualGradient === 'string' ? parsed.textualGradient : null,
+    };
+}
+//# sourceMappingURL=episode-orchestrator.js.map