@evomap/evolver-core 2.0.0-beta.0

package/dist/personality/drift.js

@@ -0,0 +1,106 @@
+import { normalizePersonalityState } from './schema.js';
+/**
+ * 何时/如何小步变异人格 (v1 proposeMutations / shouldTriggerPersonalityMutation + mutation.js 的信号判定端口).
+ * 这是"自调参"的规则引擎: 根据信号/失败连击提出对人格向量的小 nudge, 由 applyPersonalityMutations 落地.
+ */
+/** 机会信号: 表示"有创新余地"而非只是修 bug (v1 OPPORTUNITY_SIGNALS). */
+export const OPPORTUNITY_SIGNALS = [
+    'user_feature_request',
+    'user_improvement_suggestion',
+    'perf_bottleneck',
+    'capability_gap',
+    'stable_success_plateau',
+    'external_opportunity',
+    'recurring_error',
+    'unsupported_input_type',
+    'evolution_stagnation_detected',
+    'repair_loop_detected',
+    'force_innovation_after_repair_loop',
+    'tool_bypass',
+    'curriculum_target',
+    'issue_already_resolved',
+    'openclaw_self_healed',
+    'empty_cycle_loop_detected',
+];
+const ERROR_INDICATORS = ['log_error', 'error', 'exception', 'failed', 'unstable'];
+function asStrings(signals) {
+    return Array.isArray(signals) ? signals.map((s) => String(s ?? '')) : [];
+}
+/** signals 里是否有机会信号 (精确名或 `name:` 前缀). */
+export function hasOpportunitySignal(signals) {
+    const list = asStrings(signals);
+    return OPPORTUNITY_SIGNALS.some((name) => list.includes(name) || list.some((s) => s.startsWith(`${name}:`)));
+}
+/** signals 里是否有错误类信号 (但 issue_already_resolved / openclaw_self_healed 例外为 false). */
+export function hasErrorishSignal(signals) {
+    const list = asStrings(signals);
+    if (list.includes('issue_already_resolved') || list.includes('openclaw_self_healed'))
+        return false;
+    return list.some((sig) => {
+        const s = sig.toLowerCase();
+        return ERROR_INDICATORS.includes(s) || s.startsWith('errsig:') || s.startsWith('errsig_norm:');
+    });
+}
+/**
+ * 依上下文提出一组人格变异 (v1 proposeMutations). 分支优先级:
+ *  drift → 提创造性(风险回夹) / protocol_drift → 提服从&严谨 / 错误 → 提严谨降风险 /
+ *  机会 → 提创造性&风险 / 否则(平台期) → 微提创造性降啰嗦.
+ * 若 obedience 已饱和(≥0.95), 把服从类变异换成创造性.
+ */
+export function proposeMutations(input) {
+    const s = normalizePersonalityState(input.baseState);
+    const sig = asStrings(input.signals);
+    const r = String(input.reason ?? '');
+    const mk = (param, delta, reason) => ({ type: 'PersonalityMutation', param, delta, reason });
+    const muts = [];
+    if (input.driftEnabled) {
+        muts.push(mk('creativity', +0.1, r || 'drift enabled'));
+        muts.push(mk('risk_tolerance', -0.05, 'drift safety clamp'));
+    }
+    else if (sig.includes('protocol_drift')) {
+        muts.push(mk('obedience', +0.1, r || 'protocol drift'));
+        muts.push(mk('rigor', +0.05, 'tighten protocol compliance'));
+    }
+    else if (sig.includes('log_error') || sig.some((x) => x.startsWith('errsig:') || x.startsWith('errsig_norm:'))) {
+        muts.push(mk('rigor', +0.1, r || 'repair instability'));
+        muts.push(mk('risk_tolerance', -0.1, 'reduce risky changes under errors'));
+    }
+    else if (hasOpportunitySignal(sig)) {
+        muts.push(mk('creativity', +0.1, r || 'opportunity signal detected'));
+        muts.push(mk('risk_tolerance', +0.05, 'allow exploration for innovation'));
+    }
+    else {
+        muts.push(mk('creativity', +0.05, r || 'plateau creativity nudge'));
+        muts.push(mk('verbosity', -0.05, 'reduce noise'));
+    }
+    if (s.obedience >= 0.95) {
+        const idx = muts.findIndex((m) => m.param === 'obedience');
+        if (idx >= 0)
+            muts[idx] = mk('creativity', +0.05, 'obedience saturated');
+    }
+    return muts;
+}
+/**
+ * 是否该触发一次人格变异 (v1 shouldTriggerPersonalityMutation):
+ *  - driftEnabled ⇒ 总触发
+ *  - 最近 6 事件里, 后 4 个有 ≥3 个 failed ⇒ 长失败连击
+ *  - 带 mutation_id 的最近 3 个事件全 failed ⇒ 变异连续失败
+ */
+export function shouldTriggerPersonalityMutation(args) {
+    if (args.driftEnabled)
+        return { ok: true, reason: 'drift enabled' };
+    const tail = (Array.isArray(args.recentEvents) ? args.recentEvents : []).slice(-6);
+    const outcomes = tail.map((e) => (e?.outcome?.status ? String(e.outcome.status) : null)).filter((x) => x != null);
+    if (outcomes.length >= 4) {
+        const recentFailed = outcomes.slice(-4).filter((x) => x === 'failed').length;
+        if (recentFailed >= 3)
+            return { ok: true, reason: 'long failure streak' };
+    }
+    const withMut = tail.filter((e) => typeof e?.mutationId === 'string' && e.mutationId);
+    if (withMut.length >= 3) {
+        const fail3 = withMut.slice(-3).filter((e) => e?.outcome?.status === 'failed').length;
+        if (fail3 >= 3)
+            return { ok: true, reason: 'mutation consecutive failures' };
+    }
+    return { ok: false, reason: '' };
+}

