@evomap/evolver-core 2.0.0-beta.0 → 2.0.0-beta.10

package/dist/benchmark/triggerShift.d.ts

@@ -0,0 +1,62 @@
+export declare const TRIGGER_SHIFT_METHOD_VERSION = "trigger-shift-v1";
+/** @experimental Shift dimension for a semantically paired replay task. */
+export type TriggerShiftAxis = 'wrapper_trigger' | 'temporal_context' | 'instruction_phrasing';
+/** @experimental One replay prompt variant in a trigger-shift pair. */
+export interface TriggerShiftTask {
+    id: string;
+    prompt: string;
+    wrapperTrigger?: string;
+    temporalContext?: string;
+    instructionPhrasing?: string;
+}
+/** @experimental Same objective, paired across one trigger/context shift axis. */
+export interface TriggerShiftPair {
+    id: string;
+    objectiveId: string;
+    axis: TriggerShiftAxis;
+    expectedDecision: string;
+    train: TriggerShiftTask;
+    shifted: TriggerShiftTask;
+}
+/** @experimental Policy output normalized for replay scoring. */
+export interface TriggerShiftDecision {
+    label: string;
+    confidence?: number;
+}
+/** @experimental Replay-only policy seam; callers own any model/tool execution. */
+export interface TriggerShiftPolicy {
+    id: string;
+    predict(task: TriggerShiftTask): TriggerShiftDecision;
+}
+/** @experimental One paired replay result with train/shifted rewards and gap. */
+export interface TriggerShiftPairResult {
+    pairId: string;
+    objectiveId: string;
+    axis: TriggerShiftAxis;
+    trainTaskId: string;
+    shiftedTaskId: string;
+    expectedDecision: string;
+    trainDecision: string;
+    shiftedDecision: string;
+    trainReward: number;
+    shiftedReward: number;
+    gap: number;
+}
+/** @experimental Aggregate replay report; diagnostic only, not a selector input. */
+export interface TriggerShiftReport {
+    methodVersion: string;
+    policyId: string;
+    pairs: number;
+    meanTrainReward: number;
+    meanShiftedReward: number;
+    meanGap: number;
+    maxGap: number;
+    rows: TriggerShiftPairResult[];
+}
+/**
+ * @experimental Offline trigger-shift replay evaluator. It returns inert report
+ * rows only: no trigger fires, no store writes, and no live selection updates.
+ */
+export declare function evaluateTriggerShift(policy: TriggerShiftPolicy, pairs: readonly TriggerShiftPair[]): TriggerShiftReport;
+/** @experimental Tiny public calibration/demo suite; not a live threshold. */
+export declare function smallTriggerShiftSuite(): TriggerShiftPair[];

package/dist/benchmark/triggerShift.js

