synergyspec-selfevolving 2.1.5 → 2.1.7

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

@@ -1,5 +1,9 @@
-import { type CanonicalTargetKind } from './canonical-targets.js';
-import { type CanonicalCandidate } from './candidates.js';
+import { type CanonicalTarget, type CanonicalTargetKind } from './canonical-targets.js';
+import { type CandidateEdit, type CanonicalCandidate } from './candidates.js';
+import { type ResolvedTargetFile } from './local-targets.js';
+import { type PromotionApplyResult } from './promote.js';
+import { type StaticGateResult } from './candidate-gates.js';
+import type { TargetEvolutionPolicy } from './target-evolution.js';
 export declare const DREAM_RUN_SCHEMA_VERSION: 1;
 export type DreamEvidenceKind = 'change' | 'trajectory' | 'episode-diagnosis' | 'policy-ledger' | 'reject-buffer' | 'candidate-verdict';
 export interface DreamEvidenceItem {
@@ -39,6 +43,43 @@ export interface DreamTargetProposal {
     riskLevel: CanonicalCandidate['riskLevel'];
     changedFiles: string[];
 }
+export interface DreamOptimizerInput {
+    projectRoot: string;
+    proposal: DreamTargetProposal;
+    target: CanonicalTarget;
+    evidence: DreamEvidenceItem[];
+    files: ResolvedTargetFile[];
+}
+export interface DreamOptimizerOutput {
+    edits: CandidateEdit[];
+    rationale: string;
+    validationPlan?: string;
+    riskReport?: string;
+}
+export type DreamOptimizer = (input: DreamOptimizerInput) => Promise<DreamOptimizerOutput>;
+export interface DreamPolicyEditSynthesizerInput {
+    candidateId: string;
+    targetId: string;
+    acceptedBy: string;
+    proposalMd: string;
+    rationaleMd: string;
+    evalPlanMd: string;
+    riskReportMd: string;
+}
+export type DreamPolicyEditSynthesizer = (input: DreamPolicyEditSynthesizerInput) => Promise<DreamOptimizerOutput>;
+export type DreamPolicyUpdateOutcome = 'promoted' | 'refused-no-local-files' | 'refused-optimizer' | 'refused-static-gate' | 'error-runtime';
+export interface DreamPolicyUpdateResult {
+    candidateId: string;
+    targetId: string;
+    outcome: DreamPolicyUpdateOutcome;
+    promoted: boolean;
+    gatePassed: boolean;
+    promotedFiles: string[];
+    policyVersion: number | null;
+    reason?: string;
+    gate?: StaticGateResult;
+    applied?: PromotionApplyResult;
+}
 export interface DreamPreview {
     schemaVersion: typeof DREAM_RUN_SCHEMA_VERSION;
     mode: 'preview';
@@ -47,7 +88,7 @@ export interface DreamPreview {
     proposals: DreamTargetProposal[];
     safety: {
         createsNewSkills: false;
-        autoPromotes: false;
+        autoPromotes: boolean;
         directlyWritesPolicy: false;
         allowedTargetKinds: readonly CanonicalTargetKind[];
     };
@@ -57,6 +98,7 @@ export interface DreamRunManifest extends Omit<DreamPreview, 'mode'> {
     runId: string;
     runDir: string;
     candidateIds: string[];
+    policyUpdates?: DreamPolicyUpdateResult[];
 }
 export interface BuildDreamPreviewOptions {
     projectRoot: string;
@@ -66,6 +108,17 @@ export interface BuildDreamPreviewOptions {
 }
 export interface WriteDreamRunOptions extends BuildDreamPreviewOptions {
     preview?: DreamPreview;
+    applyPolicy?: boolean;
+    optimizer?: DreamOptimizer;
+    targetPolicy?: TargetEvolutionPolicy;
+}
+export interface RunAcceptedDreamPolicyUpdateOptions {
+    projectRoot: string;
+    candidateId: string;
+    acceptedBy: string;
+    synthesizeEdits?: DreamPolicyEditSynthesizer;
+    targetPolicy?: TargetEvolutionPolicy;
+    now?: () => Date;
 }
 export declare function resolveDreamRunsDir(projectRoot: string): string;
 export declare function resolveDreamRunDir(projectRoot: string, runId: string): string;
@@ -73,6 +126,7 @@ export declare function collectDreamEvidence(projectRoot: string): Promise<Dream
 export declare function buildDreamPreview(opts: BuildDreamPreviewOptions): Promise<DreamPreview>;
 export declare function writeDreamRun(opts: WriteDreamRunOptions): Promise<DreamRunManifest>;
 export declare function readDreamRun(projectRoot: string, runId: string): Promise<DreamRunManifest>;
+export declare function runAcceptedDreamPolicyUpdate(opts: RunAcceptedDreamPolicyUpdateOptions): Promise<DreamPolicyUpdateResult>;
 export declare function renderDreamPreview(preview: DreamPreview): string;
 export declare function renderDreamRun(manifest: DreamRunManifest): string;
 //# sourceMappingURL=dream.d.ts.map

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

@@ -1,13 +1,20 @@
 /**
  * Supervised Learning Dream: an offline, batch proposal lane for existing
  * self-evolution targets. Dream reads accumulated evidence and writes review
- * candidates. It never edits canonical files and never promotes.
+ * candidates by default. The explicit apply mode turns a Dream proposal into a
+ * concrete bounded edit, runs the normal static gate, and promotes through the
+ * existing candidate promotion channel.
  */
 import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
 import * as crypto from 'node:crypto';
 import { CANONICAL_TARGETS, lookupCanonicalTarget, } from './canonical-targets.js';
-import { generateCandidateId, resolveCandidateRepo, writeCandidatePackage, } from './candidates.js';
+import { EDITS_JSON_FILE, generateCandidateId, readCandidatePackage, resolveCandidateRepo, writeCandidatePackage, } from './candidates.js';
+import { renderUnifiedDiff, validateCandidateEdits, } from './edits-contract.js';
+import { resolveTargetLocalFiles, } from './local-targets.js';
+import { applyCandidatePromotion, } from './promote.js';
+import { runStaticCandidateGate, } from './candidate-gates.js';
+import { currentPolicyVersion } from './policy/policy-store.js';
 export const DREAM_RUN_SCHEMA_VERSION = 1;
 const DREAM_SUBDIR = path.join('.synergyspec-selfevolving', 'self-evolution', 'dream-runs');
 const DEFAULT_ALLOWED_TARGET_KINDS = Object.freeze([
@@ -64,6 +71,7 @@ export async function buildDreamPreview(opts) {
 export async function writeDreamRun(opts) {
     const now = opts.now ?? (() => new Date());
     const preview = opts.preview ?? (await buildDreamPreview(opts));
+    const applyPolicy = opts.applyPolicy === true;
     const createdAt = preview.createdAt || now().toISOString();
     const entropy = [
         createdAt,
@@ -79,21 +87,62 @@ export async function writeDreamRun(opts) {
     await fs.mkdir(tmpDir, { recursive: true });
     const candidateIds = [];
     const createdCandidateDirs = [];
+    const policyUpdates = [];
     const candidateRepo = resolveCandidateRepo(opts.projectRoot);
     try {
+        const evidence = applyPolicy ? await collectDreamEvidence(opts.projectRoot) : [];
+        const evidenceById = new Map(evidence.map((item) => [item.id, item]));
         for (const proposal of preview.proposals) {
             const candidateId = generateCandidateId({
                 now: new Date(createdAt),
                 entropy: `${runId}:${proposal.targetId}`,
             });
-            const pkg = buildDreamCandidatePackage({
-                candidateId,
-                createdAt,
-                proposal,
-            });
+            let pkg;
+            let update;
+            if (applyPolicy) {
+                const applied = await buildDreamApplyCandidatePackage({
+                    projectRoot: opts.projectRoot,
+                    candidateId,
+                    createdAt,
+                    proposal,
+                    evidence: proposal.evidenceIds
+                        .map((id) => evidenceById.get(id))
+                        .filter((item) => item !== undefined),
+                    optimizer: opts.optimizer ?? defaultDreamOptimizer,
+                });
+                pkg = applied.pkg;
+                update = {
+                    candidateId,
+                    targetId: proposal.targetId,
+                    outcome: applied.initialOutcome,
+                    promoted: false,
+                    gatePassed: false,
+                    promotedFiles: [],
+                    policyVersion: null,
+                    ...(applied.reason ? { reason: applied.reason } : {}),
+                };
+            }
+            else {
+                pkg = buildDreamCandidatePackage({
+                    candidateId,
+                    createdAt,
+                    proposal,
+                });
+            }
             const written = await writeCandidatePackage(candidateRepo, pkg);
             createdCandidateDirs.push(written.candidateDir);
             candidateIds.push(candidateId);
+            if (applyPolicy && update) {
+                if (pkg.edits && pkg.edits.length > 0) {
+                    update = await runDreamPolicyUpdate({
+                        repoRoot: opts.projectRoot,
+                        candidateId,
+                        targetId: proposal.targetId,
+                        targetPolicy: opts.targetPolicy,
+                    });
+                }
+                policyUpdates.push(update);
+            }
         }
         const manifest = {
             ...preview,
@@ -101,6 +150,11 @@ export async function writeDreamRun(opts) {
             runId,
             runDir,
             candidateIds,
+            safety: {
+                ...preview.safety,
+                autoPromotes: applyPolicy,
+            },
+            ...(applyPolicy ? { policyUpdates } : {}),
         };
         await fs.writeFile(path.join(tmpDir, 'dream-run.json'), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
         await fs.rename(tmpDir, runDir);
@@ -108,7 +162,9 @@ export async function writeDreamRun(opts) {
     }
     catch (err) {
         await fs.rm(tmpDir, { recursive: true, force: true });
-        await Promise.all(createdCandidateDirs.map((candidateDir) => fs.rm(candidateDir, { recursive: true, force: true })));
+        if (!applyPolicy) {
+            await Promise.all(createdCandidateDirs.map((candidateDir) => fs.rm(candidateDir, { recursive: true, force: true })));
+        }
         throw err;
     }
 }
@@ -117,6 +173,113 @@ export async function readDreamRun(projectRoot, runId) {
     const raw = await fs.readFile(path.join(runDir, 'dream-run.json'), 'utf8');
     return JSON.parse(raw);
 }
+export async function runAcceptedDreamPolicyUpdate(opts) {
+    const layout = resolveCandidateRepo(opts.projectRoot);
+    const pkg = await readCandidatePackage(layout, opts.candidateId);
+    const targetId = pkg.candidate.targetIds[0] ?? '(none)';
+    if (pkg.candidate.source !== 'dream-batch') {
+        return {
+            candidateId: opts.candidateId,
+            targetId,
+            outcome: 'error-runtime',
+            promoted: false,
+            gatePassed: false,
+            promotedFiles: [],
+            policyVersion: targetId === '(none)' ? null : await currentPolicyVersion(opts.projectRoot, targetId),
+            reason: `candidate source is ${pkg.candidate.source}, expected dream-batch`,
+        };
+    }
+    if (targetId === '(none)') {
+        return {
+            candidateId: opts.candidateId,
+            targetId,
+            outcome: 'error-runtime',
+            promoted: false,
+            gatePassed: false,
+            promotedFiles: [],
+            policyVersion: null,
+            reason: 'Dream candidate has no targetIds entry',
+        };
+    }
+    const target = lookupCanonicalTarget(targetId);
+    if (!target) {
+        return {
+            candidateId: opts.candidateId,
+            targetId,
+            outcome: 'error-runtime',
+            promoted: false,
+            gatePassed: false,
+            promotedFiles: [],
+            policyVersion: null,
+            reason: `Unknown canonical target: ${targetId}`,
+        };
+    }
+    const resolved = await resolveTargetLocalFiles(targetId, opts.projectRoot);
+    if (resolved.files.length === 0) {
+        return {
+            candidateId: opts.candidateId,
+            targetId,
+            outcome: 'refused-no-local-files',
+            promoted: false,
+            gatePassed: false,
+            promotedFiles: [],
+            policyVersion: await currentPolicyVersion(opts.projectRoot, targetId),
+            reason: `no local editable file for target ${targetId}`,
+        };
+    }
+    const synthesizeEdits = opts.synthesizeEdits ?? defaultAcceptedDreamPolicyEditSynthesizer(resolved.files);
+    let output;
+    try {
+        output = await synthesizeEdits({
+            candidateId: opts.candidateId,
+            targetId,
+            acceptedBy: opts.acceptedBy,
+            proposalMd: pkg.proposalMd,
+            rationaleMd: pkg.rationaleMd,
+            evalPlanMd: pkg.evalPlanMd,
+            riskReportMd: pkg.riskReportMd,
+        });
+    }
+    catch (err) {
+        return {
+            candidateId: opts.candidateId,
+            targetId,
+            outcome: 'refused-optimizer',
+            promoted: false,
+            gatePassed: false,
+            promotedFiles: [],
+            policyVersion: await currentPolicyVersion(opts.projectRoot, targetId),
+            reason: err instanceof Error ? err.message : String(err),
+        };
+    }
+    const prepared = prepareDreamEditsForPackage({
+        pkg,
+        targetId,
+        files: resolved.files,
+        output,
+        acceptedBy: opts.acceptedBy,
+        now: opts.now ?? (() => new Date()),
+    });
+    if ('reason' in prepared) {
+        return {
+            candidateId: opts.candidateId,
+            targetId,
+            outcome: 'refused-optimizer',
+            promoted: false,
+            gatePassed: false,
+            promotedFiles: [],
+            policyVersion: await currentPolicyVersion(opts.projectRoot, targetId),
+            reason: prepared.reason,
+        };
+    }
+    await rewriteDreamCandidatePackage(layout, prepared.pkg);
+    return runDreamPolicyUpdate({
+        repoRoot: opts.projectRoot,
+        candidateId: opts.candidateId,
+        targetId,
+        targetPolicy: opts.targetPolicy,
+    });
+}
 export function renderDreamPreview(preview) {
     const lines = [
         'Supervised Learning Dream preview',
@@ -145,7 +308,16 @@ export function renderDreamRun(manifest) {
     if (manifest.candidateIds.length === 0) {
         lines.push('No candidates were written.');
     }
-    lines.push('Next: review the proposal, author concrete bounded edits through the existing review channel, then run gate/promote or reject.');
+    if (manifest.policyUpdates && manifest.policyUpdates.length > 0) {
+        const promoted = manifest.policyUpdates.filter((update) => update.promoted);
+        lines.push(`Policy updates: ${promoted.length}/${manifest.policyUpdates.length} promoted`);
+        for (const update of manifest.policyUpdates) {
+            lines.push(`- ${update.candidateId}: ${update.outcome}${update.reason ? ` (${update.reason})` : ''}`);
+        }
+    }
+    else {
+        lines.push('Next: review the proposal, author concrete bounded edits through the existing review channel, then run gate/promote or reject.');
+    }
     return lines.join('\n');
 }
 function buildDreamCandidatePackage(args) {
@@ -217,6 +389,305 @@ function buildDreamCandidatePackage(args) {
         riskReportMd,
     };
 }
+async function buildDreamApplyCandidatePackage(args) {
+    const target = lookupCanonicalTarget(args.proposal.targetId);
+    if (!target) {
+        return {
+            pkg: buildDreamCandidatePackage(args),
+            initialOutcome: 'error-runtime',
+            reason: `Unknown canonical target: ${args.proposal.targetId}`,
+        };
+    }
+    const resolved = await resolveTargetLocalFiles(target.id, args.projectRoot);
+    if (resolved.files.length === 0) {
+        return {
+            pkg: buildDreamCandidatePackage(args),
+            initialOutcome: 'refused-no-local-files',
+            reason: `no local editable file for target ${target.id}`,
+        };
+    }
+    let optimized;
+    try {
+        optimized = await args.optimizer({
+            projectRoot: args.projectRoot,
+            proposal: args.proposal,
+            target,
+            evidence: args.evidence,
+            files: resolved.files,
+        });
+    }
+    catch (err) {
+        return {
+            pkg: buildDreamCandidatePackage(args),
+            initialOutcome: 'refused-optimizer',
+            reason: err instanceof Error ? err.message : String(err),
+        };
+    }
+    const basePkg = buildDreamCandidatePackage(args);
+    const prepared = prepareDreamEditsForPackage({
+        pkg: basePkg,
+        targetId: target.id,
+        files: resolved.files,
+        output: optimized,
+        acceptedBy: 'dream run --apply',
+        now: () => new Date(args.createdAt),
+    });
+    if ('reason' in prepared) {
+        return {
+            pkg: buildDreamCandidatePackage(args),
+            initialOutcome: 'refused-optimizer',
+            reason: prepared.reason,
+        };
+    }
+    return {
+        pkg: prepared.pkg,
+        initialOutcome: 'promoted',
+    };
+}
+async function runDreamPolicyUpdate(args) {
+    const layout = resolveCandidateRepo(args.repoRoot);
+    let gate;
+    try {
+        gate = await runStaticCandidateGate(layout, args.candidateId, {
+            applyTransition: true,
+            targetPolicy: args.targetPolicy,
+        });
+    }
+    catch (err) {
+        return {
+            candidateId: args.candidateId,
+            targetId: args.targetId,
+            outcome: 'error-runtime',
+            promoted: false,
+            gatePassed: false,
+            promotedFiles: [],
+            policyVersion: await currentPolicyVersion(args.repoRoot, args.targetId),
+            reason: `static gate error: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    if (!gate.passed) {
+        return {
+            candidateId: args.candidateId,
+            targetId: args.targetId,
+            outcome: 'refused-static-gate',
+            promoted: false,
+            gatePassed: false,
+            promotedFiles: [],
+            policyVersion: await currentPolicyVersion(args.repoRoot, args.targetId),
+            gate,
+            reason: gate.findings
+                .filter((finding) => finding.severity === 'error')
+                .map((finding) => finding.message)
+                .join('; ') || 'static gate failed',
+        };
+    }
+    try {
+        const applied = await applyCandidatePromotion(layout, args.candidateId, {
+            repoRoot: args.repoRoot,
+            policy: args.targetPolicy,
+        });
+        return {
+            candidateId: args.candidateId,
+            targetId: args.targetId,
+            outcome: 'promoted',
+            promoted: true,
+            gatePassed: true,
+            promotedFiles: applied.appliedFiles.map((file) => file.file),
+            policyVersion: await currentPolicyVersion(args.repoRoot, args.targetId),
+            gate,
+            applied,
+        };
+    }
+    catch (err) {
+        return {
+            candidateId: args.candidateId,
+            targetId: args.targetId,
+            outcome: 'error-runtime',
+            promoted: false,
+            gatePassed: true,
+            promotedFiles: [],
+            policyVersion: await currentPolicyVersion(args.repoRoot, args.targetId),
+            gate,
+            reason: `promotion error: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+}
+function prepareDreamEditsForPackage(args) {
+    let edits;
+    try {
+        edits = validateCandidateEdits(args.output.edits, args.files.map((file) => file.relPath));
+    }
+    catch (err) {
+        return { reason: err instanceof Error ? err.message : String(err) };
+    }
+    const currentByRel = new Map(args.files.map((file) => [file.relPath, file.content]));
+    const changed = edits.filter((edit) => edit.content !== currentByRel.get(edit.relPath));
+    if (changed.length === 0) {
+        return { reason: 'optimizer produced no byte-changing edits' };
+    }
+    const diffPatch = changed
+        .map((edit) => renderUnifiedDiff(edit.relPath, currentByRel.get(edit.relPath) ?? '', edit.content))
+        .join('\n');
+    const rationaleMd = [
+        '# Rationale',
+        '',
+        `Because ${args.acceptedBy} accepted the Dream optimizer brief, this bounded edit materializes the supervised batch-learning proposal for ${args.targetId}.`,
+        '',
+        args.output.rationale,
+        '',
+    ].join('\n');
+    return {
+        pkg: {
+            ...args.pkg,
+            candidate: {
+                ...args.pkg.candidate,
+                updatedAt: args.now().toISOString(),
+                changedFiles: changed.map((edit) => edit.relPath),
+                rollbackPlan: 'Use self-evolution promote --rollback for this candidate; promotion writes a rollback snapshot before changing policy files.',
+            },
+            diffPatch: `${diffPatch}\n`,
+            rationaleMd,
+            evalPlanMd: args.output.validationPlan ??
+                [
+                    '# Evaluation Plan',
+                    '',
+                    args.pkg.evalPlanMd,
+                    '',
+                    '- Static candidate gate must pass before promotion.',
+                    '- Held-out replay should cover the cited Dream evidence before relying on the update.',
+                    '',
+                ].join('\n'),
+            riskReportMd: args.output.riskReport ??
+                [
+                    '# Risk Report',
+                    '',
+                    args.pkg.riskReportMd,
+                    '',
+                    '- Dream apply mode promotes only through the existing candidate promotion channel.',
+                    '- Rollback metadata is written before any canonical policy file is changed.',
+                    '- New skill creation remains out of scope.',
+                    '',
+                ].join('\n'),
+            edits: changed,
+        },
+    };
+}
+async function rewriteDreamCandidatePackage(layout, pkg) {
+    const dir = path.join(layout.baseDir, pkg.candidate.id);
+    await Promise.all([
+        fs.writeFile(path.join(dir, 'candidate.json'), `${JSON.stringify(pkg.candidate, null, 2)}\n`, 'utf8'),
+        fs.writeFile(path.join(dir, 'proposal.md'), pkg.proposalMd, 'utf8'),
+        fs.writeFile(path.join(dir, 'diff.patch'), pkg.diffPatch, 'utf8'),
+        fs.writeFile(path.join(dir, 'rationale.md'), pkg.rationaleMd, 'utf8'),
+        fs.writeFile(path.join(dir, 'eval-plan.md'), pkg.evalPlanMd, 'utf8'),
+        fs.writeFile(path.join(dir, 'risk-report.md'), pkg.riskReportMd, 'utf8'),
+    ]);
+    if (pkg.edits && pkg.edits.length > 0) {
+        await fs.writeFile(path.join(dir, EDITS_JSON_FILE), `${JSON.stringify(pkg.edits, null, 2)}\n`, 'utf8');
+    }
+    else {
+        await fs.rm(path.join(dir, EDITS_JSON_FILE), { force: true });
+    }
+}
+function defaultAcceptedDreamPolicyEditSynthesizer(files) {
+    return async (input) => {
+        const file = files.find((candidate) => candidate.content.trim().length > 0) ?? files[0];
+        if (!file) {
+            return {
+                edits: [],
+                rationale: `Dream found no editable files for ${input.targetId}.`,
+            };
+        }
+        const note = renderDreamPolicyNote({
+            targetId: input.targetId,
+            evidenceIds: [],
+            expectedBenefit: `Accepted by ${input.acceptedBy}`,
+            validationPlan: 'Static gate plus held-out replay before relying on the updated policy.',
+        });
+        return {
+            edits: [{ relPath: file.relPath, content: applyDreamPolicyNote(file, note) }],
+            rationale: 'Accepted Dream optimizer brief; materialize it as one bounded policy-file update with rollback support.',
+        };
+    };
+}
+async function defaultDreamOptimizer(input) {
+    const file = input.files.find((candidate) => candidate.content.trim().length > 0) ?? input.files[0];
+    if (!file) {
+        return {
+            edits: [],
+            rationale: `Dream found no editable files for ${input.target.id}.`,
+        };
+    }
+    const evidenceIds = input.proposal.evidenceIds.slice(0, 6);
+    const note = renderDreamPolicyNote({
+        targetId: input.target.id,
+        evidenceIds,
+        expectedBenefit: input.proposal.expectedBenefit,
+        validationPlan: input.proposal.validationPlan,
+    });
+    const content = applyDreamPolicyNote(file, note);
+    return {
+        edits: [{ relPath: file.relPath, content }],
+        rationale: `Because ${input.target.id} repeatedly appears in accumulated Dream evidence, ` +
+            'the policy now carries a supervised batch-learning note that makes validation, held-out replay, and rollback expectations explicit for similar future work.',
+        validationPlan: [
+            '# Evaluation Plan',
+            '',
+            input.proposal.validationPlan,
+            '',
+            '- Static candidate gate must pass before promotion.',
+            '- Validate with tests or replay for the cited evidence before treating this policy update as reliable.',
+            '',
+        ].join('\n'),
+        riskReport: [
+            '# Risk Report',
+            '',
+            `Risk level: ${input.proposal.riskLevel}`,
+            '',
+            '- Uses existing policy target only; no new skill is created.',
+            '- Promotion writes rollback metadata before mutating local policy files.',
+            '- If held-out replay regresses, roll back this candidate promotion.',
+            '',
+        ].join('\n'),
+    };
+}
+function renderDreamPolicyNote(args) {
+    return [
+        '<!-- SS_SUPERVISED_DREAM_OPTIMIZER_START -->',
+        '**Supervised Dream Optimizer Note**',
+        '',
+        `- Target: ${args.targetId}`,
+        `- Evidence batch: ${args.evidenceIds.length > 0 ? args.evidenceIds.join(', ') : 'none'}`,
+        `- Expected benefit: ${args.expectedBenefit}`,
+        `- Validation: ${args.validationPlan}`,
+        '- Behavior: when similar friction appears, make the expected verification, recovery, and rollback check explicit before finishing the workflow.',
+        '<!-- SS_SUPERVISED_DREAM_OPTIMIZER_END -->',
+    ].join('\n');
+}
+function applyDreamPolicyNote(file, note) {
+    const current = file.content;
+    const replaceBlock = (text) => {
+        const blockRe = /<!-- SS_SUPERVISED_DREAM_OPTIMIZER_START -->[\s\S]*?<!-- SS_SUPERVISED_DREAM_OPTIMIZER_END -->/;
+        return blockRe.test(text)
+            ? text.replace(blockRe, note)
+            : `${text.replace(/\s*$/, '')}\n\n${note}\n`;
+    };
+    if (/\.ts$/.test(file.relPath)) {
+        const marker = 'const INSTRUCTIONS_BODY = `';
+        const start = current.indexOf(marker);
+        if (start >= 0) {
+            const bodyStart = start + marker.length;
+            const bodyEnd = current.indexOf('`;', bodyStart);
+            if (bodyEnd > bodyStart) {
+                const before = current.slice(0, bodyStart);
+                const body = current.slice(bodyStart, bodyEnd);
+                const after = current.slice(bodyEnd);
+                return `${before}${replaceBlock(body)}${after}`;
+            }
+        }
+    }
+    return replaceBlock(current);
+}
 function buildDreamProposals(evidence, targets, limit) {
     if (limit === 0 || evidence.length === 0)
         return [];

package/dist/core/self-evolution/episode-orchestrator.d.ts

@@ -196,6 +196,7 @@ export interface RunEpisodeOptions {
 }
 export interface RunEpisodeResult {
     episodeId: string;
+    harness?: AgentHarness;
     /** True when the CRITIC AGENT（基线智能体 baseline agent）arm was skipped. */
     baselineSkipped: boolean;
     /** advantage ＝ reward(主臂) − reward(基线臂); null when skipped or abstained. */
@@ -236,6 +237,7 @@ export interface ResumeEpisodeOptions {
 }
 export interface ResumeEpisodeResult {
     episodeId: string;
+    harness?: AgentHarness;
     /** The stage the episode was at when resume was called. */
     resumedFrom: EpisodeStage;
     /** The stage it reached after the resume re-ran the remaining steps. */