synergyspec-selfevolving 1.4.0 → 2.0.0

package/dist/commands/self-evolution-episode.js

@@ -0,0 +1,423 @@
+import * as path from 'node:path';
+import { 
+// Orchestrator (the three-agent episode runner).
+captureMainArm as captureMainArmImpl, runEpisode as runEpisodeImpl, resumeEpisode as resumeEpisodeImpl, 
+// 版本账本 ledger + 否决缓冲 reject-buffer (read-only views + manual rollback).
+readPolicyLedger, readRejectBuffer, currentPolicyVersion, rollbackPolicyVersion, appendRejectBufferEntry, 
+// Canonical target registry.
+lookupCanonicalTarget, listCanonicalTargets, DESIGN_ARTIFACT_TARGET_ID, } from '../core/self-evolution/index.js';
+import { generateLearnReport } from '../core/learn.js';
+import { validateExplicitTrajectoryHandle } from '../core/learn/trajectory-discovery.js';
+import { validateChangeExists } from './workflow/shared.js';
+/**
+ * The 主智能体 MAIN AGENT arm is graded from a learn report exactly the way the
+ * `learn` command grades it (the orchestrator REUSES that grading; it never
+ * re-runs the tests). The default target is the design artifact-template — the
+ * opinionated design-only evolution default — but any registered canonical
+ * target id is accepted via `--target`.
+ */
+const DEFAULT_EPISODE_TARGET = DESIGN_ARTIFACT_TARGET_ID;
+// ---------------------------------------------------------------------------
+// CLI registration
+// ---------------------------------------------------------------------------
+/**
+ * Attach the loop-v2 `episode` + `policy` subcommands to the parent
+ * `self-evolution` command. Called once from {@link registerSelfEvolutionCommand}.
+ */
+export function attachSelfEvolutionEpisodeCommands(parent) {
+    const episode = parent
+        .command('episode [change]')
+        .description('Run ONE loop-v2 episode (self-evolution as in-context RL) for a change: build the 主智能体 MAIN AGENT arm from the change\'s learn report, rerun the CRITIC AGENT（基线智能体 baseline agent）arm, score advantage with the 奖励智能体 REWARD AGENT, roll back the 策略 POLICY on a bad advantage, then let the 演进智能体 EVOLVING AGENT take ONE bounded edit.')
+        .option('--change <name>', 'the completed change to run the episode for (or positional)')
+        .option('--target <id>', `canonical target id to evolve (default ${DEFAULT_EPISODE_TARGET})`)
+        .option('--no-baseline', 'skip the CRITIC AGENT（基线智能体 baseline agent）arm for this episode')
+        .option('--transcript <path>', 'Explicit transcript .jsonl to grade (bypasses change-window discovery; Claude transcript store only)')
+        .option('--session-id <id>', 'Explicit Claude session id to grade (bypasses change-window discovery; Claude transcript store only)')
+        .option('--json', 'output the full RunEpisodeResult JSON')
+        .action(async (changeArg, options) => {
+        const changeName = options.change ?? changeArg;
+        const result = await runEpisodeCommand({
+            changeName,
+            target: options.target,
+            // commander sets `baseline` to false when --no-baseline is passed.
+            noBaseline: options.baseline === false,
+            transcript: options.transcript,
+            sessionId: options.sessionId,
+            json: options.json,
+        }, { repoRoot: process.cwd() });
+        process.exitCode = result.exitCode;
+    });
+    episode
+        .command('resume <episodeId>')
+        .description('Re-enter a partially-run loop-v2 episode at its recorded stage and idempotently finish the remaining steps (decision → 演进智能体 EVOLVING AGENT → close).')
+        .option('--json', 'output the full ResumeEpisodeResult JSON')
+        .action(async (episodeId, options) => {
+        const result = await runResumeEpisodeCommand({ episodeId, json: options.json }, { repoRoot: process.cwd() });
+        process.exitCode = result.exitCode;
+    });
+    const policy = parent
+        .command('policy')
+        .description('Inspect or manually roll back the 策略 POLICY lineage (版本账本 ledger + 否决缓冲 reject-buffer) for loop-v2 targets');
+    policy
+        .command('show')
+        .description('READ-ONLY: print the 版本账本 ledger (versions, actions, Δ stats, predictions) and the 否决缓冲 reject-buffer for the target(s). Replaces the read-only role of the trajectory command.')
+        .option('--target <id>', 'restrict to a single canonical target id (default: all registered targets with a lineage)')
+        .option('--json', 'output { targets: [{ targetId, head, ledger, rejectBuffer }] } JSON')
+        .action(async (options) => {
+        const result = await runPolicyShowCommand({ target: options.target, json: options.json }, { repoRoot: process.cwd() });
+        process.exitCode = result.exitCode;
+    });
+    policy
+        .command('rollback')
+        .description('Manual 策略 POLICY rollback: restore the previous version (recorded as a new monotonic head, git-revert style) and append a `human-reject` 否决缓冲 reject-buffer entry. Requires --yes.')
+        .requiredOption('--target <id>', 'the canonical target id whose lineage to roll back')
+        .option('--reason <text>', 'why the version is being rejected (recorded on the 否决缓冲 entry)')
+        .option('--yes', 'required: confirm the manual rollback')
+        .option('--json', 'output JSON')
+        .action(async (options) => {
+        const result = await runPolicyRollbackCommand({ target: options.target, reason: options.reason, yes: options.yes, json: options.json }, { repoRoot: process.cwd() });
+        process.exitCode = result.exitCode;
+    });
+}
+/**
+ * Programmatic entrypoint for `self-evolution episode`. Exported so tests can
+ * drive the full episode flow with an injected orchestrator seam (no real agent
+ * spawn).
+ */
+export async function runEpisodeCommand(args, opts) {
+    const stdout = opts.stdout ?? ((l) => console.log(l));
+    const stderr = opts.stderr ?? ((l) => console.error(l));
+    const generateReport = opts.generateReport ??
+        ((changeName) => generateLearnReport({ projectRoot: opts.repoRoot, changeName }));
+    const captureMainArm = opts.captureMainArm ?? captureMainArmImpl;
+    const runEpisode = opts.runEpisode ?? runEpisodeImpl;
+    const targetId = args.target ?? DEFAULT_EPISODE_TARGET;
+    // Validate the target up front so a typo fails loud (exit 1) rather than deep
+    // in the orchestrator with a bare lineage-init error.
+    if (!lookupCanonicalTarget(targetId)) {
+        return failEpisode(args.json, stdout, stderr, `Unknown canonical target: ${targetId}`);
+    }
+    // USER-TYPED handle flags fail LOUD on a miss (mirrors the learn /
+    // evolve-from-edits commands) BEFORE the env is mutated.
+    const handleError = await validateExplicitTrajectoryHandle({
+        projectRoot: opts.repoRoot,
+        transcriptPath: args.transcript,
+        sessionId: args.sessionId,
+    });
+    if (handleError) {
+        return failEpisode(args.json, stdout, stderr, handleError);
+    }
+    // The change must exist (active) so the orchestrator has a real changeDirPath.
+    let changeName;
+    try {
+        changeName = await validateChangeExists(args.changeName, opts.repoRoot);
+    }
+    catch (err) {
+        return failEpisode(args.json, stdout, stderr, err instanceof Error ? err.message : String(err));
+    }
+    const changeDirPath = path.join(opts.repoRoot, 'synergyspec-selfevolving', 'changes', changeName);
+    // Build the 主智能体 MAIN AGENT arm from the change's learn report (the SAME
+    // grading the `learn` command uses; the orchestrator never re-grades). The
+    // explicit trajectory handle reaches the discovery layer via env (kept in this
+    // action layer so the injected-generateReport test seam stays untouched).
+    const prevTranscriptEnv = process.env.SYNERGYSPEC_SELFEVOLVING_TRANSCRIPT;
+    const prevSessionEnv = process.env.SYNERGYSPEC_SELFEVOLVING_SESSION_ID;
+    if (args.transcript)
+        process.env.SYNERGYSPEC_SELFEVOLVING_TRANSCRIPT = args.transcript;
+    if (args.sessionId)
+        process.env.SYNERGYSPEC_SELFEVOLVING_SESSION_ID = args.sessionId;
+    let mainArm;
+    try {
+        const report = await generateReport(changeName);
+        mainArm = await captureMainArm({ repoRoot: opts.repoRoot, changeName, report });
+    }
+    catch (err) {
+        return failEpisode(args.json, stdout, stderr, `failed to build main arm for "${changeName}": ${err instanceof Error ? err.message : String(err)}`);
+    }
+    finally {
+        restoreEnv('SYNERGYSPEC_SELFEVOLVING_TRANSCRIPT', args.transcript, prevTranscriptEnv);
+        restoreEnv('SYNERGYSPEC_SELFEVOLVING_SESSION_ID', args.sessionId, prevSessionEnv);
+    }
+    // Run the episode. The CRITIC AGENT（基线智能体 baseline agent）arm is gated by
+    // the orchestrator's own shouldRunCriticAgent ledger read (it skips when the
+    // lineage has < 2 versions or last action refused), so the orchestrator owns
+    // the skip decision. `--no-baseline` is surfaced as `skipBaseline` on the
+    // options the command forwards to the (injectable) runEpisode seam so a caller
+    // can request the skip explicitly; the field is additive (the base
+    // RunEpisodeOptions ignores unknown keys), so this never alters the real
+    // orchestrator's behavior when it is unaware of the flag.
+    let outcome;
+    try {
+        const episodeOptions = {
+            repoRoot: opts.repoRoot,
+            targetId,
+            changeName,
+            changeDirPath,
+            mainArm,
+            ...(args.noBaseline ? { skipBaseline: true } : {}),
+        };
+        outcome = await runEpisode(episodeOptions);
+    }
+    catch (err) {
+        return failEpisode(args.json, stdout, stderr, err instanceof Error ? err.message : String(err));
+    }
+    if ('busy' in outcome && outcome.busy) {
+        if (args.json) {
+            stdout(JSON.stringify({ exitCode: 0, busy: outcome }, null, 2));
+        }
+        else {
+            stdout(`Episode not started for ${targetId}: ${outcome.reason}`);
+        }
+        return { exitCode: 0, busy: outcome };
+    }
+    const ran = outcome;
+    if (args.json) {
+        stdout(JSON.stringify({ exitCode: 0, result: ran }, null, 2));
+    }
+    else {
+        printEpisodeSummary(ran, targetId, changeName, stdout);
+    }
+    return { exitCode: 0, result: ran };
+}
+function printEpisodeSummary(result, targetId, changeName, stdout) {
+    stdout(`episode ${result.episodeId} (target ${targetId}, change ${changeName})`);
+    stdout(`  advantage: ${result.advantage === null ? 'n/a' : result.advantage.toFixed(3)} ` +
+        `(baseline arm ${result.baselineSkipped ? 'skipped' : 'rerun'})`);
+    stdout(`  decision: ${result.decision}`);
+    stdout(`  evolution: ${describeEvolution(result.evolution)}`);
+    stdout(`  new policy version: ${result.newPolicyVersion === null ? 'n/a' : `v${result.newPolicyVersion}`}`);
+}
+function describeEvolution(evolution) {
+    if (evolution === null)
+        return 'not spawned (no decision branch reached the 演进智能体 EVOLVING AGENT)';
+    switch (evolution.kind) {
+        case 'not-spawned':
+            return `not spawned (${evolution.reason})`;
+        case 'refused':
+            return `refused (${evolution.reason})`;
+        case 'evolved':
+            return `evolved → v${evolution.ledgerEntry.version}`;
+    }
+}
+function restoreEnv(name, applied, previous) {
+    if (!applied)
+        return;
+    if (previous === undefined)
+        delete process.env[name];
+    else
+        process.env[name] = previous;
+}
+function failEpisode(json, stdout, stderr, message) {
+    if (json) {
+        stdout(JSON.stringify({ exitCode: 1, error: message }, null, 2));
+    }
+    else {
+        stderr(`episode failed: ${message}`);
+    }
+    return { exitCode: 1, error: message };
+}
+/**
+ * Programmatic entrypoint for `self-evolution episode resume <id>`. Exported for
+ * tests; the orchestrator seam is injectable.
+ */
+export async function runResumeEpisodeCommand(args, opts) {
+    const stdout = opts.stdout ?? ((l) => console.log(l));
+    const stderr = opts.stderr ?? ((l) => console.error(l));
+    const resumeEpisode = opts.resumeEpisode ?? resumeEpisodeImpl;
+    let result;
+    try {
+        result = await resumeEpisode({ repoRoot: opts.repoRoot, episodeId: args.episodeId });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (args.json) {
+            stdout(JSON.stringify({ exitCode: 1, error: message }, null, 2));
+        }
+        else {
+            stderr(`episode resume failed: ${message}`);
+        }
+        return { exitCode: 1, error: message };
+    }
+    if (args.json) {
+        stdout(JSON.stringify({ exitCode: 0, result }, null, 2));
+    }
+    else {
+        stdout(`resumed episode ${result.episodeId}`);
+        stdout(`  from stage: ${result.resumedFrom}`);
+        stdout(`  now at stage: ${result.stage}`);
+        stdout(`  evolution: ${describeEvolution(result.evolution)}`);
+    }
+    return { exitCode: 0, result };
+}
+/**
+ * Programmatic entrypoint for `self-evolution policy show`. READ-ONLY: reads the
+ * 版本账本 ledger + 否决缓冲 reject-buffer for the target(s) and renders them.
+ * Never mutates anything.
+ */
+export async function runPolicyShowCommand(args, opts) {
+    const stdout = opts.stdout ?? ((l) => console.log(l));
+    const stderr = opts.stderr ?? ((l) => console.error(l));
+    // Resolve the target list. A named --target must be registered; otherwise show
+    // every registered canonical target (those with no lineage render head=null).
+    let targetIds;
+    if (args.target !== undefined) {
+        if (!lookupCanonicalTarget(args.target)) {
+            const message = `Unknown canonical target: ${args.target}`;
+            if (args.json)
+                stdout(JSON.stringify({ error: message }, null, 2));
+            else
+                stderr(message);
+            return { exitCode: 1, targets: [], error: message };
+        }
+        targetIds = [args.target];
+    }
+    else {
+        targetIds = listCanonicalTargets().map((t) => t.id);
+    }
+    const targets = [];
+    try {
+        for (const targetId of targetIds) {
+            const ledger = await readPolicyLedger(opts.repoRoot, targetId);
+            const rejectBuffer = await readRejectBuffer(opts.repoRoot, targetId);
+            const head = await currentPolicyVersion(opts.repoRoot, targetId);
+            // Skip targets with NEITHER a lineage NOR a reject-buffer when showing
+            // ALL targets (keep the default view focused on live lineages). A named
+            // --target is always shown, even when empty.
+            if (args.target === undefined && ledger.length === 0 && rejectBuffer.length === 0) {
+                continue;
+            }
+            targets.push({ targetId, head, ledger, rejectBuffer });
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (args.json)
+            stdout(JSON.stringify({ error: message }, null, 2));
+        else
+            stderr(`policy show failed: ${message}`);
+        return { exitCode: 1, targets: [], error: message };
+    }
+    if (args.json) {
+        stdout(JSON.stringify({ targets }, null, 2));
+        return { exitCode: 0, targets };
+    }
+    if (targets.length === 0) {
+        stdout('No policy lineage recorded yet.');
+        return { exitCode: 0, targets };
+    }
+    for (const view of targets) {
+        stdout(renderPolicyTargetView(view));
+    }
+    return { exitCode: 0, targets };
+}
+function renderPolicyTargetView(view) {
+    const lines = [];
+    lines.push(`# ${view.targetId} (head ${view.head === null ? 'uninitialized' : `v${view.head}`})`);
+    lines.push('## 版本账本 ledger');
+    if (view.ledger.length === 0) {
+        lines.push('- (no versions)');
+    }
+    else {
+        for (const entry of view.ledger) {
+            const delta = entry.deltaStats
+                ? ` Δ ${entry.deltaStats.filesChanged}f +${entry.deltaStats.linesAdded}/-${entry.deltaStats.linesRemoved}`
+                : '';
+            const prediction = entry.prediction
+                ? ` predicts ${entry.prediction.metric} ${entry.prediction.direction} by ${entry.prediction.checkBy}`
+                : '';
+            const advantage = entry.advantage !== undefined ? ` advantage=${entry.advantage.toFixed(3)}` : '';
+            const reason = entry.reason ? ` (${entry.reason})` : '';
+            lines.push(`- v${entry.version} ${entry.action} ${entry.at}${delta}${prediction}${advantage}${reason}`);
+        }
+    }
+    lines.push('## 否决缓冲 reject-buffer');
+    if (view.rejectBuffer.length === 0) {
+        lines.push('- (no rejections)');
+    }
+    else {
+        for (const entry of view.rejectBuffer) {
+            const advantage = entry.advantage === null ? 'n/a' : entry.advantage.toFixed(3);
+            const files = entry.editSummary.files.join(', ') || '(none)';
+            lines.push(`- ${entry.at} ${entry.reason} v${entry.fromVersion}→v${entry.toVersion} advantage=${advantage} files=[${files}]`);
+            if (entry.textualGradientTried) {
+                lines.push(`    gradient: ${entry.textualGradientTried.slice(0, 200)}`);
+            }
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Programmatic entrypoint for `self-evolution policy rollback`. Manually rolls
+ * the 策略 POLICY lineage back to the previous version (recorded as a NEW
+ * monotonic head, git-revert style) and appends a `human-reject` 否决缓冲
+ * reject-buffer entry so the next 演进智能体 EVOLVING AGENT step sees the rejected
+ * direction. Requires --yes.
+ */
+export async function runPolicyRollbackCommand(args, opts) {
+    const stdout = opts.stdout ?? ((l) => console.log(l));
+    const stderr = opts.stderr ?? ((l) => console.error(l));
+    const now = opts.now ?? (() => new Date());
+    const fail = (code, message) => {
+        if (args.json)
+            stdout(JSON.stringify({ exitCode: code, error: message }, null, 2));
+        else
+            stderr(`policy rollback failed: ${message}`);
+        return { exitCode: code, error: message };
+    };
+    if (!args.yes) {
+        return fail(2, '--yes is required: policy rollback restores the previous version of your local policy file(s).');
+    }
+    if (!lookupCanonicalTarget(args.target)) {
+        return fail(1, `Unknown canonical target: ${args.target}`);
+    }
+    const head = await currentPolicyVersion(opts.repoRoot, args.target);
+    if (head === null) {
+        return fail(1, `No policy lineage for ${args.target}; nothing to roll back.`);
+    }
+    if (head < 1) {
+        return fail(1, `Policy lineage for ${args.target} is at v0; there is no earlier version to roll back to.`);
+    }
+    const toVersion = head - 1;
+    const reason = (args.reason ?? '').trim() || 'human: manual rollback to the previous policy version';
+    let entry;
+    try {
+        // Restore the previous version (recorded as a new monotonic head). The manual
+        // rollback path has no per-arm advantage, so none is recorded on the ledger.
+        entry = await rollbackPolicyVersion({
+            repoRoot: opts.repoRoot,
+            targetId: args.target,
+            episodeId: `manual-rollback-${now().toISOString().replace(/[^0-9]/g, '').slice(0, 14)}`,
+            toVersion,
+        });
+        // Append the 否决缓冲 reject-buffer entry so the rejected direction stays as
+        // evidence (the rolled-back files themselves are 产物即弃).
+        await appendRejectBufferEntry(opts.repoRoot, {
+            schemaVersion: 1,
+            at: now().toISOString(),
+            episodeId: entry.episodeId ?? 'manual-rollback',
+            targetId: args.target,
+            // fromVersion = the version restored TO; toVersion = the rejected head.
+            fromVersion: toVersion,
+            toVersion: head,
+            advantage: null,
+            rewardMain: null,
+            rewardBaseline: null,
+            textualGradientTried: '',
+            editSummary: { files: [], linesAdded: 0, linesRemoved: 0, rationaleExcerpt: reason },
+            reason: 'human-reject',
+        });
+    }
+    catch (err) {
+        return fail(1, err instanceof Error ? err.message : String(err));
+    }
+    if (args.json) {
+        stdout(JSON.stringify({ exitCode: 0, entry, toVersion }, null, 2));
+    }
+    else {
+        stdout(`Rolled back ${args.target} to v${toVersion} (recorded as new head v${entry.version}).`);
+        stdout(`Recorded a human-reject 否决缓冲 reject-buffer entry: ${reason}`);
+        stdout('Restored your LOCAL policy file(s) — effective immediately, no rebuild/republish.');
+    }
+    return { exitCode: 0, entry, toVersion };
+}
+//# sourceMappingURL=self-evolution-episode.js.map

package/dist/commands/self-evolution.d.ts

@@ -1,5 +1,5 @@
 import { Command } from 'commander';
-import { type AggregationOptions, type CanonicalCandidate, type CanonicalCandidateSource, type CanonicalCandidateStatus, type PromotionReportArtifact, type StaticGateResult, type RankedCandidate, type RunChangeFn, type CandidateReplayScore, type PromotionApplyResult, type RollbackResult } from '../core/self-evolution/index.js';
+import { type AggregationOptions, type CanonicalCandidate, type CanonicalCandidateSource, type CanonicalCandidateStatus, type PromotionReportArtifact, type StaticGateResult, type PromotionApplyResult, type RollbackResult } from '../core/self-evolution/index.js';
 import { type LearnReport } from '../core/learn.js';
 export declare function registerSelfEvolutionCommand(program: Command): void;
 /**
@@ -41,34 +41,19 @@ export interface RunProposeCanonicalArgs {
     /** If true, emit JSON output. */
     json?: boolean;
     /**
-     * HEADLESS FALLBACK. When true (and `editsInput` is absent), spawn the
-     * canonical proposer agent to draft a real diff for each group's target
-     * (proposal-only) — for cron/CI runs with no host agent. Ignored when
-     * `editsInput` is present. When both are false/omitted, the candidate carries
-     * the placeholder diff and a human supplies the change before the gate.
-     */
-    agent?: boolean;
-    /**
-     * Population-based generation: draft N competing variant candidates (clamped
-     * 1-5; default 1) for the single surviving group, each on a distinct
-     * improvement angle, so the GA outer loop (`evolve`) can select the best.
-     * Requires `agent` (divergence is prompt-side; the host `--from-edits` path
-     * carries one payload). Ignored/treated as 1 otherwise.
-     */
-    variants?: number;
-    /**
-     * HOST-AGENT path (preferred). Candidate edits the host code agent already
-     * authored. When present, the CLI validates + packages these (frozen + target
-     * scope) instead of spawning the proposer agent, and `agent` is ignored.
+     * HOST-AGENT path. Candidate edits the host code agent already authored. When
+     * present, the CLI validates + packages these (frozen + target scope).
      * Requires exactly one surviving hint group (narrow via --target /
-     * --threshold-key) so the single payload is not misattributed.
+     * --threshold-key) so the single payload is not misattributed. When absent the
+     * candidate carries the placeholder diff and a human supplies the change
+     * before the gate.
      */
     editsInput?: HostEditsInput;
     /**
      * Aggregation thresholds. Self-evolution is gradient descent: ONE forward
      * pass (a change's trajectory + pass-rate) is a complete loss signal, so
-     * auto-evolve passes single-change thresholds (all min-occurrences = 1, no
-     * diversity requirement) to act on one change. Omitted → conservative
+     * the host evolve-from-edits path passes single-change thresholds (all
+     * min-occurrences = 1, no diversity requirement) to act on one change. Omitted → conservative
      * cross-change defaults (recurrence required).
      */
     aggregationOptions?: AggregationOptions;
@@ -76,10 +61,6 @@ export interface RunProposeCanonicalArgs {
 export interface RunProposeCanonicalOptions {
     /** Project root used to resolve the candidate base dir. */
     repoRoot: string;
-    /** Test seam: spawn used by the proposer agent (defaults to node's spawn). */
-    proposerSpawn?: typeof import('node:child_process').spawn;
-    /** Test seam: proposer agent binary override. */
-    proposerBinary?: string;
     /** Override for stdout (defaults to console.log). */
     stdout?: (line: string) => void;
     /** Override for stderr (defaults to console.error). */
@@ -124,9 +105,8 @@ export declare function parseHostEditsInput(raw: string): HostEditsInput;
  *
  * SAFETY:
  *   - Never writes outside `<repoRoot>/.synergyspec-selfevolving/self-evolution/candidates/`.
- *   - Generation is EITHER the host-agent `--from-edits` path (validate + package)
- *     OR the headless `--agent` proposer fallback; without either, diff.patch is
- *     the placeholder for a human to complete.
+ *   - Generation is the host-agent `--from-edits` path (validate + package); when
+ *     absent, diff.patch is the placeholder for a human to complete.
  */
 export declare function runProposeCanonical(args: RunProposeCanonicalArgs, opts: RunProposeCanonicalOptions): Promise<RunProposeCanonicalResult>;
 export interface RunPromoteArgs {
@@ -146,7 +126,7 @@ export interface RunPromoteResult {
 }
 /**
  * Programmatic entrypoint for `self-evolution promote <id>` — the close-the-loop
- * apply/rollback. Exported so tests + auto-evolve can drive it directly.
+ * apply/rollback. Exported so tests + the host evolve-from-edits path can drive it directly.
  */
 export declare function runPromoteCommand(args: RunPromoteArgs, opts: {
     repoRoot: string;
@@ -175,95 +155,6 @@ export declare function runRejectCommand(args: RunRejectArgs, opts: {
     stderr?: (l: string) => void;
     now?: () => Date;
 }): Promise<RunRejectResult>;
-export interface RunTrajectoryArgs {
-    targetId: string;
-    /** Cap the number of prior candidates shown (default in buildOptimizationTrajectory: 6). */
-    maxEntries?: number;
-    json?: boolean;
-}
-export interface RunTrajectoryResult {
-    exitCode: number;
-    error?: string;
-}
-/**
- * Programmatic entrypoint for `self-evolution trajectory <targetId>` — a
- * READ-ONLY view of the scored optimization-trajectory block the headless
- * proposer receives, so a HOST code agent (which authors edits via
- * `--from-edits` and never sees that prompt) can read the same prior-candidate
- * loss/verdict history before authoring. Reuses the exact builder/renderer the
- * proposer uses. Never mutates anything.
- */
-export declare function runTrajectoryCommand(args: RunTrajectoryArgs, opts: {
-    repoRoot: string;
-    stdout?: (l: string) => void;
-    stderr?: (l: string) => void;
-}): Promise<RunTrajectoryResult>;
-export interface RunAutoEvolveArgs {
-    /**
-     * One or more completed changes to learn from and evolve. A SINGLE change is
-     * enough; pass several to let a signal recurring across them be the trigger.
-     */
-    changeNames: string[];
-    /** Default true; false (via --no-auto) runs the pipeline but stops before applying. */
-    auto?: boolean;
-    requireProven?: boolean;
-    /**
-     * Minimum occurrences a signal must reach to be proposed. Default 1 — so a
-     * single change CAN evolve. Raise it (and pass several `changeNames`) to
-     * require a signal to RECUR across changes before it evolves. Neither
-     * single-change nor multi-change is mandatory.
-     */
-    minOccurrences?: number;
-    /** Force-propose only the aggregated signal with this exact thresholdKey. */
-    thresholdKey?: string;
-    evolveTarget?: string;
-    freezeTarget?: string;
-    json?: boolean;
-}
-export interface RunAutoEvolveOptions {
-    repoRoot: string;
-    stdout?: (l: string) => void;
-    stderr?: (l: string) => void;
-    now?: () => Date;
-    /** Injected for tests; forwarded to the proposer agent. */
-    proposerSpawn?: typeof import('node:child_process').spawn;
-    proposerBinary?: string;
-}
-export interface AutoEvolveReport {
-    exitCode: number;
-    changeNames: string[];
-    /** Mean per-change loss (functional ⊕ health) from learn; null when unmeasurable. */
-    loss: number | null;
-    /** Mean RAW code-health penalty across the change(s); null when no health signal. */
-    healthPenalty?: number | null;
-    hintCount: number;
-    hintsPaths: string[];
-    proposed: string[];
-    gated: {
-        candidateId: string;
-        passed: boolean;
-    }[];
-    promoted: {
-        candidateId: string;
-        targetIds: string[];
-        files: string[];
-    }[];
-    skipped: {
-        candidateId: string;
-        reason: string;
-    }[];
-    error?: string;
-}
-/**
- * ONE-BUTTON auto-evolve: learn → hints → propose(--agent) → gate → promote, in
- * one motion. Auto-applies the gate-passing winner per target onto the canonical
- * template (no per-change human approval), honoring the per-target switch + the
- * oracle/gate freeze, and snapshotting every write for rollback.
- *
- * Exported + fully injectable (proposer spawn, clock, io) so it is unit-testable
- * without a real `claude` binary.
- */
-export declare function runAutoEvolve(args: RunAutoEvolveArgs, opts: RunAutoEvolveOptions): Promise<AutoEvolveReport>;
 export interface RunEvolveFromEditsArgs {
     /** The change's learn hints.json to aggregate into a single signal/target. */
     fromLearn: string;
@@ -285,7 +176,7 @@ export interface RunEvolveFromEditsArgs {
     requireProven?: boolean;
     /** Mutually exclusive with this host path; presence is a hard error. */
     agent?: boolean;
-    /** Non-interactive confirmation; required to run (like auto-evolve). */
+    /** Non-interactive confirmation; required to run (one-button host-authored apply). */
     yes?: boolean;
     json?: boolean;
 }
@@ -402,73 +293,4 @@ export interface RunPromotionReportResult {
  * - Exit code 0 on success, non-zero when the candidate cannot be loaded.
  */
 export declare function runPromotionReportCommand(args: RunPromotionReportArgs, opts: RunPromotionReportOptions): Promise<RunPromotionReportResult>;
-export interface RunEvolveOuterLoopArgs {
-    /** Restrict the loop to a single canonical target id. */
-    target?: string;
-    /** Replay a corpus to score candidates (requires `changeIds`). */
-    replay?: boolean;
-    /** The replay corpus (change ids). Only used when `replay` is true. */
-    changeIds?: string[];
-    /** Write a human-gated promotion-report.md for each selected best. */
-    write?: boolean;
-    /**
-     * Mark proven sibling variants that lost the ranking to `best` (same
-     * variantGroup, higher meanLoss) with verdict `outcompeted`, so the
-     * optimization-trajectory block shows them as negative examples. Never
-     * transitions status (rejected is human-owned); advisory metadata only.
-     */
-    markOutcompeted?: boolean;
-    /** Per-target evolution policy overrides (supports all/none). */
-    evolveTarget?: string;
-    freezeTarget?: string;
-    json?: boolean;
-    /**
-     * ISO-8601 timestamp stamped onto appended fitness records. Defaults to the
-     * current time; supplied explicitly by tests for determinism.
-     */
-    at?: string;
-    /**
-     * Injected replay re-runner (see {@link makeReplayRunChange}). Defaults to a
-     * live agent shell-out; tests pass a fake to drive the loop without an agent.
-     */
-    runChange?: RunChangeFn;
-}
-export interface RunEvolveOuterLoopOptions {
-    repoRoot: string;
-    stdout?: (line: string) => void;
-    stderr?: (line: string) => void;
-}
-export interface TargetEvolveSummary {
-    targetId: string;
-    candidateIds: string[];
-    /** Skipped because the per-target policy froze this target. */
-    frozen: boolean;
-    /** Replay scoring outcomes (only present in --replay mode). */
-    scored?: CandidateReplayScore[];
-    /** Candidates ranked best-first by accumulated fitness. */
-    ranked: RankedCandidate[];
-    /** The selected best candidate id, or null when there are no candidates. */
-    best: string | null;
-    /** Path to the promotion report written for `best` (only with --write). */
-    promotionReportPath?: string;
-    /** Sibling variants marked `outcompeted` this run (only with --mark-outcompeted). */
-    outcompeted?: string[];
-}
-export interface RunEvolveOuterLoopResult {
-    exitCode: number;
-    targets: TargetEvolveSummary[];
-    error?: string;
-}
-/**
- * Programmatic entrypoint for `self-evolution evolve` — the GA outer loop.
- *
- * Chains the previously-inert pieces into one live pass:
- *   groupCandidatesByTarget → (optional replay scoring that APPENDS fitness)
- *   → rankCandidatesForTarget → select best → human-gated promotion report.
- *
- * Invariants: frozen targets (per the resolved policy) are skipped; promotion
- * is NEVER applied here (the report keeps its human-review gate); the oracle is
- * never touched (replay only runs tests).
- */
-export declare function runEvolveOuterLoopCommand(args: RunEvolveOuterLoopArgs, opts: RunEvolveOuterLoopOptions): Promise<RunEvolveOuterLoopResult>;
 //# sourceMappingURL=self-evolution.d.ts.map