package/dist/personality/events.d.ts

@@ -0,0 +1,25 @@
+import type { Ingestor } from '../events/ingest.js';
+import type { RootEvent } from '../events/eventSchema.js';
+import { type PersonalityState } from './schema.js';
+import type { GateResult } from './riskGate.js';
+/**
+ * PersonalityState 用途③(可审计): 人格相关变更进事件流.
+ * 这里只覆盖 PR-1 两类事件 —— 选定人格 / 风险闸降级; 统计回写与 pivot 属 PR-2.
+ * 传薄 Ingestor 接口 (只用 ingest), 不反向依赖 cycleEngine.
+ */
+export type PersonalityIngestor = Pick<Ingestor, 'ingest'>;
+/** 记录本轮选用的人格状态 (注入 prompt 前). */
+export declare function emitPersonalitySelected(ingestor: PersonalityIngestor, args: {
+    cycleId: string;
+    personality: PersonalityState;
+    known: boolean;
+}): Promise<RootEvent>;
+/**
+ * 记录风险闸对变异的降级 (仅当真降级了才发; downgraded=false 不发).
+ * why 必填 —— 让"Why 面板"能解释这次变异为何被压。
+ */
+export declare function emitPersonalityRiskGated(ingestor: PersonalityIngestor, args: {
+    cycleId: string;
+    personality: PersonalityState;
+    gate: GateResult;
+}): Promise<RootEvent | null>;

package/dist/personality/events.js

@@ -0,0 +1,37 @@
+import { personalityKey } from './schema.js';
+/** 记录本轮选用的人格状态 (注入 prompt 前). */
+export async function emitPersonalitySelected(ingestor, args) {
+    const key = personalityKey(args.personality);
+    return ingestor.ingest({
+        type: 'personality.selected',
+        human: {
+            title: `人格 ${key}`,
+            detail: `rigor=${args.personality.rigor.toFixed(2)} creativity=${args.personality.creativity.toFixed(2)} risk=${args.personality.risk_tolerance.toFixed(2)}`,
+        },
+        payload: { cycleId: args.cycleId, personalityKey: key, personalityState: args.personality, known: args.known },
+    });
+}
+/**
+ * 记录风险闸对变异的降级 (仅当真降级了才发; downgraded=false 不发).
+ * why 必填 —— 让"Why 面板"能解释这次变异为何被压。
+ */
+export async function emitPersonalityRiskGated(ingestor, args) {
+    if (!args.gate.downgraded)
+        return null;
+    const m = args.gate.mutation;
+    return ingestor.ingest({
+        type: 'personality.risk_gated',
+        human: {
+            title: `风险闸降级 → ${m.category}/${m.risk_level}`,
+            why: `人格 ${personalityKey(args.personality)} 未满足高危放行 (rigor≥0.6 且 risk_tolerance≤0.5); 安全信号: ${args.gate.appliedSignals.join(', ')}`,
+            severity: 'notice',
+        },
+        payload: {
+            cycleId: args.cycleId,
+            mutationId: m.id,
+            category: m.category,
+            riskLevel: m.risk_level,
+            appliedSignals: args.gate.appliedSignals,
+        },
+    });
+}