@@ -0,0 +1,106 @@
+// Offline replay guard for trigger/context overfitting. Keep this module pure:
+// no trigger fires, no store writes, and no live selection feedback.
+export const TRIGGER_SHIFT_METHOD_VERSION = 'trigger-shift-v1';
+function labelReward(predicted, expected) {
+    return predicted.trim() === expected.trim() ? 1 : 0;
+}
+function decisionLabel(decision) {
+    return decision.label.trim();
+}
+function mean(values) {
+    if (values.length === 0)
+        return 0;
+    return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+/**
+ * @experimental Offline trigger-shift replay evaluator. It returns inert report
+ * rows only: no trigger fires, no store writes, and no live selection updates.
+ */
+export function evaluateTriggerShift(policy, pairs) {
+    const rows = pairs.map((pair) => {
+        const train = policy.predict(pair.train);
+        const shifted = policy.predict(pair.shifted);
+        const trainDecision = decisionLabel(train);
+        const shiftedDecision = decisionLabel(shifted);
+        const trainReward = labelReward(trainDecision, pair.expectedDecision);
+        const shiftedReward = labelReward(shiftedDecision, pair.expectedDecision);
+        return {
+            pairId: pair.id,
+            objectiveId: pair.objectiveId,
+            axis: pair.axis,
+            trainTaskId: pair.train.id,
+            shiftedTaskId: pair.shifted.id,
+            expectedDecision: pair.expectedDecision,
+            trainDecision,
+            shiftedDecision,
+            trainReward,
+            shiftedReward,
+            gap: trainReward - shiftedReward,
+        };
+    });
+    const trainRewards = rows.map((row) => row.trainReward);
+    const shiftedRewards = rows.map((row) => row.shiftedReward);
+    const gaps = rows.map((row) => row.gap);
+    return {
+        methodVersion: TRIGGER_SHIFT_METHOD_VERSION,
+        policyId: policy.id,
+        pairs: rows.length,
+        meanTrainReward: mean(trainRewards),
+        meanShiftedReward: mean(shiftedRewards),
+        meanGap: mean(gaps),
+        maxGap: gaps.length === 0 ? 0 : Math.max(...gaps),
+        rows,
+    };
+}
+/** @experimental Tiny public calibration/demo suite; not a live threshold. */
+export function smallTriggerShiftSuite() {
+    return [
+        {
+            id: 'wrapper-timeout-retry',
+            objectiveId: 'safe-timeout-retry',
+            axis: 'wrapper_trigger',
+            expectedDecision: 'repair_timeout_source',
+            train: {
+                id: 'train-wrapper-timeout-retry',
+                prompt: 'EVOLVER_TRIGGER: timeout retry loop. Fix the timeout source instead of adding more retries.',
+                wrapperTrigger: 'EVOLVER_TRIGGER',
+            },
+            shifted: {
+                id: 'shifted-wrapper-timeout-retry',
+                prompt: 'A service keeps retrying after timeouts. Fix the timeout source instead of adding more retries.',
+            },
+        },
+        {
+            id: 'temporal-cache-invalidation',
+            objectiveId: 'safe-cache-invalidation',
+            axis: 'temporal_context',
+            expectedDecision: 'repair_cache_invalidation',
+            train: {
+                id: 'train-temporal-cache-invalidation',
+                prompt: 'In yesterday\'s deploy, stale cache entries survived invalidation. Repair the invalidation path.',
+                temporalContext: 'yesterday deploy',
+            },
+            shifted: {
+                id: 'shifted-temporal-cache-invalidation',
+                prompt: 'In the next release candidate, stale cache entries may survive invalidation. Repair the invalidation path.',
+                temporalContext: 'next release candidate',
+            },
+        },
+        {
+            id: 'phrasing-safe-help',
+            objectiveId: 'constructive-safe-help',
+            axis: 'instruction_phrasing',
+            expectedDecision: 'provide_safe_steps',
+            train: {
+                id: 'train-phrasing-safe-help',
+                prompt: 'Answer constructively with safe constraints: explain how to rotate an exposed API key.',
+                instructionPhrasing: 'constructive constraints',
+            },
+            shifted: {
+                id: 'shifted-phrasing-safe-help',
+                prompt: 'Do not over-refuse: give practical, safe steps to rotate an exposed API key.',
+                instructionPhrasing: 'avoid over-refusal',
+            },
+        },
+    ];
+}

package/dist/events/eventArchive.d.ts

@@ -0,0 +1,65 @@
+import { type RootEvent } from './eventSchema.js';
+export declare const ROOT_EVENT_ARCHIVE_DEFAULT_KEEP_EVENTS = 10000;
+export declare class InvalidRootEventLogError extends Error {
+    readonly line: number;
+    readonly code = "ROOT_EVENT_ARCHIVE_INVALID_LOG";
+    constructor(line: number, reason: string);
+}
+export declare class ArchiveSegmentConflictError extends Error {
+    readonly archiveId: string;
+    readonly code = "ROOT_EVENT_ARCHIVE_SEGMENT_CONFLICT";
+    constructor(archiveId: string);
+}
+export declare class InvalidRootEventArchiveError extends Error {
+    readonly segment: string;
+    readonly line: number;
+    readonly code = "ROOT_EVENT_ARCHIVE_INVALID_ARCHIVE";
+    constructor(segment: string, line: number);
+}
+export declare class RootEventHistoryGapError extends Error {
+    readonly expectedSeq: number;
+    readonly actualSeq: number;
+    readonly code = "ROOT_EVENT_HISTORY_GAP";
+    constructor(expectedSeq: number, actualSeq: number);
+}
+export interface RootEventArchiveOptions {
+    path: string;
+    keepEvents?: number;
+}
+export interface RootEventArchivePlan {
+    mode: 'preview';
+    activeRecords: number;
+    keepEvents: number;
+    wouldArchive: number;
+    retainedRecords: number;
+    firstSeq: number | null;
+    lastSeq: number | null;
+    archiveId: string | null;
+}
+export interface RootEventArchiveResult {
+    mode: 'write';
+    activeRecordsBefore: number;
+    keepEvents: number;
+    archivedRecords: number;
+    retainedRecords: number;
+    firstSeq: number | null;
+    lastSeq: number | null;
+    archiveId: string | null;
+    reusedSegment: boolean;
+}
+export interface RootEventArchiveStats {
+    exists: boolean;
+    segments: number;
+    bytes: number;
+    records: number;
+    invalidLines: number;
+    firstSeq: number | null;
+    lastSeq: number | null;
+}
+export declare function rootEventArchiveDir(path: string): string;
+export declare function rootEventArchiveSegmentName(firstSeq: number, lastSeq: number): string;
+export declare function planRootEventArchive(opts: RootEventArchiveOptions): RootEventArchivePlan;
+export declare function archiveRootEvents(opts: RootEventArchiveOptions): RootEventArchiveResult;
+export declare function readRootEventHistory(path: string, archiveDir?: string): RootEvent[];
+export declare function validateRootEventHistory(path: string): void;
+export declare function inspectRootEventArchive(path: string): RootEventArchiveStats;

package/dist/events/eventArchive.js

@@ -0,0 +1,343 @@
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, writeSync, } from 'node:fs';
+import { basename, dirname, extname, join } from 'node:path';
+import { acquireLock, releaseLock } from '../util/fileLock.js';
+import { rootEvent } from './eventSchema.js';
+export const ROOT_EVENT_ARCHIVE_DEFAULT_KEEP_EVENTS = 10_000;
+const SEGMENT_PATTERN = /^root-events-(\d{16})-(\d{16})\.jsonl$/;
+export class InvalidRootEventLogError extends Error {
+    line;
+    code = 'ROOT_EVENT_ARCHIVE_INVALID_LOG';
+    constructor(line, reason) {
+        super(`root event archive refused invalid active log at line ${line}: ${reason}`);
+        this.line = line;
+        this.name = 'InvalidRootEventLogError';
+    }
+}
+export class ArchiveSegmentConflictError extends Error {
+    archiveId;
+    code = 'ROOT_EVENT_ARCHIVE_SEGMENT_CONFLICT';
+    constructor(archiveId) {
+        super(`root event archive segment ${archiveId} already exists with different content`);
+        this.archiveId = archiveId;
+        this.name = 'ArchiveSegmentConflictError';
+    }
+}
+export class InvalidRootEventArchiveError extends Error {
+    segment;
+    line;
+    code = 'ROOT_EVENT_ARCHIVE_INVALID_ARCHIVE';
+    constructor(segment, line) {
+        super(`root event archive segment ${segment} is invalid at line ${line}`);
+        this.segment = segment;
+        this.line = line;
+        this.name = 'InvalidRootEventArchiveError';
+    }
+}
+export class RootEventHistoryGapError extends Error {
+    expectedSeq;
+    actualSeq;
+    code = 'ROOT_EVENT_HISTORY_GAP';
+    constructor(expectedSeq, actualSeq) {
+        super(`root event history expected seq ${expectedSeq} but found ${actualSeq}`);
+        this.expectedSeq = expectedSeq;
+        this.actualSeq = actualSeq;
+        this.name = 'RootEventHistoryGapError';
+    }
+}
+export function rootEventArchiveDir(path) {
+    const ext = extname(path);
+    const stem = ext.length > 0 ? basename(path, ext) : basename(path);
+    return join(dirname(path), `${stem}.archive`);
+}
+export function rootEventArchiveSegmentName(firstSeq, lastSeq) {
+    return `root-events-${String(firstSeq).padStart(16, '0')}-${String(lastSeq).padStart(16, '0')}.jsonl`;
+}
+export function planRootEventArchive(opts) {
+    const keepEvents = normalizeKeepEvents(opts.keepEvents);
+    const active = readActiveStrict(opts.path);
+    const wouldArchive = Math.max(0, active.length - keepEvents);
+    const prefix = active.slice(0, wouldArchive);
+    readValidatedArchive(opts.path, active);
+    const firstSeq = prefix[0]?.event.seq ?? null;
+    const lastSeq = prefix[prefix.length - 1]?.event.seq ?? null;
+    return {
+        mode: 'preview',
+        activeRecords: active.length,
+        keepEvents,
+        wouldArchive,
+        retainedRecords: active.length - wouldArchive,
+        firstSeq,
+        lastSeq,
+        archiveId: firstSeq === null || lastSeq === null ? null : `${firstSeq}-${lastSeq}`,
+    };
+}
+export function archiveRootEvents(opts) {
+    const keepEvents = normalizeKeepEvents(opts.keepEvents);
+    const lockPath = `${opts.path}.lock`;
+    mkdirSync(dirname(opts.path), { recursive: true });
+    acquireLock(lockPath);
+    try {
+        const active = readActiveStrict(opts.path);
+        const archivedRecords = Math.max(0, active.length - keepEvents);
+        const prefix = active.slice(0, archivedRecords);
+        const tail = active.slice(archivedRecords);
+        const firstSeq = prefix[0]?.event.seq ?? null;
+        const lastSeq = prefix[prefix.length - 1]?.event.seq ?? null;
+        const archiveId = firstSeq === null || lastSeq === null ? null : `${firstSeq}-${lastSeq}`;
+        let reusedSegment = false;
+        const archivedBySeq = readValidatedArchive(opts.path, active);
+        if (archiveId !== null && firstSeq !== null && lastSeq !== null) {
+            const archiveDir = rootEventArchiveDir(opts.path);
+            const missing = [];
+            for (const line of prefix) {
+                const archived = archivedBySeq.get(line.event.seq);
+                if (archived === undefined) {
+                    missing.push(line);
+                    continue;
+                }
+                if (JSON.stringify(archived) !== JSON.stringify(line.event)) {
+                    throw new ArchiveSegmentConflictError(String(line.event.seq));
+                }
+                reusedSegment = true;
+            }
+            for (const segment of contiguousGroups(missing)) {
+                const missingFirstSeq = segment[0].event.seq;
+                const missingLastSeq = segment[segment.length - 1].event.seq;
+                const archiveBytes = serializeLines(segment);
+                mkdirSync(archiveDir, { recursive: true });
+                const segmentPath = join(archiveDir, rootEventArchiveSegmentName(missingFirstSeq, missingLastSeq));
+                if (existsSync(segmentPath))
+                    throw new ArchiveSegmentConflictError(`${missingFirstSeq}-${missingLastSeq}`);
+                durableReplace(`${segmentPath}.tmp`, segmentPath, archiveBytes);
+                fsyncDirectoryBestEffort(archiveDir);
+            }
+            durableReplace(`${opts.path}.archive.tmp`, opts.path, serializeLines(tail));
+            fsyncDirectoryBestEffort(dirname(opts.path));
+        }
+        return {
+            mode: 'write',
+            activeRecordsBefore: active.length,
+            keepEvents,
+            archivedRecords,
+            retainedRecords: tail.length,
+            firstSeq,
+            lastSeq,
+            archiveId,
+            reusedSegment,
+        };
+    }
+    finally {
+        releaseLock(lockPath);
+    }
+}
+export function readRootEventHistory(path, archiveDir = rootEventArchiveDir(path)) {
+    const bySeq = new Map();
+    for (const file of archiveSegmentFiles(archiveDir)) {
+        for (const event of readEventsLenient(join(archiveDir, file))) {
+            // Archive segments are immutable: the first segment in canonical order owns a seq. A later conflicting
+            // segment cannot silently replace it during operational reads. Strict validation still reports the
+            // conflict and blocks archive writes.
+            if (!bySeq.has(event.seq))
+                bySeq.set(event.seq, event);
+        }
+    }
+    // Preserve the pre-archive fail-soft behavior for routine commands. The active log is the current writer
+    // source, so it deterministically wins an active/archive conflict without crashing status/report readers.
+    for (const event of readEventsLenient(path))
+        bySeq.set(event.seq, event);
+    return [...bySeq.values()].sort((a, b) => a.seq - b.seq);
+}
+export function validateRootEventHistory(path) {
+    const active = readActiveStrict(path);
+    readValidatedArchive(path, active);
+}
+export function inspectRootEventArchive(path) {
+    const archiveDir = rootEventArchiveDir(path);
+    const files = archiveSegmentFiles(archiveDir);
+    let bytes = 0;
+    let records = 0;
+    let invalidLines = 0;
+    let firstSeq = null;
+    let lastSeq = null;
+    for (const file of files) {
+        const raw = readFileSync(join(archiveDir, file), 'utf8');
+        bytes += Buffer.byteLength(raw, 'utf8');
+        for (const line of raw.split('\n')) {
+            if (line.length === 0)
+                continue;
+            try {
+                const event = rootEvent.parse(JSON.parse(line));
+                firstSeq ??= event.seq;
+                lastSeq = event.seq;
+                records += 1;
+            }
+            catch {
+                invalidLines += 1;
+            }
+        }
+    }
+    return {
+        exists: files.length > 0,
+        segments: files.length,
+        bytes,
+        records,
+        invalidLines,
+        firstSeq,
+        lastSeq,
+    };
+}
+function readActiveStrict(path) {
+    if (!existsSync(path))
+        return [];
+    const out = [];
+    const lines = readFileSync(path, 'utf8').split('\n');
+    let previousSeq = null;
+    for (let index = 0; index < lines.length; index += 1) {
+        const raw = lines[index];
+        if (raw.length === 0)
+            continue;
+        let event;
+        try {
+            event = rootEvent.parse(JSON.parse(raw));
+        }
+        catch {
+            throw new InvalidRootEventLogError(index + 1, 'invalid json or event schema');
+        }
+        if (previousSeq !== null && event.seq !== previousSeq + 1) {
+            throw new InvalidRootEventLogError(index + 1, 'seq must be contiguous and strictly increasing');
+        }
+        previousSeq = event.seq;
+        out.push({ event, raw });
+    }
+    return out;
+}
+function readEventsLenient(path) {
+    if (!existsSync(path))
+        return [];
+    const out = [];
+    for (const line of readFileSync(path, 'utf8').split('\n')) {
+        if (line.length === 0)
+            continue;
+        try {
+            out.push(rootEvent.parse(JSON.parse(line)));
+        }
+        catch {
+            // Active reads retain the existing crash-tail behavior. Strict archive writes refuse these lines.
+        }
+    }
+    return out;
+}
+function archiveSegmentFiles(archiveDir) {
+    if (!existsSync(archiveDir))
+        return [];
+    return readdirSync(archiveDir).filter((entry) => SEGMENT_PATTERN.test(entry)).sort();
+}
+function readArchivedEventsStrict(archiveDir) {
+    const out = new Map();
+    for (const file of archiveSegmentFiles(archiveDir)) {
+        const lines = readFileSync(join(archiveDir, file), 'utf8').split('\n');
+        let previousSeq = null;
+        for (let index = 0; index < lines.length; index += 1) {
+            const line = lines[index];
+            if (line.length === 0)
+                continue;
+            let event;
+            try {
+                event = rootEvent.parse(JSON.parse(line));
+            }
+            catch {
+                throw new InvalidRootEventArchiveError(file, index + 1);
+            }
+            if (previousSeq !== null && event.seq !== previousSeq + 1) {
+                throw new InvalidRootEventArchiveError(file, index + 1);
+            }
+            previousSeq = event.seq;
+            const current = out.get(event.seq);
+            if (current !== undefined && JSON.stringify(current) !== JSON.stringify(event)) {
+                throw new ArchiveSegmentConflictError(String(event.seq));
+            }
+            out.set(event.seq, event);
+        }
+    }
+    return out;
+}
+function readValidatedArchive(path, active) {
+    const archived = readArchivedEventsStrict(rootEventArchiveDir(path));
+    for (const line of active) {
+        const existing = archived.get(line.event.seq);
+        if (existing !== undefined && JSON.stringify(existing) !== JSON.stringify(line.event)) {
+            throw new ArchiveSegmentConflictError(String(line.event.seq));
+        }
+    }
+    assertContinuousHistory(archived, active);
+    return archived;
+}
+function assertContinuousHistory(archived, active) {
+    const seqs = new Set(archived.keys());
+    for (const line of active)
+        seqs.add(line.event.seq);
+    const ordered = [...seqs].sort((left, right) => left - right);
+    if (ordered.length === 0)
+        return;
+    let expected = 1;
+    for (const actual of ordered) {
+        if (actual !== expected)
+            throw new RootEventHistoryGapError(expected, actual);
+        expected += 1;
+    }
+}
+function contiguousGroups(lines) {
+    const groups = [];
+    for (const line of lines) {
+        const current = groups[groups.length - 1];
+        const previous = current?.[current.length - 1];
+        if (current === undefined || previous === undefined || line.event.seq !== previous.event.seq + 1) {
+            groups.push([line]);
+        }
+        else {
+            current.push(line);
+        }
+    }
+    return groups;
+}
+function serializeLines(lines) {
+    return lines.length === 0 ? '' : `${lines.map((line) => line.raw).join('\n')}\n`;
+}
+function durableReplace(tmpPath, finalPath, contents) {
+    let fd = null;
+    try {
+        fd = openSync(tmpPath, 'w', 0o600);
+        writeSync(fd, contents, undefined, 'utf8');
+        fsyncSync(fd);
+        closeSync(fd);
+        fd = null;
+        renameSync(tmpPath, finalPath);
+    }
+    catch (error) {
+        if (fd !== null)
+            closeSync(fd);
+        rmSync(tmpPath, { force: true });
+        throw error;
+    }
+}
+function fsyncDirectoryBestEffort(path) {
+    let fd = null;
+    try {
+        fd = openSync(path, 'r');
+        fsyncSync(fd);
+    }
+    catch {
+        // Windows and some filesystems do not support fsync on directories.
+    }
+    finally {
+        if (fd !== null)
+            closeSync(fd);
+    }
+}
+function normalizeKeepEvents(value) {
+    if (value === undefined)
+        return ROOT_EVENT_ARCHIVE_DEFAULT_KEEP_EVENTS;
+    if (!Number.isFinite(value) || value < 1)
+        throw new RangeError('keepEvents must be a positive integer');
+    return Math.floor(value);
+}

