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

package/dist/algo/candidateAssembly.js

@@ -18,14 +18,15 @@ function candidateIds(geneId, assetId) {
 function isBannedCandidate(banned, geneId, assetId) {
     return candidateIds(geneId, assetId).some((id) => banned.has(id));
 }
-function passesInjectedCandidateGates(candidate, opts, provenance) {
+function passesInjectedCandidateGates(candidate, opts, provenance, review) {
     const assetId = candidate.assetId;
     if (opts.provenance && !opts.includeUntrusted) {
         if (!assetId || provenance?.get(assetId)?.trusted !== true)
             return false;
     }
     if (opts.review) {
-        if (!assetId || !opts.review.isApproved(assetId))
+        const reviewRecord = assetId ? review?.get(assetId) : undefined;
+        if (!assetId || (reviewRecord !== undefined && reviewRecord.state !== 'approved'))
             return false;
     }
     return true;
@@ -80,6 +81,7 @@ export async function assembleSelectionPool(store, signals, opts = {}) {
     const banned = await computeBans(store, signals, limit);
     const sigSet = new Set(signals);
     const provenance = opts.provenance?.snapshot();
+    const review = opts.review?.snapshot();
     const out = [];
     const distilledFallback = [];
     const antiWarnings = [];
@@ -92,8 +94,9 @@ export async function assembleSelectionPool(store, signals, opts = {}) {
         // out too. No record → eligible (cycle/migrate genes). Symmetric to the provenance trust-first filter above.
         // Probation (#306): includeProbation lets a quarantined draft be TRIED so it can earn evidence; a rejected
         // draft is never tried. Off (default) keeps quarantined drafts out until approval.
-        if (opts.review && !opts.review.isApproved(String(g.asset_id))
-            && (!opts.includeProbation || opts.review.get(String(g.asset_id))?.state === 'rejected'))
+        const reviewRecord = review?.get(String(g.asset_id));
+        if (opts.review && reviewRecord !== undefined && reviewRecord.state !== 'approved'
+            && (!opts.includeProbation || reviewRecord.state === 'rejected'))
             continue;
         const geneId = typeof g['id'] === 'string' ? String(g['id']) : String(g.asset_id);
         const assetId = String(g.asset_id);
@@ -148,7 +151,7 @@ export async function assembleSelectionPool(store, signals, opts = {}) {
     if (opts.hubCandidates && opts.hubCandidates.length > 0) {
         const localIds = new Set(out.map((c) => c.geneId));
         for (const h of opts.hubCandidates) {
-            if (!passesInjectedCandidateGates(h, opts, provenance))
+            if (!passesInjectedCandidateGates(h, opts, provenance, review))
                 continue;
             if (localIds.has(h.geneId))
                 continue; // a trusted local gene already covers this id
@@ -166,7 +169,7 @@ export async function assembleSelectionPool(store, signals, opts = {}) {
         // AntiGene is negative memory that changes an autonomous prompt. Unlike legacy/cycle-authored Genes, it must
         // never inherit ReviewLedger's backward-compatible "no record = approved" default: no ledger, no record,
         // quarantined, and rejected all fail closed. Only an explicit human approval can enable warning injection.
-        if (!opts.review?.isExplicitlyApproved(String(a.asset_id)))
+        if (review?.get(String(a.asset_id))?.state !== 'approved')
             continue;
         const trigger = asStrings(a['trigger']);
         const avoid = asStrings(a['avoid']);

package/dist/algo/cycleEngine.d.ts

@@ -10,11 +10,13 @@ import type { PersonalityStore } from '../personality/store.js';
 import { type ResolutionStatus } from './solidify.js';
 import type { ProofOfWork } from '../schema/proofOfWork.js';
 import { type ClassifyRecentEvent } from './cycleFailureClassifier.js';
+import type { MemoryGraphGeneEvidence } from './memoryGraph.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';
@@ -23,6 +25,9 @@ export interface ExecutionResult {
     };
     proofOfWork?: ProofOfWork;
     strongEvidence?: boolean;
+    /** 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 /
@@ -102,6 +107,8 @@ export interface CycleInput {
     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
@@ -125,11 +132,15 @@ export interface CycleResult {
     cycleId: string;
     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[];
 }
 /**

package/dist/algo/cycleEngine.js

@@ -200,6 +200,10 @@ export class CycleEngine {
             });
             return r.reason ? { failure_class: r.failureClass, failure_class_reason: r.reason } : { failure_class: r.failureClass };
         };
+        const executionMetadata = (exec) => ({
+            ...(exec.failureKind !== undefined ? { failureKind: exec.failureKind } : {}),
+            ...(exec.exitCode !== undefined ? { exitCode: exec.exitCode } : {}),
+        });
         const strategy = resolveStrategy({ name: input.strategyName, signals: cycleSignals, cycleCount: historyCycleCount(ingestor, 1000, input.cycleId) });
         const cycleCategory = categoryForStrategy(input.category, strategy);
         let stage = 'none';
@@ -226,7 +230,7 @@ export class CycleEngine {
         if (!trig.trigger) {
             await ingestor.ingest({ type: 'cycle.aborted', human: { title: `cycle ${input.cycleId} 抑制` }, payload: { cycleId: input.cycleId, reasons: trig.reasons } });
             advance('aborted');
-            return { cycleId: input.cycleId, triggered: false, finalStage: stage, reasons: trig.reasons };
+            return { cycleId: input.cycleId, triggered: false, finalStage: stage, producedValue: false, reasons: trig.reasons };
         }
         // 选 gene(可解释决策). Exploration: when recent cycles plateau, enable drift to escape local optima.
         const recentOutcomes = recentCycleOutcomes(ingestor, 100);
@@ -297,11 +301,11 @@ export class CycleEngine {
             const epi = epigeneticPenaltyForIds(candidateIds(c), envKey, geneOutcomes);
             return epi > 0 ? { ...c, epigeneticPenalty: epi } : c;
         });
-        const decision = (await this.deps.selection.run({ signals: baseSignals, candidates, floor: input.selectionFloor, ...(input.forcedGeneId !== undefined ? { forcedGeneId: input.forcedGeneId } : {}), ...(exploration ? { exploration } : {}), ...(distilledFallback.length > 0 ? { distilledFallback } : {}), ...(input.antiWarnings && input.antiWarnings.length > 0 ? { antiWarnings: input.antiWarnings } : {}) }, { now, cycleId: input.cycleId, ...(this.deps.rng ? { rng: this.deps.rng } : {}) }));
+        const decision = (await this.deps.selection.run({ signals: baseSignals, candidates, floor: input.selectionFloor, ...(input.forcedGeneId !== undefined ? { forcedGeneId: input.forcedGeneId } : {}), ...(exploration ? { exploration } : {}), ...(distilledFallback.length > 0 ? { distilledFallback } : {}), ...(input.antiWarnings && input.antiWarnings.length > 0 ? { antiWarnings: input.antiWarnings } : {}), ...(input.memoryEvidence && input.memoryEvidence.length > 0 ? { memoryEvidence: input.memoryEvidence } : {}) }, { now, cycleId: input.cycleId, ...(this.deps.rng ? { rng: this.deps.rng } : {}) }));
         await ingestor.ingest({
             type: 'decision.gene_selected',
             human: { title: `选 gene ${decision.selectedGeneId ?? '(innovate)'}`, why: decision.candidates.map((c) => `${c.geneId}:${c.score.toFixed(3)}`).join(', ') || '无候选→innovate' },
-            payload: { cycleId: input.cycleId, selectedGeneId: decision.selectedGeneId, ...(decision.selectedAssetId ? { selectedAssetId: decision.selectedAssetId } : {}), candidates: decision.candidates, ...(decision.antiWarnings && decision.antiWarnings.length > 0 ? { antiWarnings: decision.antiWarnings } : {}), weightsVersion: decision.weightsVersion, strategy: decision.strategyName, strategyPreset: strategy.name, ...(plateau.active ? { plateau } : {}), ...(inertBanned.size > 0 ? { inertBanned: [...inertBanned] } : {}) },
+            payload: { cycleId: input.cycleId, selectedGeneId: decision.selectedGeneId, ...(decision.selectedAssetId ? { selectedAssetId: decision.selectedAssetId } : {}), ...(decision.selectedReason ? { selectedReason: decision.selectedReason } : {}), candidates: decision.candidates, ...(decision.antiWarnings && decision.antiWarnings.length > 0 ? { antiWarnings: decision.antiWarnings } : {}), ...(decision.memoryEvidence && decision.memoryEvidence.length > 0 ? { memoryEvidence: decision.memoryEvidence } : {}), weightsVersion: decision.weightsVersion, strategy: decision.strategyName, strategyPreset: strategy.name, ...(plateau.active ? { plateau } : {}), ...(inertBanned.size > 0 ? { inertBanned: [...inertBanned] } : {}) },
         });
         advance('gene_selected');
         const geneId = decision.selectedGeneId ?? 'ad-hoc';
@@ -331,7 +335,7 @@ export class CycleEngine {
             await ingestor.ingest({ type: 'cycle.failed', human: { title: `cycle ${input.cycleId} 执行抛错` }, payload: { cycleId: input.cycleId, error: msg, gene: geneId, env: envKey, ...failureClassPayload({ geneId }, msg) } });
             advance('failed');
             await recordPersonalityOutcome('failed', null);
-            return { cycleId: input.cycleId, triggered: true, finalStage: stage, decision, mutation, reasons: [...reasons, `执行异常: ${msg}`] };
+            return { cycleId: input.cycleId, triggered: true, finalStage: stage, producedValue: false, decision, mutation, reasons: [...reasons, `执行异常: ${msg}`] };
         }
         if (input.solidifyPermit) {
             let permit;
@@ -360,12 +364,13 @@ export class CycleEngine {
                         reason: permit.reason,
                         gene: geneId,
                         env: envKey,
+                        ...executionMetadata(exec),
                         ...failureClassPayload({ geneId }),
                     },
                 });
                 advance('failed');
                 await recordPersonalityOutcome('failed', null);
-                return { cycleId: input.cycleId, triggered: true, finalStage: stage, decision, mutation, reasons: [...reasons, reason] };
+                return { cycleId: input.cycleId, triggered: true, finalStage: stage, producedValue: false, decision, mutation, ...executionMetadata(exec), reasons: [...reasons, reason] };
             }
         }
         // solidify → Capsule
@@ -394,6 +399,7 @@ export class CycleEngine {
                     outcome: exec.outcome,
                     gene: geneId,
                     env: envKey,
+                    ...executionMetadata(exec),
                     // Only forward blast radius as a no-op signal when it was measured from a git_diff proof. solidify.ts
                     // forces blast to {0,0} for non-git_diff proofs (artifact_hash/external_receipt/tool_call_trace),
                     // where {0,0} means "blast unknown", NOT "no change" — forwarding it would mis-classify a productive
@@ -414,6 +420,6 @@ export class CycleEngine {
         }
         // 人格统计回写(用途②): 用本轮真实 outcome/score 回写当轮人格桶, 供下一轮自然选择靠拢. 未注入 ⇒ no-op.
         await recordPersonalityOutcome(exec.outcome.status, exec.outcome.score);
-        return { cycleId: input.cycleId, triggered: true, finalStage: stage, decision, mutation, capsule: sol.capsule, event, resolutionStatus: sol.resolutionStatus, reasons };
+        return { cycleId: input.cycleId, triggered: true, finalStage: stage, producedValue: sol.producedValue, decision, mutation, capsule: sol.capsule, event, resolutionStatus: sol.resolutionStatus, ...executionMetadata(exec), reasons };
     }
 }

package/dist/algo/cycleFailureClassifier.d.ts

@@ -1,5 +1,5 @@
 /** Bucket the failure falls into. unclassified = default-open (treat as a real evolver bug worth filing).
- *  Bucket string matches V1 (EvoMap/evolver-private-dev#279 commit a89e123e) byte-for-byte so wire / UI
+ *  Bucket string matches V1 byte-for-byte so wire / UI
  *  consumers can branch on the same value regardless of producer. */
 export type CycleFailureClass = 'host_no_transcript' | 'host_provider_error' | 'local_gene_no_blast' | 'unclassified';
 /** Shape of a recent cycle event the classifier reads. Loose so callers can pass partial DTOs. */

package/dist/algo/geneSelection.d.ts

@@ -5,6 +5,7 @@ import type { GeneLearningView } from '../assetstore/learningHistory.js';
 import type { AssetRecord } from '../assetstore/provider.js';
 import { type ExplorationInput } from './exploration.js';
 import type { GenerationSource } from '../wire/index.js';
+import type { MemoryGraphGeneEvidence } from './memoryGraph.js';
 /** 一个候选 gene 的选择期素材. */
 export interface GeneCandidateInput {
     geneId: string;
@@ -35,6 +36,8 @@ export interface GeneCandidateInput {
      * set the hard gates already produced, so a high confidence can never resurrect a gene that was excluded.
      */
     confidence?: number;
+    /** Scoped local MemoryGraph outcome signal in [-1,1]. Data-only and never executable prompt content. */
+    memoryBoost?: number;
     /**
      * Cross-runtime reuse sentiment in [-1, 1] for this gene (#268 phase 1): the net of self-reported reuse
      * SUCCESSes vs negatives (failed/mismatched/stale/unsafe), computed upstream from reuse-outcome events
@@ -78,6 +81,8 @@ export interface SelectionInput {
      * for prompt rendering only; they never enter scoring, fallback, or forced selection.
      */
     antiWarnings?: readonly AntiWarning[];
+    /** Structured, scoped outcome evidence selected upstream. Contains no raw memory text or instructions. */
+    memoryEvidence?: readonly MemoryGraphGeneEvidence[];
 }
 export interface ScoredCandidate {
     geneId: string;
@@ -105,6 +110,10 @@ export interface GeneDecision {
     antiWarnings?: AntiWarning[];
     weightsVersion: string;
     strategyName: string;
+    /** Human-readable explanation for the winning candidate. */
+    selectedReason?: string;
+    /** Bounded structured outcome evidence for prompt enrichment. */
+    memoryEvidence?: MemoryGraphGeneEvidence[];
 }
 /**
  * Weight of the preferred-gene confidence factor (fourth factor, positive cross-cycle learning). Kept small so
@@ -118,12 +127,14 @@ export declare const CONFIDENCE_WEIGHT = 0.15;
  * ±REUSE_WEIGHT and can never dominate health/signal-match.
  */
 export declare const REUSE_WEIGHT = 0.1;
+/** Weight of scoped local MemoryGraph outcome evidence. */
+export declare const MEMORY_GRAPH_WEIGHT = 0.12;
 /**
  * Version of the full engine-health weight vector (health 0.6 + signal-match 0.4 − epigenetic penalty
  * + CONFIDENCE_WEIGHT × confidence + REUSE_WEIGHT × reuse-sentiment). Bumped whenever a factor is added so golden
  * weight snapshots track the change. Composed from the health-weights version so a change to either layer shows.
  */
-export declare const SELECTION_WEIGHTS_VERSION = "sel-3(gh-1,conf=0.15,reuse=0.1)";
+export declare const SELECTION_WEIGHTS_VERSION = "sel-4(gh-1,conf=0.15,memory=0.12,reuse=0.1)";
 /** 实现1: engine 健康分主导(health 0.6 + 信号匹配 0.4). */
 export declare const engineHealthSelection: Strategy<SelectionInput, GeneDecision>;
 /** 实现2: 纯信号匹配采样(忽略 health, 对照基线 — 经验主义要可对比). */

package/dist/algo/geneSelection.js

@@ -4,9 +4,17 @@ import { tagOverlapScore, bagCosine } from '../signals/expand.js';
 import { driftSelect } from './exploration.js';
 import { isDistilledGeneId } from './geneIntake.js';
 function decisionWithWarnings(input, decision) {
+    const selected = decision.selectedGeneId
+        ? decision.candidates.find((candidate) => candidate.geneId === decision.selectedGeneId || candidate.assetId === decision.selectedAssetId)
+        : undefined;
+    const enriched = {
+        ...decision,
+        ...(selected ? { selectedReason: selected.reasons.join('; ') } : {}),
+        ...(input.memoryEvidence && input.memoryEvidence.length > 0 ? { memoryEvidence: [...input.memoryEvidence] } : {}),
+    };
     return input.antiWarnings && input.antiWarnings.length > 0
-        ? { ...decision, antiWarnings: [...input.antiWarnings] }
-        : decision;
+        ? { ...enriched, antiWarnings: [...input.antiWarnings] }
+        : enriched;
 }
 function signalMatchScore(signals, match) {
     if (signals.length === 0 || match.length === 0)
@@ -29,12 +37,14 @@ export const CONFIDENCE_WEIGHT = 0.15;
  * ±REUSE_WEIGHT and can never dominate health/signal-match.
  */
 export const REUSE_WEIGHT = 0.1;
+/** Weight of scoped local MemoryGraph outcome evidence. */
+export const MEMORY_GRAPH_WEIGHT = 0.12;
 /**
  * Version of the full engine-health weight vector (health 0.6 + signal-match 0.4 − epigenetic penalty
  * + CONFIDENCE_WEIGHT × confidence + REUSE_WEIGHT × reuse-sentiment). Bumped whenever a factor is added so golden
  * weight snapshots track the change. Composed from the health-weights version so a change to either layer shows.
  */
-export const SELECTION_WEIGHTS_VERSION = `sel-3(${HEALTH_WEIGHTS_VERSION},conf=${CONFIDENCE_WEIGHT},reuse=${REUSE_WEIGHT})`;
+export const SELECTION_WEIGHTS_VERSION = `sel-4(${HEALTH_WEIGHTS_VERSION},conf=${CONFIDENCE_WEIGHT},memory=${MEMORY_GRAPH_WEIGHT},reuse=${REUSE_WEIGHT})`;
 /**
  * Match score with semantic signal expansion (ported from v1): literal coverage first, then fill the
  * recall gap with semantic tag overlap, then with bag-of-words cosine similarity. A perfect literal match
@@ -65,13 +75,16 @@ function scoreCandidate(signals, c) {
     // Cross-runtime reuse sentiment (#268 phase 1): clamped to [-1,1] so an upstream bug cannot turn the soft nudge
     // into a dominant (or unbounded) term. Absent → 0 → no effect (default-off until a caller injects it).
     const reuse = Math.max(-1, Math.min(1, c.reuseAdjust ?? 0));
-    const score = 0.6 * health.score + 0.4 * m.score - epi + CONFIDENCE_WEIGHT * conf + REUSE_WEIGHT * reuse;
+    const memory = Math.max(-1, Math.min(1, c.memoryBoost ?? 0));
+    const score = 0.6 * health.score + 0.4 * m.score - epi + CONFIDENCE_WEIGHT * conf + MEMORY_GRAPH_WEIGHT * memory + REUSE_WEIGHT * reuse;
     const breakdown = m.tag > 0 || m.cos > 0 ? `(literal=${m.literal.toFixed(2)}+tag=${m.tag.toFixed(2)}+cos=${m.cos.toFixed(2)})` : '';
     const reasons = [`health=${health.score.toFixed(3)}(succ=${health.successRate.toFixed(2)},reuse=${health.reuseCount})`, `信号匹配=${m.score.toFixed(2)}${breakdown}`];
     if (epi > 0)
         reasons.push(`epigenetic 环境抑制 -${epi.toFixed(2)}`);
     if (conf > 0)
         reasons.push(`preferred-gene confidence +${(CONFIDENCE_WEIGHT * conf).toFixed(3)} (conf=${conf.toFixed(2)})`);
+    if (memory !== 0)
+        reasons.push(`scoped memory-graph outcome ${memory >= 0 ? '+' : ''}${(MEMORY_GRAPH_WEIGHT * memory).toFixed(3)} (boost=${memory.toFixed(2)})`);
     if (reuse !== 0)
         reasons.push(`cross-runtime reuse ${reuse >= 0 ? '+' : ''}${(REUSE_WEIGHT * reuse).toFixed(3)} (sentiment=${reuse.toFixed(2)})`);
     return { geneId: c.geneId, ...(c.assetId ? { assetId: c.assetId } : {}), score, health, reasons };
@@ -164,11 +177,14 @@ export const engineHealthSelection = {
             // (0 < score <= floor) would be preempted by an unrelated zero-evidence distilled gene; V1 (which has no floor)
             // keeps such a match. When candidates scored > 0 but below floor, defer to V2's floor policy (innovate).
             const noSignalMatch = !forced.forceRejected && forced.scoredForChoice.every((s) => s.score <= 0);
-            const fb = noSignalMatch
-                ? (input.distilledFallback ?? []).find((c) => isReusableFallbackCandidate(c) && (c.epigeneticPenalty ?? 0) === 0)
+            const fallback = noSignalMatch
+                ? (input.distilledFallback ?? [])
+                    .filter((candidate) => isReusableFallbackCandidate(candidate) && (candidate.epigeneticPenalty ?? 0) === 0)
+                    .map((candidate) => ({ candidate, scored: scoreCandidate(input.signals, candidate) }))
+                    .sort((left, right) => right.scored.score - left.scored.score || left.candidate.geneId.localeCompare(right.candidate.geneId))[0]
                 : undefined;
-            if (fb) {
-                const fbScored = scoreCandidate(input.signals, fb);
+            if (fallback) {
+                const { candidate: fb, scored: fbScored } = fallback;
                 fbScored.reasons.push('distilled_fallback(#97): 无信号匹配, 低置信度复用蒸馏 gene');
                 scored.push(fbScored);
                 selectedGeneId = fb.geneId;

package/dist/algo/index.d.ts

@@ -2,6 +2,7 @@ export * from './geneHealth.js';
 export * from './exploration.js';
 export * from './epigenetics.js';
 export * from './confidence.js';
+export * from './memoryGraph.js';
 export * from './capabilityCandidates.js';
 export * from './conversationSniffer.js';
 export * from './geneIntake.js';

package/dist/algo/index.js

@@ -2,6 +2,7 @@ export * from './geneHealth.js';
 export * from './exploration.js';
 export * from './epigenetics.js';
 export * from './confidence.js';
+export * from './memoryGraph.js';
 export * from './capabilityCandidates.js';
 export * from './conversationSniffer.js';
 export * from './geneIntake.js';

package/dist/algo/memoryGraph.d.ts

@@ -0,0 +1,62 @@
+export type MemoryGraphOutcomeStatus = 'success' | 'failed';
+export interface MemoryGraphOutcomeRecord {
+    version: 2;
+    kind: 'outcome';
+    provenance: 'v2_local' | 'v1_import';
+    workspaceScope: string;
+    userScope: string;
+    signalFingerprint: string;
+    signals: readonly string[];
+    geneId: string;
+    status: MemoryGraphOutcomeStatus;
+    score: number;
+    at: string;
+    /** Stable local-source identity used to make one-time imports crash-retry safe. */
+    sourceFingerprint?: string;
+    successCount?: number;
+    failCount?: number;
+}
+export interface MemoryGraphGeneEvidence {
+    geneId: string;
+    boost: number;
+    expectedSuccess: number;
+    successCount: number;
+    failCount: number;
+    attempts: number;
+    similarity: number;
+    lastAt: string;
+}
+export interface MemoryGraphDiagnostics {
+    bytesRead: number;
+    recordsRead: number;
+    corruptLines: number;
+    oversizedLines: number;
+    scopeRejected: number;
+    provenanceRejected: number;
+    truncated: boolean;
+    recovery: 'healthy' | 'degraded' | 'recovered' | 'empty';
+    /** The graph was healthy enough to address, but another process held its maintenance lock. */
+    busy?: boolean;
+}
+export interface MemoryGraphAdvice {
+    genes: readonly MemoryGraphGeneEvidence[];
+    diagnostics: MemoryGraphDiagnostics;
+}
+export interface MemoryGraphQueryInput {
+    workspace: string;
+    signals: readonly string[];
+}
+export interface MemoryGraphRecordInput extends MemoryGraphQueryInput {
+    geneId: string;
+    status: MemoryGraphOutcomeStatus;
+    score: number;
+    at: string;
+}
+export interface MemoryGraphProvider {
+    query(input: MemoryGraphQueryInput): Promise<MemoryGraphAdvice> | MemoryGraphAdvice;
+    recordOutcome(input: MemoryGraphRecordInput): Promise<void> | void;
+}
+export declare function normalizeMemorySignals(signals: readonly string[]): string[];
+export declare function memorySignalFingerprint(signals: readonly string[]): string;
+export declare function safeMemoryGeneId(value: string): string;
+export declare function deriveMemoryGraphAdvice(records: readonly MemoryGraphOutcomeRecord[], signals: readonly string[], nowMs: number, diagnostics: MemoryGraphDiagnostics): MemoryGraphAdvice;

package/dist/algo/memoryGraph.js

@@ -0,0 +1,86 @@
+const MAX_SIGNALS = 32;
+const MAX_SIGNAL_CHARS = 120;
+const MAX_GENE_CHARS = 240;
+const MIN_SIMILARITY = 0.34;
+const HALF_LIFE_DAYS = 30;
+export function normalizeMemorySignals(signals) {
+    return [...new Set(signals
+            .filter((signal) => typeof signal === 'string')
+            .map((signal) => signal.trim().toLowerCase().slice(0, MAX_SIGNAL_CHARS))
+            .filter(Boolean))]
+        .sort()
+        .slice(0, MAX_SIGNALS);
+}
+export function memorySignalFingerprint(signals) {
+    return normalizeMemorySignals(signals).join('|') || '(none)';
+}
+export function safeMemoryGeneId(value) {
+    return value.trim().slice(0, MAX_GENE_CHARS);
+}
+export function deriveMemoryGraphAdvice(records, signals, nowMs, diagnostics) {
+    const currentSignals = normalizeMemorySignals(signals);
+    const aggregates = new Map();
+    for (const record of records) {
+        const similarity = jaccard(currentSignals, record.signals);
+        if (similarity < MIN_SIMILARITY)
+            continue;
+        const successCount = boundedCount(record.successCount ?? (record.status === 'success' ? 1 : 0));
+        const failCount = boundedCount(record.failCount ?? (record.status === 'failed' ? 1 : 0));
+        const total = successCount + failCount;
+        if (total === 0)
+            continue;
+        const decay = decayWeight(record.at, nowMs);
+        const weight = similarity * decay;
+        const current = aggregates.get(record.geneId) ?? { success: 0, fail: 0, weightedSimilarity: 0, weight: 0, lastAt: record.at };
+        current.success += successCount * weight;
+        current.fail += failCount * weight;
+        current.weightedSimilarity += similarity * total;
+        current.weight += total;
+        if (Date.parse(record.at) > Date.parse(current.lastAt))
+            current.lastAt = record.at;
+        aggregates.set(record.geneId, current);
+    }
+    const genes = [];
+    for (const [geneId, aggregate] of aggregates) {
+        const successCount = Math.round(aggregate.success);
+        const failCount = Math.round(aggregate.fail);
+        const attempts = successCount + failCount;
+        if (attempts === 0)
+            continue;
+        const expectedSuccess = (aggregate.success + 1) / (aggregate.success + aggregate.fail + 2);
+        const similarity = aggregate.weight > 0 ? Math.min(1, aggregate.weightedSimilarity / aggregate.weight) : 0;
+        const confidence = Math.min(1, Math.log2(attempts + 1) / 3);
+        const boost = clamp((expectedSuccess - 0.5) * 2 * similarity * confidence, -1, 1);
+        genes.push({ geneId, boost, expectedSuccess, successCount, failCount, attempts, similarity, lastAt: aggregate.lastAt });
+    }
+    genes.sort((left, right) => Math.abs(right.boost) - Math.abs(left.boost) || right.attempts - left.attempts || left.geneId.localeCompare(right.geneId));
+    return { genes: genes.slice(0, 64), diagnostics };
+}
+function boundedCount(value) {
+    if (!Number.isFinite(value) || value <= 0)
+        return 0;
+    return Math.min(1_000_000, Math.floor(value));
+}
+function jaccard(left, right) {
+    const a = new Set(normalizeMemorySignals(left));
+    const b = new Set(normalizeMemorySignals(right));
+    if (a.size === 0 && b.size === 0)
+        return 1;
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    let intersection = 0;
+    for (const value of a)
+        if (b.has(value))
+            intersection += 1;
+    return intersection / (a.size + b.size - intersection);
+}
+function decayWeight(at, nowMs) {
+    const timestamp = Date.parse(at);
+    if (!Number.isFinite(timestamp))
+        return 0;
+    const ageDays = Math.max(0, nowMs - timestamp) / 86_400_000;
+    return Math.pow(0.5, ageDays / HALF_LIFE_DAYS);
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}

package/dist/algo/orchestrator.d.ts

@@ -7,6 +7,7 @@ import type { GeneCandidateInput } from './geneSelection.js';
 import { CycleEngine, type CycleInput, type CycleResult, type SolidifyPermitGate } from './cycleEngine.js';
 import { type PendingSignalsContext } from '../assetstore/pendingSignals.js';
 import { type ReuseOutcomeSummary, type ReuseOutcomeEvent } from '../ops/reuseOutcomes.js';
+import type { MemoryGraphAdvice } from './memoryGraph.js';
 export interface RunCycleOptions {
     cycleId: string;
     problem: ProblemPattern;
@@ -60,6 +61,8 @@ export interface RunCycleOptions {
      * agent self-report) gains teeth on selection. Omit → no recall contribution. Never feeds quarantine.
      */
     recallEvents?: readonly ReuseOutcomeEvent[];
+    /** Scoped local MemoryGraph query result. Omit to keep selection unchanged. */
+    memoryGraphAdvice?: MemoryGraphAdvice;
 }
 /** Drive one full evolution cycle end-to-end: assemble candidates from the store, then run the cycle. */
 export declare function runEvolutionCycle(engine: CycleEngine, store: AssetStoreProvider, opts: RunCycleOptions): Promise<CycleResult>;

package/dist/algo/orchestrator.js

@@ -38,7 +38,18 @@ export async function runEvolutionCycle(engine, store, opts) {
         ...(opts.hubCandidates && opts.hubCandidates.length > 0 ? { hubCandidates: opts.hubCandidates } : {}),
         ...(reuseCounts.size > 0 ? { reuseCounts } : {}),
     };
-    const { candidates, distilledFallback, antiWarnings } = await assembleSelectionPool(store, signals, asmOpts);
+    const { candidates: assembledCandidates, distilledFallback, antiWarnings } = await assembleSelectionPool(store, signals, asmOpts);
+    const memoryByGene = new Map((opts.memoryGraphAdvice?.genes ?? []).map((evidence) => [evidence.geneId, evidence]));
+    const candidates = assembledCandidates.map((candidate) => {
+        const evidence = memoryByGene.get(candidate.geneId) ?? (candidate.assetId ? memoryByGene.get(candidate.assetId) : undefined);
+        return evidence ? { ...candidate, memoryBoost: evidence.boost } : candidate;
+    });
+    const memoryDistilledFallback = distilledFallback.map((candidate) => {
+        const evidence = memoryByGene.get(candidate.geneId) ?? (candidate.assetId ? memoryByGene.get(candidate.assetId) : undefined);
+        return evidence ? { ...candidate, memoryBoost: evidence.boost } : candidate;
+    });
+    const memoryEligible = [...candidates, ...memoryDistilledFallback];
+    const memoryEvidence = opts.memoryGraphAdvice?.genes.filter((evidence) => memoryEligible.some((candidate) => candidate.geneId === evidence.geneId || candidate.assetId === evidence.geneId)).slice(0, 3) ?? [];
     return engine.runCycle({
         cycleId: opts.cycleId,
         problem: opts.problem,
@@ -57,7 +68,8 @@ export async function runEvolutionCycle(engine, store, opts) {
         ...(opts.solidifyPermit ? { solidifyPermit: opts.solidifyPermit } : {}),
         // #97: forward the distilled-gene fallback pool so a no-signal-match cycle reuses a distilled strategy
         // (instead of a blind innovate) when nothing clears the floor.
-        ...(distilledFallback.length > 0 ? { distilledFallback } : {}),
+        ...(memoryDistilledFallback.length > 0 ? { distilledFallback: memoryDistilledFallback } : {}),
         ...(antiWarnings.length > 0 ? { antiWarnings } : {}),
+        ...(memoryEvidence.length > 0 ? { memoryEvidence } : {}),
     });
 }

package/dist/assetstore/assetSidecarRecords.d.ts

@@ -0,0 +1,23 @@
+import type { AssetSyncRecord } from './assetSyncLedger.js';
+import type { ProvenanceRecord } from './provenance.js';
+import type { ReviewRecord } from './reviewLedger.js';
+export type AssetSidecarKind = 'provenance' | 'review' | 'asset-sync';
+export type AssetSidecarCorruptionReason = 'invalid_row' | 'unterminated';
+export interface ParsedSidecarJsonl<T> {
+    records: T[];
+    rows: number;
+    validRows: number;
+    corruptRows: number;
+    unterminated: boolean;
+}
+export declare class CorruptAssetSidecarError extends Error {
+    readonly sidecar: AssetSidecarKind;
+    readonly reason: AssetSidecarCorruptionReason;
+    readonly code = "CORRUPT_ASSET_SIDECAR";
+    constructor(sidecar: AssetSidecarKind, reason: AssetSidecarCorruptionReason);
+}
+export declare function parseSidecarJsonl<T>(raw: string, parseRecord: (value: unknown) => T | null): ParsedSidecarJsonl<T>;
+export declare function assertTrustSidecarHealthy<T>(sidecar: Extract<AssetSidecarKind, 'provenance' | 'review'>, parsed: ParsedSidecarJsonl<T>): void;
+export declare function parseProvenanceRecord(value: unknown): ProvenanceRecord | null;
+export declare function parseReviewRecord(value: unknown): ReviewRecord | null;
+export declare function parseAssetSyncRecord(value: unknown): AssetSyncRecord | null;