package/dist/personality/evolveOps.d.ts

@@ -0,0 +1,20 @@
+import type { RootEvent } from '../events/eventSchema.js';
+import type { PersonalityIngestor } from './events.js';
+import type { PersonalityStore } from './store.js';
+import { type SelectInput, type SelectResult } from './select.js';
+import { type UpdateStatsInput, type UpdateStatsResult } from './stats.js';
+import { type ForcePivotInput, type ForcePivotResult } from './pivot.js';
+export interface EvolveDeps {
+    store: PersonalityStore;
+    /** 可选: 传了就把变更记进事件流 (personality.mutated / stats_updated / pivoted). */
+    ingestor?: PersonalityIngestor;
+    /** 关联的 cycle (进 payload, 便于回溯). */
+    cycleId?: string;
+}
+/** 每轮开始: 选人格 (自然选择 + 触发变异), 落盘, 发 personality.mutated (仅当真有变异). */
+export declare function applySelectForRun(deps: EvolveDeps, input?: SelectInput): Promise<SelectResult>;
+/** 每轮结束: 把 outcome/score 回写到对应人格桶, 落盘, 发 personality.stats_updated. */
+export declare function applyStatsUpdate(deps: EvolveDeps, input: UpdateStatsInput): Promise<UpdateStatsResult>;
+/** 平台期: 强制转向到探索模式, 落盘, 发 personality.pivoted. */
+export declare function applyForcePivot(deps: EvolveDeps, input: Omit<ForcePivotInput, 'base'>): Promise<ForcePivotResult>;
+export type { RootEvent };

package/dist/personality/evolveOps.js