package/dist/events/eventStore.js

@@ -2,6 +2,7 @@ import { openSync, writeSync, fsyncSync, closeSync, statSync, readSync, mkdirSyn
 import { dirname } from 'node:path';
 import { monotonicFactory } from 'ulid';
 import { acquireLock, releaseLock } from '../util/fileLock.js';
+import { readRootEventHistory } from './eventArchive.js';
 // Monotonic ULIDs: plain ulid() randomizes the low 80 bits, so two ids minted in the SAME millisecond can sort
 // out of order — the event log wants time-sortable eventIds (and a flaky CI test proved it). The monotonic
 // factory increments within a millisecond, guaranteeing each successive eventId is strictly greater.
@@ -73,18 +74,7 @@ export class EventStore {
     }
     /** 读全部事件 (跳过尾部半行/损坏行). */
     readAll() {
-        if (!existsSync(this.path))
-            return [];
-        const out = [];
-        for (const l of readFileSync(this.path, 'utf8').split('\n')) {
-            if (!l)
-                continue;
-            try {
-                out.push(rootEvent.parse(JSON.parse(l)));
-            }
-            catch { /* 崩溃半行: 跳过 */ }
-        }
-        return out;
+        return readRootEventHistory(this.path);
     }
     *iterate(fromSeq = 0) {
         for (const e of this.readAll())

package/dist/events/ingest.d.ts

@@ -2,7 +2,7 @@ import { EventStore, type EventStoreOptions } from './eventStore.js';
 import type { RawEvent, RootEvent } from './eventSchema.js';
 import type { EventSink } from './sink.js';
 /** 已知事件类型 (军杰 §9; 可 registerEventType 扩展). */
-export declare const EVENT_TYPES: readonly ["cycle.started", "cycle.signals_collected", "cycle.solidified", "cycle.failed", "cycle.aborted", "cycle.heartbeat", "cycle.consumed", "decision.gene_selected", "decision.triggered", "decision.suppressed", "personality.selected", "personality.risk_gated", "personality.mutated", "personality.stats_updated", "personality.pivoted", "signals.extracted", "mutation.built", "capsule.produced", "evolution_event.projected", "observer.quarantined", "observer.dead_letter", "actor.human.nudge", "actor.human.intervene", "actor.human.teach", "actor.human.observe", "actor.human.review.approve", "actor.human.review.reject", "gene.distilled", "gene.distill_shadowed", "anti_gene.distilled", "anti_gene.distill_shadowed", "anti_gene.benchmark_result", "anti_gene.rollout_result", "reflection.recorded", "material.batch_ready", "value.reuse_hit", "value.inject", "value.reuse_outcome", "value.recall"];
+export declare const EVENT_TYPES: readonly ["cycle.started", "cycle.signals_collected", "cycle.solidified", "cycle.failed", "cycle.aborted", "cycle.heartbeat", "cycle.consumed", "decision.gene_selected", "decision.triggered", "decision.suppressed", "personality.selected", "personality.risk_gated", "personality.mutated", "personality.stats_updated", "personality.pivoted", "signals.extracted", "mutation.built", "capsule.produced", "evolution_event.projected", "observer.quarantined", "observer.dead_letter", "actor.human.nudge", "actor.human.intervene", "actor.human.teach", "actor.human.observe", "actor.human.review.approve", "actor.human.review.reject", "actor.human.trust.promote", "actor.human.trust.revoke", "actor.human.sidecar.recover", "gene.distilled", "gene.distill_shadowed", "anti_gene.distilled", "anti_gene.distill_shadowed", "anti_gene.benchmark_result", "anti_gene.rollout_result", "reflection.recorded", "material.batch_ready", "value.reuse_hit", "value.inject", "value.reuse_outcome", "value.recall"];
 export type EventType = (typeof EVENT_TYPES)[number];
 export declare function registerEventType(t: string): void;
 export declare function isKnownEventType(t: string): boolean;

package/dist/events/ingest.js

@@ -1,4 +1,6 @@
+import { dirname, join } from 'node:path';
 import { EventStore } from './eventStore.js';
+import { createIssueDraftForEventBestEffort } from '../issueReporter/index.js';
 /** 已知事件类型 (军杰 §9; 可 registerEventType 扩展). */
 export const EVENT_TYPES = [
     'cycle.started', 'cycle.signals_collected', 'cycle.solidified', 'cycle.failed',
@@ -10,6 +12,8 @@ export const EVENT_TYPES = [
     'observer.quarantined', 'observer.dead_letter',
     'actor.human.nudge', 'actor.human.intervene', 'actor.human.teach', 'actor.human.observe',
     'actor.human.review.approve', 'actor.human.review.reject',
+    'actor.human.trust.promote', 'actor.human.trust.revoke',
+    'actor.human.sidecar.recover',
     'gene.distilled', 'gene.distill_shadowed',
     'anti_gene.distilled', 'anti_gene.distill_shadowed',
     'anti_gene.benchmark_result', 'anti_gene.rollout_result',
@@ -49,6 +53,11 @@ export class Ingestor {
         if (raw.actor?.kind === 'human' && !raw.actor.id)
             throw new IngestValidationError('actor.kind=human 必带 actor.id (审计, 军杰 §9.7)');
         const evt = await this.store.append(raw);
+        createIssueDraftForEventBestEffort(evt, {
+            rootDir: join(dirname(this.store.path), 'issue-reporter'),
+            workspaceScope: process.cwd(),
+            env: process.env,
+        });
         this.sink?.dispatch(evt);
         return evt;
     }

package/dist/events/paths.d.ts

@@ -1,22 +1,22 @@
 /** ~/.evomap, 可 EVOLVER_HOME/EVOMAP_HOME 覆盖. */
-export declare function evomapHome(): string;
-export declare function rootEventsPath(): string;
-export declare function mvDir(): string;
+export declare function evomapHome(env?: Readonly<Record<string, string | undefined>>): string;
+export declare function rootEventsPath(env?: Readonly<Record<string, string | undefined>>): string;
+export declare function mvDir(env?: Readonly<Record<string, string | undefined>>): string;
 /** 可进化人格模型持久化文件 (五维向量 + 各键统计 + 变更历史). v1 personality_state.json 的 v2 落点. */
-export declare function personalityStatePath(): string;
-export declare function assetsDir(): string;
+export declare function personalityStatePath(env?: Readonly<Record<string, string | undefined>>): string;
+export declare function assetsDir(env?: Readonly<Record<string, string | undefined>>): string;
 /** M1 raw-material substrate (append-only jsonl consumed by the cycle). */
-export declare function materialDir(): string;
+export declare function materialDir(env?: Readonly<Record<string, string | undefined>>): string;
 /** MaterialStore backing file. */
-export declare function materialStorePath(): string;
+export declare function materialStorePath(env?: Readonly<Record<string, string | undefined>>): string;
 /** Per-source watermark cursor used to make re-ingest idempotent (file-level dedup). */
-export declare function materialWatermarkPath(): string;
+export declare function materialWatermarkPath(env?: Readonly<Record<string, string | undefined>>): string;
 /** Proxy LLM-trace day-files dir (`llm-trace-YYYYMMDD.jsonl`), the route-savings source for the value ledger.
  *  Mirrors the proxy's EVOLVER_LLM_TRACE_DIR default so the outreach layer reads what the proxy wrote. */
-export declare function tracesDir(): string;
+export declare function tracesDir(env?: Readonly<Record<string, string | undefined>>): string;
 /** Hub-asset audit trail (`asset_call_log.jsonl`): one JSONL line per hub-asset interaction (search hit/miss,
  *  reuse/reference, publish, review). Written best-effort by AssetCallLog; the desktop's RecallHistory / 召回历程
  *  reads it. Defaults to the evomap home root, beside assets/ + evolution/.
  *  NOTE(reuse/#234): confirm this matches where the proxy/RecallHistory reads — best-effort append, so a path
  *  mismatch degrades the audit line, never the reuse write itself. */
-export declare function assetCallLogPath(): string;
+export declare function assetCallLogPath(env?: Readonly<Record<string, string | undefined>>): string;