synergyspec-selfevolving 2.1.4 → 2.1.6

package/dist/commands/config.js

@@ -51,6 +51,10 @@ const WORKFLOW_PROMPT_META = {
         name: 'Learn from change',
         description: 'Review verified work and capture reusable lessons',
     },
+    dream: {
+        name: 'Dream proposals',
+        description: 'Batch-mine completed evidence into proposal-only SS optimizer briefs',
+    },
     'verify-spec': {
         name: 'Verify spec traceability',
         description: 'Audit and fix use case traceability across all artifacts',

package/dist/commands/learn.js

@@ -4,10 +4,10 @@ import { detectFrozenHealthRoutingObservations, detectUnbindableHintObservations
 import { readProjectConfig } from '../core/project-config.js';
 import { assembleTrajectoryContext, } from '../core/learn/trajectory-assembler.js';
 import { findTranscriptsForChange, resolveChangeDir, validateExplicitTrajectoryHandle, } from '../core/learn/trajectory-discovery.js';
-import { getTrajectoryForChange } from '../core/trajectory/registry.js';
+import { getTrajectoryResultForChange } from '../core/trajectory/registry.js';
 import { toTrajectoryFacts, describeRunnerResults, extractExpectedTestPaths } from '../core/trajectory/facts.js';
 import { toActionSkeleton } from '../core/trajectory/skeleton.js';
-import { resolveHostHarness, resolveHostHarnessForRepo } from '../core/self-evolution/host-harness.js';
+import { resolveHostHarness, resolveHostHarnessDetailsForRepo, persistHostHarness, seedHostHarnessForRepo, } from '../core/self-evolution/host-harness.js';
 import { mineSuccessSignals } from '../core/self-evolution/success-channel.js';
 import { captureMainArm, runEpisode, } from '../core/self-evolution/episode-orchestrator.js';
 import { buildLLMSummaryCandidates, ingestLearnHandoff, } from '../core/learn/llm-summary.js';
@@ -15,6 +15,13 @@ function collect(value, previous) {
     previous.push(value);
     return previous;
 }
+function parseAgentHarness(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === 'claude' || value === 'codex' || value === 'opencode')
+        return value;
+    throw new Error(`Invalid harness '${value}'. Expected one of: claude, codex, opencode`);
+}
 export function registerLearnCommand(program, deps = {}) {
     const runEpisodeImpl = deps.runEpisode ?? runEpisode;
     const learnCmd = program
@@ -31,25 +38,32 @@ export function registerLearnCommand(program, deps = {}) {
         .option('--no-focus', 'Disable the evolution-focus switch for this run: when the policy is frozen-by-default, frozen-kind signals are dropped silently instead of being re-aimed at the explicitly evolvable target(s) as a policy-focus hint (config: selfEvolution.focus)')
         .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('--harness <name>', 'Force the observed-run/code-agent harness (claude|codex|opencode)')
+        .option('--rerun', 'Force a new loop-v2 episode instead of reusing a completed matching episode')
+        .option('--force-new-episode', 'Alias for --rerun')
         .option('--json', 'Output as JSON')
         .option('--no-interactive', 'Disable interactive prompts (learn is non-interactive by default)')
         .action(async (change, options) => {
         try {
             const projectRoot = process.cwd();
-            // SEED the host harness for the env-less episode subagent. learn runs at
-            // HOST level, where the OPENCODE_*/CODEX_* env that distinguishes the
-            // host harness IS present; the downstream loop-v2 episode (and its
-            // reward/evolving agent spawns) can run in an env-less Task subagent that
-            // would otherwise default to the 'claude' binary. resolveHostHarnessForRepo
-            // self-persists the confidently-resolved harness to
-            // `.synergyspec-selfevolving/host-harness.json`, so the subagent reads it
-            // back instead of guessing. Best-effort: a persistence failure must never
-            // fail the learn run (a missing seed only degrades to today's behavior).
+            const forcedHarness = parseAgentHarness(options.harness);
+            let reportHarness = forcedHarness;
+            // Resolve the report harness without writing the repo sidecar. Preview
+            // and diagnostic learn runs are read-only: a weak ambient CODEX_*/
+            // OPENCODE_* signal must not be promoted into durable provenance before
+            // we know an episode will actually spawn.
             try {
-                await resolveHostHarnessForRepo(projectRoot);
+                if (!forcedHarness) {
+                    const resolution = await resolveHostHarnessDetailsForRepo(projectRoot);
+                    if (resolution.source === 'override' ||
+                        resolution.source === 'env' ||
+                        resolution.source === 'persisted') {
+                        reportHarness = resolution.harness;
+                    }
+                }
             }
             catch {
-                // best-effort seed only.
+                // best-effort read only.
             }
             // USER-TYPED handle flags are validated up front and fail LOUD
             // (exit 1) on a miss — unlike the env-var channel, which keeps the
@@ -68,8 +82,11 @@ export function registerLearnCommand(program, deps = {}) {
             // (same set/restore shape as debug-trajectory's --harness) so it
             // reaches the registry adapter inside generateLearnReport without
             // changing any core signature. Restored as soon as the report exists.
+            const prevHarnessEnv = process.env.SYNERGYSPEC_SELFEVOLVING_HOST_HARNESS;
             const prevTranscriptEnv = process.env.SYNERGYSPEC_SELFEVOLVING_TRANSCRIPT;
             const prevSessionEnv = process.env.SYNERGYSPEC_SELFEVOLVING_SESSION_ID;
+            if (reportHarness)
+                process.env.SYNERGYSPEC_SELFEVOLVING_HOST_HARNESS = reportHarness;
             if (options.transcript)
                 process.env.SYNERGYSPEC_SELFEVOLVING_TRANSCRIPT = options.transcript;
             if (options.sessionId)
@@ -79,6 +96,14 @@ export function registerLearnCommand(program, deps = {}) {
                 report = await generateLearnReport({ projectRoot, changeName: change });
             }
             finally {
+                if (reportHarness) {
+                    if (prevHarnessEnv === undefined) {
+                        delete process.env.SYNERGYSPEC_SELFEVOLVING_HOST_HARNESS;
+                    }
+                    else {
+                        process.env.SYNERGYSPEC_SELFEVOLVING_HOST_HARNESS = prevHarnessEnv;
+                    }
+                }
                 if (options.transcript) {
                     if (prevTranscriptEnv === undefined) {
                         delete process.env.SYNERGYSPEC_SELFEVOLVING_TRANSCRIPT;
@@ -198,18 +223,19 @@ export function registerLearnCommand(program, deps = {}) {
                 // orderSwap / tamperCheck / divergenceCheck). Omitted ⇒ the orchestrator's
                 // single-sample, divergence-routing default (no extra spawns).
                 const episodeConfig = readProjectConfig(projectRoot);
-                // Pass the host-resolved harness EXPLICITLY into the in-process episode
-                // (learn runs host-level where the harness is confidently resolvable),
-                // so the orchestrator's reward/evolving agent spawns never fall back to
-                // the default 'claude' binary on a non-claude host.
-                const harness = await resolveHostHarnessForRepo(projectRoot);
+                // Pass the host-resolved harness EXPLICITLY only when the resolver has
+                // a real host signal. A silent default must remain "unknown" rather
+                // than being laundered into a concrete Claude provenance value.
+                const harness = forcedHarness
+                    ? (await persistHostHarness(projectRoot, forcedHarness), forcedHarness)
+                    : await seedHostHarnessForRepo(projectRoot).then((resolution) => resolution.source === 'default' ? undefined : resolution.harness);
                 episodeOutcome = await runEpisodeImpl({
                     repoRoot: projectRoot,
                     targetId: concreteEvolveTarget.targetId,
                     changeName: report.changeName,
                     changeDirPath: report.changeDir,
                     mainArm,
-                    harness,
+                    ...(harness ? { harness } : {}),
                     ...(episodeConfig?.selfEvolution?.reward
                         ? { reward: episodeConfig.selfEvolution.reward }
                         : {}),
@@ -218,6 +244,9 @@ export function registerLearnCommand(program, deps = {}) {
                     ...(episodeConfig?.selfEvolution?.agentTimeoutMs !== undefined
                         ? { agentTimeoutMs: episodeConfig.selfEvolution.agentTimeoutMs }
                         : {}),
+                    ...(options.rerun === true || options.forceNewEpisode === true
+                        ? { forceNewEpisode: true }
+                        : {}),
                 });
             }
             if (options.json) {
@@ -261,6 +290,23 @@ export function registerLearnCommand(program, deps = {}) {
         // handle is honored either way.
         const opts = command.optsWithGlobals();
         try {
+            const forcedHarness = parseAgentHarness(opts.harness);
+            let debugHarness = forcedHarness;
+            let debugHarnessSource = forcedHarness ? 'override' : null;
+            try {
+                if (!forcedHarness) {
+                    const resolution = await resolveHostHarnessDetailsForRepo(projectRoot);
+                    debugHarnessSource = resolution.source;
+                    if (resolution.source === 'override' ||
+                        resolution.source === 'env' ||
+                        resolution.source === 'persisted') {
+                        debugHarness = resolution.harness;
+                    }
+                }
+            }
+            catch {
+                // best-effort read only; the adapter block below will surface any miss.
+            }
             const discovered = await findTranscriptsForChange(change, projectRoot, {
                 transcriptPath: opts.transcript,
                 sessionId: opts.sessionId,
@@ -290,8 +336,8 @@ export function registerLearnCommand(program, deps = {}) {
             const prevHarnessEnv = process.env.SYNERGYSPEC_SELFEVOLVING_HOST_HARNESS;
             const prevTranscriptEnv = process.env.SYNERGYSPEC_SELFEVOLVING_TRANSCRIPT;
             const prevSessionEnv = process.env.SYNERGYSPEC_SELFEVOLVING_SESSION_ID;
-            if (opts.harness)
-                process.env.SYNERGYSPEC_SELFEVOLVING_HOST_HARNESS = opts.harness;
+            if (debugHarness)
+                process.env.SYNERGYSPEC_SELFEVOLVING_HOST_HARNESS = debugHarness;
             // The explicit trajectory handle must reach the adapter's own discovery
             // call too (env is the only channel through the registry), so the
             // introspected payload reflects the same override as `discovery` above.
@@ -300,7 +346,8 @@ export function registerLearnCommand(program, deps = {}) {
             if (opts.sessionId)
                 process.env.SYNERGYSPEC_SELFEVOLVING_SESSION_ID = opts.sessionId;
             try {
-                const adapterTrajectory = await getTrajectoryForChange(projectRoot, change);
+                const adapterResult = await getTrajectoryResultForChange(projectRoot, change);
+                const adapterTrajectory = adapterResult.trajectory;
                 // Change-scope guard input so debug-trajectory's facts + per-runner
                 // detail reflect the same scope demotion the loop uses (surfaces a
                 // green-but-out-of-scope graded run instead of hiding it).
@@ -309,6 +356,9 @@ export function registerLearnCommand(program, deps = {}) {
                     .catch(() => undefined));
                 payload.adapter = {
                     resolvedHarness: resolveHostHarness(),
+                    resolvedHarnessSource: debugHarnessSource,
+                    sourceHarness: adapterResult.sourceHarness,
+                    reason: adapterResult.reason ?? null,
                     sessionId: adapterTrajectory?.sessionId ?? null,
                     turns: adapterTrajectory?.turns.length ?? 0,
                     sourcePaths: adapterTrajectory ? [...new Set(adapterTrajectory.sourcePaths)] : [],
@@ -324,7 +374,7 @@ export function registerLearnCommand(program, deps = {}) {
                 };
             }
             finally {
-                if (opts.harness) {
+                if (debugHarness) {
                     if (prevHarnessEnv === undefined) {
                         delete process.env.SYNERGYSPEC_SELFEVOLVING_HOST_HARNESS;
                     }
@@ -625,6 +675,7 @@ function printJson(report, applied, evolutionPreview, hintsPath, episodeOutcome)
             ? { busy: true, reason: episodeOutcome.reason }
             : {
                 episodeId: episodeOutcome.episodeId,
+                ...(episodeOutcome.harness ? { harness: episodeOutcome.harness } : {}),
                 baselineSkipped: episodeOutcome.baselineSkipped,
                 advantage: episodeOutcome.advantage,
                 decision: episodeOutcome.decision,
@@ -876,7 +927,8 @@ function renderLearnTransparency(report, applied, evolutionPreview, hintsPath, o
 }
 /**
  * The loop-v2 autonomous entrance command (CS6-F):
- * `self-evolution episode --change "<name>" [--target <id>] [--session-id <id>]`.
+ * `self-evolution episode --change "<name>" [--target <id>] [--harness <h>]
+ * [--session-id <id>]`.
  * Replaces the GA `auto-evolve` / autonomous `evolve-from-edits` suggestions as
  * the loop-v2 path. The `--target` pin is included only when a concrete target
  * id resolved; `--session-id` is threaded through when the operator pinned an
@@ -886,8 +938,12 @@ function renderEpisodeCommand(changeName, targetId, options) {
     const parts = [`synergyspec-selfevolving self-evolution episode --change "${changeName}"`];
     if (targetId)
         parts.push(`--target ${targetId}`);
+    if (options.harness)
+        parts.push(`--harness ${options.harness}`);
     if (options.sessionId)
         parts.push(`--session-id ${options.sessionId}`);
+    if (options.rerun === true || options.forceNewEpisode === true)
+        parts.push('--rerun');
     return parts.join(' ');
 }
 /** The loop-v2 next-step line shown when a concrete target is pinned. */

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

@@ -0,0 +1,54 @@
+import { Command } from 'commander';
+import { type DreamPolicyEditSynthesizer, type DreamPolicyUpdateResult, type DreamPreview, type DreamRunManifest } from '../core/self-evolution/index.js';
+export declare function attachSelfEvolutionDreamCommands(parent: Command): void;
+export interface RunDreamPreviewArgs {
+    target?: string;
+    limit?: number;
+    json?: boolean;
+}
+export interface RunDreamCommandOptions {
+    repoRoot: string;
+    stdout?: (line: string) => void;
+    stderr?: (line: string) => void;
+    now?: () => Date;
+    synthesizeEdits?: DreamPolicyEditSynthesizer;
+}
+export interface RunDreamPreviewResult {
+    exitCode: number;
+    preview?: DreamPreview;
+    error?: string;
+}
+export declare function runDreamPreviewCommand(args: RunDreamPreviewArgs, opts: RunDreamCommandOptions): Promise<RunDreamPreviewResult>;
+export interface RunDreamRunArgs extends RunDreamPreviewArgs {
+    applyPolicy?: boolean;
+    yes?: boolean;
+}
+export interface RunDreamRunResult {
+    exitCode: number;
+    manifest?: DreamRunManifest;
+    error?: string;
+}
+export declare function runDreamRunCommand(args: RunDreamRunArgs, opts: RunDreamCommandOptions): Promise<RunDreamRunResult>;
+export interface RunDreamPolicyUpdateArgs {
+    candidateId: string;
+    acceptedBy?: string;
+    yes?: boolean;
+    json?: boolean;
+}
+export interface RunDreamPolicyUpdateResult extends DreamPolicyUpdateResult {
+    exitCode: number;
+    error?: string;
+}
+export declare function runDreamPolicyUpdateCommand(args: RunDreamPolicyUpdateArgs, opts: RunDreamCommandOptions): Promise<RunDreamPolicyUpdateResult>;
+export interface RunDreamShowArgs {
+    runId?: string;
+    json?: boolean;
+}
+export interface RunDreamShowResult {
+    exitCode: number;
+    manifest?: DreamRunManifest;
+    error?: string;
+}
+export declare function runDreamShowCommand(args: RunDreamShowArgs, opts: RunDreamCommandOptions): Promise<RunDreamShowResult>;
+export declare function parseDreamLimitOption(value: string): number;
+//# sourceMappingURL=self-evolution-dream.d.ts.map

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

@@ -0,0 +1,265 @@
+/**
+ * Offline Supervised Learning Dream commands.
+ *
+ * Dream reads accumulated evidence and writes review candidates by default.
+ * Explicit accepted-candidate paths can synthesize bounded edits, run the
+ * static gate, and promote through the existing ledger/rollback channel.
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import { buildDreamPreview, readDreamRun, renderDreamPreview, renderDreamRun, resolveDreamRunsDir, runAcceptedDreamPolicyUpdate, writeDreamRun, } from '../core/self-evolution/index.js';
+export function attachSelfEvolutionDreamCommands(parent) {
+    const dream = parent
+        .command('dream')
+        .description('Offline Supervised Learning Dream: batch-mine evidence into candidates and apply accepted policy updates');
+    dream
+        .command('preview')
+        .description('Preview Dream batch proposals without writing candidates or policy files')
+        .option('--target <id>', 'restrict Dream to one existing canonical target')
+        .option('--limit <n>', 'maximum number of Dream proposals to show', parseDreamLimitOption, 3)
+        .option('--json', 'output JSON')
+        .action(async (options) => {
+        const result = await runDreamPreviewCommand({
+            target: options.target,
+            limit: options.limit,
+            json: options.json,
+        }, { repoRoot: process.cwd() });
+        process.exitCode = result.exitCode;
+    });
+    dream
+        .command('run')
+        .description('Run Dream batch proposal generation; plain run writes drafts, --apply --yes attempts gated policy updates')
+        .option('--target <id>', 'restrict Dream to one existing canonical target')
+        .option('--limit <n>', 'maximum number of Dream candidates to write', parseDreamLimitOption, 3)
+        .option('--apply', 'synthesize bounded edits, run the static gate, and promote passing Dream candidates')
+        .option('--yes', 'confirm non-interactive Dream policy updates when --apply is used')
+        .option('--json', 'output JSON')
+        .action(async (options) => {
+        const result = await runDreamRunCommand({
+            target: options.target,
+            limit: options.limit,
+            applyPolicy: options.apply,
+            yes: options.yes,
+            json: options.json,
+        }, { repoRoot: process.cwd() });
+        process.exitCode = result.exitCode;
+    });
+    dream
+        .command('policy-update <candidateId>')
+        .description('Promote an accepted dream-batch candidate through bounded edits, static gate, and policy ledger update')
+        .option('--accepted-by <name>', 'actor that accepted the Dream candidate', 'maintainer')
+        .option('--yes', 'confirm non-interactive policy update')
+        .option('--json', 'output JSON')
+        .action(async (candidateId, options) => {
+        const result = await runDreamPolicyUpdateCommand({
+            candidateId,
+            acceptedBy: options.acceptedBy,
+            yes: options.yes,
+            json: options.json,
+        }, { repoRoot: process.cwd() });
+        process.exitCode = result.exitCode;
+    });
+    dream
+        .command('show [runId]')
+        .description('Show a Dream run record; omit runId to print the latest run when one exists')
+        .option('--json', 'output JSON')
+        .action(async (runId, options) => {
+        const result = await runDreamShowCommand({ runId, json: options.json }, { repoRoot: process.cwd() });
+        process.exitCode = result.exitCode;
+    });
+}
+export async function runDreamPreviewCommand(args, opts) {
+    const stdout = opts.stdout ?? ((line) => console.log(line));
+    const stderr = opts.stderr ?? ((line) => console.error(line));
+    try {
+        const preview = await buildDreamPreview({
+            projectRoot: opts.repoRoot,
+            target: args.target,
+            limit: args.limit,
+            now: opts.now,
+        });
+        stdout(args.json ? JSON.stringify(preview, null, 2) : renderDreamPreview(preview));
+        return { exitCode: 0, preview };
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        if (args.json)
+            stdout(JSON.stringify({ error }, null, 2));
+        else
+            stderr(error);
+        return { exitCode: 1, error };
+    }
+}
+export async function runDreamRunCommand(args, opts) {
+    const stdout = opts.stdout ?? ((line) => console.log(line));
+    const stderr = opts.stderr ?? ((line) => console.error(line));
+    if (args.applyPolicy && !args.yes) {
+        const error = '--yes is required when using dream run --apply because it can promote policy updates.';
+        if (args.json)
+            stdout(JSON.stringify({ error }, null, 2));
+        else
+            stderr(error);
+        return { exitCode: 2, error };
+    }
+    try {
+        const manifest = await writeDreamRun({
+            projectRoot: opts.repoRoot,
+            target: args.target,
+            limit: args.limit,
+            now: opts.now,
+            applyPolicy: args.applyPolicy,
+        });
+        stdout(args.json ? JSON.stringify(manifest, null, 2) : renderDreamRun(manifest));
+        return { exitCode: 0, manifest };
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        if (args.json)
+            stdout(JSON.stringify({ error }, null, 2));
+        else
+            stderr(error);
+        return { exitCode: 1, error };
+    }
+}
+export async function runDreamPolicyUpdateCommand(args, opts) {
+    const stdout = opts.stdout ?? ((line) => console.log(line));
+    const stderr = opts.stderr ?? ((line) => console.error(line));
+    if (!args.yes) {
+        const error = '--yes is required because Dream policy-update can modify local policy files.';
+        const result = {
+            exitCode: 2,
+            candidateId: args.candidateId,
+            targetId: '(unknown)',
+            outcome: 'error-runtime',
+            promoted: false,
+            gatePassed: false,
+            promotedFiles: [],
+            policyVersion: null,
+            error,
+            reason: error,
+        };
+        if (args.json)
+            stdout(JSON.stringify(result, null, 2));
+        else
+            stderr(error);
+        return result;
+    }
+    try {
+        const update = await runAcceptedDreamPolicyUpdate({
+            projectRoot: opts.repoRoot,
+            candidateId: args.candidateId,
+            acceptedBy: args.acceptedBy ?? 'maintainer',
+            synthesizeEdits: opts.synthesizeEdits,
+            now: opts.now,
+        });
+        const result = {
+            exitCode: update.outcome === 'error-runtime' ? 1 : 0,
+            ...update,
+        };
+        if (args.json)
+            stdout(JSON.stringify(result, null, 2));
+        else
+            stdout(renderDreamPolicyUpdateResult(result));
+        return result;
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        const result = {
+            exitCode: 1,
+            candidateId: args.candidateId,
+            targetId: '(unknown)',
+            outcome: 'error-runtime',
+            promoted: false,
+            gatePassed: false,
+            promotedFiles: [],
+            policyVersion: null,
+            error,
+            reason: error,
+        };
+        if (args.json)
+            stdout(JSON.stringify(result, null, 2));
+        else
+            stderr(error);
+        return result;
+    }
+}
+function renderDreamPolicyUpdateResult(result) {
+    const lines = [
+        `Dream policy update: ${result.outcome}`,
+        `Candidate: ${result.candidateId}`,
+        `Target: ${result.targetId}`,
+        `Gate passed: ${result.gatePassed ? 'yes' : 'no'}`,
+        `Policy version: ${result.policyVersion ?? '(unchanged)'}`,
+    ];
+    if (result.promotedFiles.length > 0) {
+        lines.push(`Promoted files: ${result.promotedFiles.join(', ')}`);
+    }
+    if (result.reason)
+        lines.push(`Reason: ${result.reason}`);
+    return lines.join('\n');
+}
+export async function runDreamShowCommand(args, opts) {
+    const stdout = opts.stdout ?? ((line) => console.log(line));
+    const stderr = opts.stderr ?? ((line) => console.error(line));
+    try {
+        const runId = args.runId ?? (await latestRunId(opts.repoRoot));
+        if (!runId) {
+            const error = 'No Dream runs found.';
+            if (args.json)
+                stdout(JSON.stringify({ error }, null, 2));
+            else
+                stderr(error);
+            return { exitCode: 1, error };
+        }
+        const manifest = await readDreamRun(opts.repoRoot, runId);
+        stdout(args.json ? JSON.stringify(manifest, null, 2) : renderDreamRun(manifest));
+        return { exitCode: 0, manifest };
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        if (args.json)
+            stdout(JSON.stringify({ error }, null, 2));
+        else
+            stderr(error);
+        return { exitCode: 1, error };
+    }
+}
+async function latestRunId(repoRoot) {
+    let entries;
+    const runsDir = resolveDreamRunsDir(repoRoot);
+    try {
+        entries = await fs.readdir(runsDir, { withFileTypes: true });
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return null;
+        throw err;
+    }
+    const ids = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !isDreamRunId(entry.name))
+            continue;
+        try {
+            const stat = await fs.stat(path.join(runsDir, entry.name, 'dream-run.json'));
+            if (stat.isFile())
+                ids.push(entry.name);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT')
+                throw err;
+        }
+    }
+    ids.sort().reverse();
+    return ids[0] ?? null;
+}
+export function parseDreamLimitOption(value) {
+    if (!/^(0|[1-9]\d*)$/.test(value)) {
+        throw new Error(`expected a non-negative integer, got: ${value}`);
+    }
+    const parsed = Number(value);
+    return parsed;
+}
+function isDreamRunId(value) {
+    return /^dream-\d{8}t\d{6}z-[a-f0-9]{8}$/.test(value);
+}
+//# sourceMappingURL=self-evolution-dream.js.map

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

@@ -58,10 +58,14 @@ export interface RunEpisodeCommandArgs {
     target?: string;
     /** Skip the CRITIC AGENT（基线智能体 baseline agent）arm for this episode. */
     noBaseline?: boolean;
+    /** Force the observed-run/code-agent harness for this episode. */
+    harness?: string;
     /** Explicit transcript handle (Claude transcript store only). */
     transcript?: string;
     /** Explicit Claude session id handle. */
     sessionId?: string;
+    /** Force a new episode even when a completed matching run exists. */
+    forceNewEpisode?: boolean;
     json?: boolean;
 }
 export interface RunEpisodeCommandOptions {
@@ -106,6 +110,7 @@ export interface RunEpisodeCommandResult {
 export declare function runEpisodeCommand(args: RunEpisodeCommandArgs, opts: RunEpisodeCommandOptions): Promise<RunEpisodeCommandResult>;
 export interface RunResumeEpisodeCommandArgs {
     episodeId: string;
+    harness?: string;
     json?: boolean;
 }
 export interface RunResumeEpisodeCommandResult {