@evomap/evolver-core 2.0.0-beta.2 → 2.0.0-beta.22

package/dist/algo/cycleEngine.d.ts

@@ -4,37 +4,63 @@ import type { GepCategory, Mutation, Capsule, EvolutionEvent } from '../wire/ind
 import type { AssetStoreProvider } from '../assetstore/provider.js';
 import type { StrategyPoint } from '../strategy/strategyPoint.js';
 import { type CycleStage } from '../cycle/stateMachine.js';
-import { type GeneDecision, type SelectionInput, type GeneCandidateInput, type AntiWarning } from './geneSelection.js';
+import { type GeneDecision, type SelectionInput, type GeneCandidateInput, type AntiWarning, type SelectionGuardMode } from './geneSelection.js';
 import { type EnvFingerprint } from '../bootstrap/envFingerprint.js';
 import type { PersonalityStore } from '../personality/store.js';
-import { type ResolutionStatus } from './solidify.js';
+import { type FailureEvidenceIdentityInput, type ResolutionStatus } from './solidify.js';
 import type { ProofOfWork } from '../schema/proofOfWork.js';
+import type { ExecutionTerminalDisposition, FrozenExecutionBinding, ImmutableExecutionProvenance } from '../exec/executionBinding.js';
 import { type ClassifyRecentEvent } from './cycleFailureClassifier.js';
+import type { MemoryGraphGeneEvidence } from './memoryGraph.js';
+import { type SelectionPolicy } from './ucb1.js';
 export interface TriggerEval {
     trigger: boolean;
     reasons: string[];
     valueScore: number;
 }