@@ -0,0 +1,93 @@
+import { selectPersonalityForRun } from './select.js';
+import { updatePersonalityStats } from './stats.js';
+import { forcePivot } from './pivot.js';
+import { personalityKey } from './schema.js';
+/**
+ * store-backed 进化算子 (PR-2): 把纯函数 select/stats/pivot 接到持久化 + 事件流.
+ * 每个算子: load model → 跑纯函数 → save → emit 事件 (可审计). 事件 emit best-effort, 不阻断进化.
+ */
+/** 事件 human.title 有 80 字上限 (humanNarrative schema); personalityKey 约 65 字, 塞不进标题.
+ *  标题只放紧凑摘要 (rigor/creativity/risk 三主轴), 完整 key + 全状态进 payload. */
+function briefState(s) {
+    return `r${s.rigor.toFixed(1)} c${s.creativity.toFixed(1)} k${s.risk_tolerance.toFixed(1)}`;
+}
+/** 每轮开始: 选人格 (自然选择 + 触发变异), 落盘, 发 personality.mutated (仅当真有变异). */
+export async function applySelectForRun(deps, input = {}) {
+    const model = deps.store.load();
+    const result = selectPersonalityForRun(model, input);
+    deps.store.save(result.model);
+    if (deps.ingestor && result.mutations.length > 0) {
+        await deps.ingestor.ingest({
+            type: 'personality.mutated',
+            human: {
+                title: `人格自调参 (${briefState(result.state)})`,
+                why: result.meta.triggered
+                    ? `触发变异: ${result.meta.triggered.reason}${result.meta.bestKnownKey ? `; 向最佳桶 ${result.meta.bestKnownKey} 靠拢` : ''}`
+                    : `向最佳已知桶 ${result.meta.bestKnownKey} 靠拢 (自然选择)`,
+                severity: 'notice',
+            },
+            payload: {
+                cycleId: deps.cycleId ?? null,
+                personalityKey: result.key,
+                personalityState: result.state,
+                mutations: result.mutations,
+                meta: result.meta,
+            },
+        });
+    }
+    return result;
+}
+/** 每轮结束: 把 outcome/score 回写到对应人格桶, 落盘, 发 personality.stats_updated. */
+export async function applyStatsUpdate(deps, input) {
+    const model = deps.store.load();
+    const result = updatePersonalityStats(model, input, deps.store.nowIso());
+    deps.store.save(result.model);
+    if (deps.ingestor) {
+        await deps.ingestor.ingest({
+            type: 'personality.stats_updated',
+            human: { title: `人格统计回写 ${String(input.outcome)} (${result.entry.success}✓/${result.entry.fail}✗)` },
+            payload: {
+                cycleId: deps.cycleId ?? null,
+                personalityKey: result.key,
+                outcome: String(input.outcome),
+                score: input.score ?? null,
+                entry: result.entry,
+            },
+        });
+    }
+    return result;
+}
+/** 平台期: 强制转向到探索模式, 落盘, 发 personality.pivoted. */
+export async function applyForcePivot(deps, input) {
+    const model = deps.store.load();
+    const result = forcePivot({ ...input, base: model.current });
+    const at = deps.store.nowIso();
+    const key = personalityKey(result.state);
+    deps.store.save({
+        ...model,
+        current: result.state,
+        history: [
+            ...model.history,
+            { at, key, outcome: `pivot_${result.severity}`, score: null, notes: `Forced pivot after ${input.evalsSinceImprovement ?? 0} non-improving evals` },
+        ],
+    });
+    if (deps.ingestor) {
+        await deps.ingestor.ingest({
+            type: 'personality.pivoted',
+            human: {
+                title: `人格强制转向 ${result.severity} (${briefState(result.state)})`,
+                why: `平台期 ${input.evalsSinceImprovement ?? 0} 轮无改进; 拉高 creativity/risk_tolerance 进入探索`,
+                severity: result.severity === 'required' ? 'warn' : 'notice',
+            },
+            payload: {
+                cycleId: deps.cycleId ?? null,
+                severity: result.severity,
+                evalsSinceImprovement: input.evalsSinceImprovement ?? 0,
+                personalityKey: key,
+                personalityState: result.state,
+                mutations: result.mutations,
+            },
+        });
+    }
+    return result;
+}

package/dist/personality/index.d.ts

@@ -0,0 +1,11 @@
+export * from './schema.js';
+export * from './mutate.js';
+export * from './riskGate.js';
+export * from './prompt.js';
+export * from './store.js';
+export * from './events.js';
+export * from './stats.js';
+export * from './drift.js';
+export * from './pivot.js';
+export * from './select.js';
+export * from './evolveOps.js';

package/dist/personality/index.js

@@ -0,0 +1,11 @@
+export * from './schema.js';
+export * from './mutate.js';
+export * from './riskGate.js';
+export * from './prompt.js';
+export * from './store.js';
+export * from './events.js';
+export * from './stats.js';
+export * from './drift.js';
+export * from './pivot.js';
+export * from './select.js';
+export * from './evolveOps.js';

package/dist/personality/mutate.d.ts

@@ -0,0 +1,21 @@
+import { type PersonalityMutation, type PersonalityState } from './schema.js';
+/** 单次变异的最大幅度 (v1 硬夹, 防人格被一步推飞). */
+export declare const MAX_MUTATION_DELTA = 0.2;
+/** 单次 apply 最多落地几条变异 (v1: 每周期最多 2 条, 防漂移). */
+export declare const MAX_MUTATIONS_PER_APPLY = 2;
+export interface AppliedMutation extends PersonalityMutation {
+    type: 'PersonalityMutation';
+}
+export interface ApplyResult {
+    state: PersonalityState;
+    applied: AppliedMutation[];
+}
+/**
+ * 把一组变异提案落到人格状态上 (v1 applyPersonalityMutations 端口).
+ * - 只认合法轴, 非数 delta 跳过
+ * - 每条 delta 夹到 ±MAX_MUTATION_DELTA
+ * - 落地后每轴仍夹回 [0,1]
+ * - 最多落 MAX_MUTATIONS_PER_APPLY 条 (超出忽略)
+ * 纯函数: 不改入参, 返回新状态 + 实际落地的变异列表.
+ */
+export declare function applyPersonalityMutations(state: unknown, mutations: readonly PersonalityMutation[] | undefined): ApplyResult;