+export type ExecutionFailureKind = 'spawn_failed' | 'timeout' | 'cancelled' | 'permission_denied' | 'non_zero_exit' | 'invalid_output' | 'runtime_error';
 export interface ExecutionResult {
     outcome: {
         status: 'success' | 'failed';
         score: number;
         reason?: string;
     };
+    bindingCorrelation?: {
+        bindingDigest: `sha256:${string}`;
+        runId: string;
+    };
+    executionTerminal?: {
+        status: 'success' | 'failed';
+        disposition: ExecutionTerminalDisposition;
+    };
+    provenance?: ImmutableExecutionProvenance;
+    hubLifecycle?: {
+        state: 'not_submitted';
+    };
+    nativeSessionId?: string;
     proofOfWork?: ProofOfWork;
     strongEvidence?: boolean;
+    /** Optional logical failure identity supplied by the runner; absent keeps the failure as legacy advisory evidence. */
+    failureIdentity?: FailureEvidenceIdentityInput;
+    /** Structured runner failure metadata. Safe to persist; unlike sessionLog it contains no transcript text. */
+    failureKind?: ExecutionFailureKind;
+    exitCode?: number | null;
     /**
      * The agent run's transcript (stdout, plus stderr when present), attached by the execution layer on a FAILED
      * outcome. It is the host-side context classifyCycleFailure needs to reach the host_no_transcript /
      * host_provider_error buckets on the PRODUCTION path (#279): an empty transcript means the host gave evolver
      * nothing to evolve from; a provider-error string (429 / quota / context-length) means the host's LLM call
-     * failed, not the gene. Consumed only for failure triage and NEVER persisted to event payloads (the engine
-     * writes only the derived failure_class), so it adds no root_events bloat and leaks no transcript content.
+     * failed, not the gene. Consumed only for failure triage and NEVER persisted to event payloads; the engine
+     * writes only the derived failure_class, so it adds no root_events bloat and leaks no transcript content.
      */
     sessionLog?: string;
 }
 export interface SolidifyPermitContext {
     cycleId: string;
+    bindingDigest?: `sha256:${string}`;
+    runId?: string;
+    executionTerminal?: ExecutionResult['executionTerminal'];
+    provenance?: ImmutableExecutionProvenance;
     geneId: string;
     signals: readonly string[];
     mutation: Mutation;
@@ -61,6 +87,8 @@ export interface CycleEngineDeps {
     rng?: () => number;
     /** Injected environment fingerprint (deterministic tests). Defaults to capturing the real runtime env. */
     envFingerprint?: () => EnvFingerprint;
+    /** Latest external capability gaps. Composition owns persistence/wire details; core reads one bounded snapshot. */
+    capabilityGaps?: () => readonly string[];
     /** 触发评估(常注入 TriggerEngine.evaluate 的包装; 缺省=直接触发). */
     trigger?: (p: ProblemPattern, now: number) => Promise<TriggerEval> | TriggerEval;
     /** 可进化人格(可选). 注入后, 每轮:
@@ -77,10 +105,20 @@ export interface CycleInput {
     cycleId: string;
     problem: ProblemPattern;
     signals: readonly string[];
+    /** Curriculum targets already prepared before candidate assembly. Omit for direct runCycle callers. */
+    curriculumSignals?: readonly string[];
     category: GepCategory;
     /** Optional explicit strategy preset name; when set, it wins over history-derived meta-signal auto-detection. */
     strategyName?: string;
     candidates: readonly GeneCandidateInput[];
+    /** Trust-filtered library corpus captured before relevance admission for stable semantic IDF. */
+    semanticCorpus?: readonly GeneCandidateInput[];
+    /** Emergency rollback: use the pre-IDF semantic scorer for this cycle. */
+    disableSemanticIdf?: boolean;
+    /** Experimental plateau selection policy. Default preserves engine-health + legacy random drift. */
+    selectionPolicy?: SelectionPolicy;
+    /** Versioned relevance-guard rollout. Omit for legacy direct-call behavior. */
+    selectionGuard?: SelectionGuardMode;
     selectionFloor?: number;
     /**
      * Explicit GEP/runtime-selected gene. Forwarded after candidate assembly and local hard filters, so it cannot
@@ -92,16 +130,20 @@ export interface CycleInput {
     summary: string;
     confidence: number;
     execute: (mutation: Mutation, decision: GeneDecision) => Promise<ExecutionResult> | ExecutionResult;
+    /** Immutable external execution binding; omitted for legacy local cycles. */
+    executionBinding?: FrozenExecutionBinding;
     /** Optional adapter/runtime permit gate. Runs after execute succeeds and before solidify writes assets. */
     solidifyPermit?: SolidifyPermitGate;
     /**
      * Distilled-gene fallback pool (ported from v1 #97): broadly-applicable distilled genes that do NOT match the
      * live signals, assembled (trust/review/ban-filtered) upstream. Forwarded to selection, which uses one only as a
-     * last resort when no candidate clears the floor — reusing a known distilled strategy instead of a blind innovate.
+     * last resort when normal selection has no reusable positive choice — reusing a known distilled strategy instead of a blind innovate.
      */
     distilledFallback?: readonly GeneCandidateInput[];
     /** Advisory-only AntiGene warnings matched upstream for this cycle's base signals. */
     antiWarnings?: readonly AntiWarning[];
+    /** Bounded structured outcome evidence for explainability and prompt enrichment. */
+    memoryEvidence?: readonly MemoryGraphGeneEvidence[];
     /**
      * Optional triage context for the cycle.failed event (PORT v1 #279 issue-reporter half). When the caller can
      * supply a session transcript or a list of recent failed cycles, classifyCycleFailure runs and the resulting
@@ -123,13 +165,21 @@ export interface CycleInput {
 }
 export interface CycleResult {
     cycleId: string;
+    bindingDigest?: `sha256:${string}`;
+    runId?: string;
+    terminalDisposition?: ExecutionTerminalDisposition;
+    execution?: ExecutionResult;
     triggered: boolean;
     finalStage: CycleStage;
+    /** Real CycleEngine returns this on every path; optional keeps injected legacy engines source-compatible. */
+    producedValue?: boolean;
     decision?: GeneDecision;
     mutation?: Mutation;
     capsule?: Capsule;
     event?: EvolutionEvent;
     resolutionStatus?: ResolutionStatus;
+    failureKind?: ExecutionFailureKind;
+    exitCode?: number | null;
     reasons: string[];
 }
 /**
@@ -139,5 +189,13 @@ export interface CycleResult {
 export declare class CycleEngine {
     private readonly deps;
     constructor(deps: CycleEngineDeps);
+    /**
+     * Add V1-compatible curriculum targets from V2's replayable event history. Public so the orchestrator can run
+     * it before candidate assembly; runCycle calls it again for direct callers. Set merging makes that idempotent.
+     */
+    prepareCurriculumSignals(signals: readonly string[]): {
+        signals: string[];
+        curriculumSignals: string[];
+    };
     runCycle(input: CycleInput): Promise<CycleResult>;
 }