package/dist/personality/mutate.js

@@ -0,0 +1,39 @@
+import { clamp01, normalizePersonalityState, } from './schema.js';
+/** 单次变异的最大幅度 (v1 硬夹, 防人格被一步推飞). */
+export const MAX_MUTATION_DELTA = 0.2;
+/** 单次 apply 最多落地几条变异 (v1: 每周期最多 2 条, 防漂移). */
+export const MAX_MUTATIONS_PER_APPLY = 2;
+/**
+ * 把一组变异提案落到人格状态上 (v1 applyPersonalityMutations 端口).
+ * - 只认合法轴, 非数 delta 跳过
+ * - 每条 delta 夹到 ±MAX_MUTATION_DELTA
+ * - 落地后每轴仍夹回 [0,1]
+ * - 最多落 MAX_MUTATIONS_PER_APPLY 条 (超出忽略)
+ * 纯函数: 不改入参, 返回新状态 + 实际落地的变异列表.
+ */
+export function applyPersonalityMutations(state, mutations) {
+    const cur = normalizePersonalityState(state);
+    const applied = [];
+    for (const m of mutations ?? []) {
+        if (applied.length >= MAX_MUTATIONS_PER_APPLY)
+            break;
+        if (!m || typeof m !== 'object')
+            continue;
+        const param = m.param;
+        // param 是五轴枚举 (schema z.enum(PERSONALITY_AXES)) — 天然排除 'type'; in 检查兜底手改数据.
+        if (!(param in cur))
+            continue;
+        const delta = Number(m.delta);
+        if (!Number.isFinite(delta))
+            continue;
+        const clipped = Math.max(-MAX_MUTATION_DELTA, Math.min(MAX_MUTATION_DELTA, delta));
+        cur[param] = clamp01(cur[param] + clipped);
+        applied.push({
+            type: 'PersonalityMutation',
+            param,
+            delta: clipped,
+            reason: String(m.reason ?? '').slice(0, 140),
+        });
+    }
+    return { state: cur, applied };
+}

package/dist/personality/pivot.d.ts

@@ -0,0 +1,23 @@
+import { type AppliedMutation } from './mutate.js';
+import { type PersonalityState, type PersonalityStateInput } from './schema.js';
+/**
+ * 平台期强制转向 (v1 forcePivot 端口): 检测到长期无改进时, 临时拉高创造性 + 风险容忍进入探索模式.
+ * 纯函数 —— 返回新状态 + 实际落地的变异 (仍受 applyPersonalityMutations 的 ±0.2 夹取与最多 2 条约束);
+ * 是否持久化 / 记事件由调用方 (orchestrator / cycleEngine 接线) 决定.
+ */
+export type PivotSeverity = 'suggested' | 'required';
+export interface ForcePivotInput {
+    base: PersonalityStateInput;
+    severity?: PivotSeverity;
+    evalsSinceImprovement?: number;
+}
+export interface ForcePivotResult {
+    state: PersonalityState;
+    mutations: AppliedMutation[];
+    severity: PivotSeverity;
+}
+/**
+ * required: creativity +0.2 / risk_tolerance +0.15 (更激进)
+ * suggested: creativity +0.15 / risk_tolerance +0.1
+ */
+export declare function forcePivot(input: ForcePivotInput): ForcePivotResult;

package/dist/personality/pivot.js

@@ -0,0 +1,22 @@
+import { applyPersonalityMutations } from './mutate.js';
+import { normalizePersonalityState } from './schema.js';
+/**
+ * required: creativity +0.2 / risk_tolerance +0.15 (更激进)
+ * suggested: creativity +0.15 / risk_tolerance +0.1
+ */
+export function forcePivot(input) {
+    const severity = input.severity === 'required' ? 'required' : 'suggested';
+    const evals = Number(input.evalsSinceImprovement) || 0;
+    const mk = (param, delta, reason) => ({ type: 'PersonalityMutation', param, delta, reason });
+    const proposals = severity === 'required'
+        ? [
+            mk('creativity', +0.2, `forced_pivot_required (plateau ${evals} evals)`),
+            mk('risk_tolerance', +0.15, 'forced_pivot_exploration'),
+        ]
+        : [
+            mk('creativity', +0.15, `pivot_suggested (plateau ${evals} evals)`),
+            mk('risk_tolerance', +0.1, 'pivot_exploration_nudge'),
+        ];
+    const { state, applied } = applyPersonalityMutations(normalizePersonalityState(input.base), proposals);
+    return { state, mutations: applied, severity };
+}

package/dist/personality/prompt.d.ts

@@ -0,0 +1,6 @@
+import { type PersonalityStateInput } from './schema.js';
+/**
+ * 渲染人格块 (markdown), 供 renderExecPrompt 拼进 agent 指令.
+ * 末行显式声明高危变异是否被人格放行, 让 agent 与风险闸看到同一事实.
+ */
+export declare function renderPersonalityBlock(personality: PersonalityStateInput | null | undefined): string;

package/dist/personality/prompt.js

@@ -0,0 +1,62 @@
+import { normalizePersonalityState } from './schema.js';
+import { isHighRiskMutationAllowed } from './riskGate.js';
+/**
+ * PersonalityState 用途①: 注入每轮 GEP prompt, 决定进化"风格" (v1 src/gep/prompt.js 的人格块端口).
+ *
+ * 把 0..1 数值向量翻译成 agent 能照做的行为指令 —— 只影响"怎么做"(严谨/激进/啰嗦),
+ * 不改"做什么". 纯函数, 同输入同输出 (对齐 renderExecPrompt 的确定性契约).
+ */
+/** 三档定性: 数值 → low/mid/high (阈值与 v1 语感一致). */
+function band(x) {
+    if (x < 0.34)
+        return 'low';
+    if (x < 0.67)
+        return 'mid';
+    return 'high';
+}
+const RIGOR_HINT = {
+    low: 'move fast; skip exhaustive checks unless correctness is at stake',
+    mid: 'balance speed with verification',
+    high: 'be protocol-first and conservative; verify assumptions before acting',
+};
+const CREATIVITY_HINT = {
+    low: 'prefer the smallest proven change; do not explore alternatives',
+    mid: 'consider one alternative if the obvious path is weak',
+    high: 'actively explore novel approaches to escape local optima',
+};
+const VERBOSITY_HINT = {
+    low: 'keep output terse — minimal prose, no filler',
+    mid: 'explain the key decisions briefly',
+    high: 'document reasoning and trade-offs in detail',
+};
+const RISK_HINT = {
+    low: 'avoid risky or wide-reaching edits; stay well inside the blast radius',
+    mid: 'take bounded risks when the payoff is clear',
+    high: 'willing to take larger risks (subject to the safety gate)',
+};
+const OBEDIENCE_HINT = {
+    low: 'use judgment freely; deviate from convention when warranted',
+    mid: 'follow instructions, deviating only with good reason',
+    high: 'adhere strictly to instructions and established protocol',
+};
+/**
+ * 渲染人格块 (markdown), 供 renderExecPrompt 拼进 agent 指令.
+ * 末行显式声明高危变异是否被人格放行, 让 agent 与风险闸看到同一事实.
+ */
+export function renderPersonalityBlock(personality) {
+    const p = normalizePersonalityState(personality ?? {});
+    const pct = (n) => `${Math.round(n * 100)}%`;
+    const highRiskAllowed = isHighRiskMutationAllowed(p);
+    return [
+        '## Evolution style (personality)',
+        'Apply this behavioral posture to HOW you make the change (not what the change is):',
+        `- Rigor ${pct(p.rigor)}: ${RIGOR_HINT[band(p.rigor)]}`,
+        `- Creativity ${pct(p.creativity)}: ${CREATIVITY_HINT[band(p.creativity)]}`,
+        `- Verbosity ${pct(p.verbosity)}: ${VERBOSITY_HINT[band(p.verbosity)]}`,
+        `- Risk tolerance ${pct(p.risk_tolerance)}: ${RISK_HINT[band(p.risk_tolerance)]}`,
+        `- Obedience ${pct(p.obedience)}: ${OBEDIENCE_HINT[band(p.obedience)]}`,
+        highRiskAllowed
+            ? 'High-risk mutations are PERMITTED by the current personality (rigor≥0.6 and risk_tolerance≤0.5).'
+            : 'High-risk mutations are NOT permitted by the current personality — keep changes low/medium risk.',
+    ].join('\n');
+}

package/dist/personality/riskGate.d.ts

@@ -0,0 +1,42 @@
+import type { Mutation } from '../wire/index.js';
+import { type PersonalityStateInput } from './schema.js';
+/**
+ * 变异风险闸 (v1 src/gep/mutation.js 的 isHighRiskPersonality / isHighRiskMutationAllowed 端口).
+ * PersonalityState 用途②: 决定敢不敢放行高危/创新变异.
+ */
+/** rigor 低于此值即视为"高危人格". */
+export declare const HIGH_RISK_RIGOR_FLOOR = 0.5;
+/** risk_tolerance 高于此值即视为"高危人格". */
+export declare const HIGH_RISK_TOLERANCE_CEIL = 0.6;
+/** 放行 high-risk 变异要求的 rigor 下限. */
+export declare const ALLOW_HIGH_RISK_RIGOR_MIN = 0.6;
+/** 放行 high-risk 变异要求的 risk_tolerance 上限. */
+export declare const ALLOW_HIGH_RISK_TOLERANCE_MAX = 0.5;
+/**
+ * 保守定义: rigor 过低 或 risk_tolerance 过高 → 高危人格.
+ * 缺省(无人格)返回 false — 无信息不主动扣帽子, 交由下游默认策略.
+ */
+export declare function isHighRiskPersonality(p: PersonalityStateInput | null | undefined): boolean;
+/**
+ * high-risk 变异只在 rigor≥0.6 且 risk_tolerance≤0.5 放行 (任务用途②的硬阈值).
+ * 缺省(无人格)时按最保守假设处理: rigor=0, risk_tolerance=1 → 不放行.
+ */
+export declare function isHighRiskMutationAllowed(p: PersonalityStateInput | null | undefined): boolean;
+/** 安全信号: 追加到 Mutation.trigger_signals, 使降级在事件流里可审计. */
+export declare const SAFETY_SIGNAL_AVOID_INNOVATE = "safety:avoid_innovate_with_high_risk_personality";
+export declare const SAFETY_SIGNAL_DOWNGRADE_HIGH_RISK = "safety:downgrade_high_risk";
+export interface GateResult {
+    /** 经风险闸处理后的变异 (可能被降级); 原 mutation 不被改动. */
+    mutation: Mutation;
+    /** 是否发生降级. */
+    downgraded: boolean;
+    /** 追加的安全信号 (人类可读, 也进事件流). */
+    appliedSignals: string[];
+}
+/**
+ * 对一条待执行的变异施加人格风险闸 (v1 buildMutation 内两条硬安全约束的端口):
+ *  1. innovate + 高危人格 → 降级为 optimize/low (禁"高危人格 + 创新"组合)
+ *  2. high-risk 且人格不满足放行阈值 → 降一档到 medium
+ * 纯函数, 返回新 Mutation. cycleEngine 在 buildMutation 后调用它, 再 ingest mutation.built.
+ */
+export declare function gatePersonalityRisk(mutation: Mutation, personality: PersonalityStateInput | null | undefined): GateResult;

package/dist/personality/riskGate.js

@@ -0,0 +1,80 @@
+import { normalizePersonalityState } from './schema.js';
+/**
+ * 变异风险闸 (v1 src/gep/mutation.js 的 isHighRiskPersonality / isHighRiskMutationAllowed 端口).
+ * PersonalityState 用途②: 决定敢不敢放行高危/创新变异.
+ */
+/** rigor 低于此值即视为"高危人格". */
+export const HIGH_RISK_RIGOR_FLOOR = 0.5;
+/** risk_tolerance 高于此值即视为"高危人格". */
+export const HIGH_RISK_TOLERANCE_CEIL = 0.6;
+/** 放行 high-risk 变异要求的 rigor 下限. */
+export const ALLOW_HIGH_RISK_RIGOR_MIN = 0.6;
+/** 放行 high-risk 变异要求的 risk_tolerance 上限. */
+export const ALLOW_HIGH_RISK_TOLERANCE_MAX = 0.5;
+/**
+ * 保守定义: rigor 过低 或 risk_tolerance 过高 → 高危人格.
+ * 缺省(无人格)返回 false — 无信息不主动扣帽子, 交由下游默认策略.
+ */
+export function isHighRiskPersonality(p) {
+    if (!p)
+        return false;
+    const s = normalizePersonalityState(p);
+    if (s.rigor < HIGH_RISK_RIGOR_FLOOR)
+        return true;
+    if (s.risk_tolerance > HIGH_RISK_TOLERANCE_CEIL)
+        return true;
+    return false;
+}
+/**
+ * high-risk 变异只在 rigor≥0.6 且 risk_tolerance≤0.5 放行 (任务用途②的硬阈值).
+ * 缺省(无人格)时按最保守假设处理: rigor=0, risk_tolerance=1 → 不放行.
+ */
+export function isHighRiskMutationAllowed(p) {
+    const s = p ? normalizePersonalityState(p) : { rigor: 0, risk_tolerance: 1 };
+    return s.rigor >= ALLOW_HIGH_RISK_RIGOR_MIN && s.risk_tolerance <= ALLOW_HIGH_RISK_TOLERANCE_MAX;
+}
+/** 安全信号: 追加到 Mutation.trigger_signals, 使降级在事件流里可审计. */
+export const SAFETY_SIGNAL_AVOID_INNOVATE = 'safety:avoid_innovate_with_high_risk_personality';
+export const SAFETY_SIGNAL_DOWNGRADE_HIGH_RISK = 'safety:downgrade_high_risk';
+function uniq(arr) {
+    return [...new Set(arr)];
+}
+/**
+ * 对一条待执行的变异施加人格风险闸 (v1 buildMutation 内两条硬安全约束的端口):
+ *  1. innovate + 高危人格 → 降级为 optimize/low (禁"高危人格 + 创新"组合)
+ *  2. high-risk 且人格不满足放行阈值 → 降一档到 medium
+ * 纯函数, 返回新 Mutation. cycleEngine 在 buildMutation 后调用它, 再 ingest mutation.built.
+ */
+export function gatePersonalityRisk(mutation, personality) {
+    const signals = [];
+    let category = mutation.category;
+    let risk = mutation.risk_level;
+    let expected = mutation.expected_effect;
+    // 约束①: 高危人格下禁止 innovate — 降级为 optimize/low.
+    if (category === 'innovate' && isHighRiskPersonality(personality)) {
+        category = 'optimize';
+        risk = 'low';
+        expected = 'safety downgrade: optimize under high-risk personality (avoid innovate+high-risk combo)';
+        signals.push(SAFETY_SIGNAL_AVOID_INNOVATE);
+    }
+    // 约束②: high-risk 变异要满足放行阈值, 否则降到 medium.
+    if (risk === 'high' && !isHighRiskMutationAllowed(personality)) {
+        risk = 'medium';
+        signals.push(SAFETY_SIGNAL_DOWNGRADE_HIGH_RISK);
+    }
+    const downgraded = signals.length > 0;
+    if (!downgraded) {
+        return { mutation, downgraded: false, appliedSignals: [] };
+    }
+    return {
+        mutation: {
+            ...mutation,
+            category,
+            risk_level: risk,
+            expected_effect: expected,
+            trigger_signals: uniq([...mutation.trigger_signals, ...signals]),
+        },
+        downgraded: true,
+        appliedSignals: signals,
+    };
+}