@evomap/evolver-core 2.0.0-beta.0

package/dist/personality/store.js

@@ -0,0 +1,92 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { acquireLock, releaseLock } from '../util/fileLock.js';
+import { personalityStatePath } from '../events/paths.js';
+import { DEFAULT_PERSONALITY, normalizePersonalityState, personalityKey, personalityModel, } from './schema.js';
+/** history 上限 (v1 slice(-120) 同值; 防文件无界增长). */
+export const HISTORY_LIMIT = 120;
+/** 全新默认模型 (无持久文件时的种子). */
+export function defaultPersonalityModel(now = Date.now) {
+    return personalityModel.parse({
+        version: 1,
+        current: { ...DEFAULT_PERSONALITY },
+        stats: {},
+        history: [],
+        updatedAt: new Date(now()).toISOString(),
+    });
+}
+/**
+ * 可进化人格模型的持久化 (v1 loadPersonalityModel / savePersonalityModel 端口).
+ * - load: 缺失/空/损坏文件 → 回落默认模型 (绝不抛; 人格是软状态, 读坏不该崩进化循环)
+ * - save: tmp+rename 原子替换, 跨进程 O_EXCL 锁串行化 (对齐 EventStore / localJsonl 的写法)
+ * current 恒被 normalize 到合法五维, stats/history 恒是合法形状.
+ */
+export class PersonalityStore {
+    path;
+    lockPath;
+    now;
+    constructor(opts = {}) {
+        this.path = opts.path ?? personalityStatePath();
+        this.lockPath = `${this.path}.lock`;
+        this.now = opts.now ?? Date.now;
+    }
+    /** 读模型; 任何 I/O 或校验失败都回落默认 (不抛). */
+    load() {
+        if (!existsSync(this.path))
+            return defaultPersonalityModel(this.now);
+        let raw;
+        try {
+            const text = readFileSync(this.path, 'utf8');
+            if (!text.trim())
+                return defaultPersonalityModel(this.now);
+            raw = JSON.parse(text);
+        }
+        catch {
+            return defaultPersonalityModel(this.now);
+        }
+        const parsed = personalityModel.safeParse(raw);
+        if (parsed.success) {
+            // current 再夹一层, 防手改文件塞进越界值绕过 min/max (safeParse 已挡, 双保险).
+            return { ...parsed.data, current: normalizePersonalityState(parsed.data.current) };
+        }
+        // 部分损坏: 尽量抢救 current, 其余回默认.
+        const seed = defaultPersonalityModel(this.now);
+        const cur = raw?.current;
+        return { ...seed, current: normalizePersonalityState(cur ?? DEFAULT_PERSONALITY) };
+    }
+    /** 原子落盘 (规范化 + history 截断 + 刷 updatedAt). 返回实际写入的模型. */
+    save(model) {
+        const out = personalityModel.parse({
+            version: 1,
+            current: normalizePersonalityState(model.current),
+            stats: model.stats ?? {},
+            history: (model.history ?? []).slice(-HISTORY_LIMIT),
+            updatedAt: new Date(this.now()).toISOString(),
+            extensions: model.extensions ?? {},
+        });
+        mkdirSync(dirname(this.path), { recursive: true });
+        acquireLock(this.lockPath);
+        try {
+            const tmp = `${this.path}.tmp`;
+            writeFileSync(tmp, `${JSON.stringify(out, null, 2)}\n`, 'utf8');
+            renameSync(tmp, this.path); // atomic replace; 崩在中途原文件不动
+        }
+        finally {
+            releaseLock(this.lockPath);
+        }
+        return out;
+    }
+    /** 读当前人格 (便捷). */
+    currentState() {
+        return this.load().current;
+    }
+    /** 桶键 (便捷). */
+    currentKey() {
+        return personalityKey(this.load().current);
+    }
+    /** 当前时间的 ISO 串 (走注入时钟) —— 供进化算子给 stats/history/事件打时间戳. */
+    nowIso() {
+        return new Date(this.now()).toISOString();
+    }
+}
+export { personalityStatePath };

package/dist/schema/common.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+/** evolver-core 内部 domain schema 版本 (与 gep-sdk SCHEMA_VERSION 解耦). */
+export declare const DOMAIN_SCHEMA_VERSION = "1.0.0";
+/** ULID (26 char Crockford base32). */
+export declare const ulid: z.ZodString;
+export declare const sha256Hash: z.ZodString;
+/** 防过早冻结的扩展字段 (军杰 §11). */
+export declare const extensions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+/** 大对象走 artifact 引用. */
+export declare const artifactRef: z.ZodObject<{
+    path: z.ZodString;
+    sha256: z.ZodString;
+    size: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    sha256: string;
+    size: number;
+}, {
+    path: string;
+    sha256: string;
+    size: number;
+}>;
+export type ArtifactRef = z.infer<typeof artifactRef>;
+/** runtime 来源 (D11). 'generic-chat' = 任何输出标准 OpenAI/Anthropic messages 的 AI(经 genericChatAdapter 接入). */
+export declare const sourceAgent: z.ZodEnum<["claude-code", "codex", "cursor", "gemini", "kimi", "kiro", "opencode", "generic-chat"]>;
+export type SourceAgent = z.infer<typeof sourceAgent>;
+export declare const blastRadius: z.ZodEnum<["file", "module", "package", "system"]>;
+export type BlastRadius = z.infer<typeof blastRadius>;

package/dist/schema/common.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+/** evolver-core 内部 domain schema 版本 (与 gep-sdk SCHEMA_VERSION 解耦). */
+export const DOMAIN_SCHEMA_VERSION = '1.0.0';
+/** ULID (26 char Crockford base32). */
+export const ulid = z.string().regex(/^[0-9A-HJKMNP-TV-Z]{26}$/, 'invalid ULID');
+export const sha256Hash = z.string().regex(/^sha256:[a-f0-9]{64}$/, 'invalid sha256');
+/** 防过早冻结的扩展字段 (军杰 §11). */
+export const extensions = z.record(z.string(), z.unknown()).default({});
+/** 大对象走 artifact 引用. */
+export const artifactRef = z.object({
+    path: z.string(),
+    sha256: z.string(),
+    size: z.number().int().nonnegative(),
+});
+/** runtime 来源 (D11). 'generic-chat' = 任何输出标准 OpenAI/Anthropic messages 的 AI(经 genericChatAdapter 接入). */
+export const sourceAgent = z.enum(['claude-code', 'codex', 'cursor', 'gemini', 'kimi', 'kiro', 'opencode', 'generic-chat']);
+export const blastRadius = z.enum(['file', 'module', 'package', 'system']);

package/dist/schema/index.d.ts

@@ -0,0 +1,5 @@
+export * from './common.js';
+export * from './material.js';
+export * from './signal.js';
+export * from './problem.js';
+export * from './proofOfWork.js';

package/dist/schema/index.js

@@ -0,0 +1,5 @@
+export * from './common.js';
+export * from './material.js';
+export * from './signal.js';
+export * from './problem.js';
+export * from './proofOfWork.js';

package/dist/schema/material.d.ts

@@ -0,0 +1,201 @@
+import { z } from 'zod';
+/** 去重 watermark (批注#15): (path,mtime,size)+contentHash 兜底. */
+export declare const watermark: z.ZodObject<{
+    path: z.ZodString;
+    mtime: z.ZodNumber;
+    size: z.ZodNumber;
+    contentHash: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    size: number;
+    mtime: number;
+    contentHash?: string | undefined;
+}, {
+    path: string;
+    size: number;
+    mtime: number;
+    contentHash?: string | undefined;
+}>;
+export type Watermark = z.infer<typeof watermark>;
+/** 进化原材料 (环境). 来自 runtime session/tool 日志, 或 agent-无关的 proxy LLM-trace (#95). */
+export declare const material: z.ZodEffects<z.ZodObject<{
+    materialId: z.ZodString;
+    /** Runtime agent that produced a session/tool source. Absent for agent-agnostic origins (proxy trace), #95. */
+    sourceAgent: z.ZodOptional<z.ZodEnum<["claude-code", "codex", "cursor", "gemini", "kimi", "kiro", "opencode", "generic-chat"]>>;
+    /** Origin class: a runtime agent session, or the proxy gateway's LLM trace (agent-agnostic), #95.
+     *  Defaults to runtime_session so pre-#95 records (which only ever held sessions) parse unchanged. */
+    sourceKind: z.ZodDefault<z.ZodEnum<["runtime_session", "proxy_trace"]>>;
+    sourcePath: z.ZodString;
+    kind: z.ZodEnum<["session_log", "tool_event", "llm_trace"]>;
+    watermark: z.ZodObject<{
+        path: z.ZodString;
+        mtime: z.ZodNumber;
+        size: z.ZodNumber;
+        contentHash: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        size: number;
+        mtime: number;
+        contentHash?: string | undefined;
+    }, {
+        path: string;
+        size: number;
+        mtime: number;
+        contentHash?: string | undefined;
+    }>;
+    capturedAt: z.ZodString;
+    consumerGroup: z.ZodString;
+    payloadRef: z.ZodOptional<z.ZodObject<{
+        path: z.ZodString;
+        sha256: z.ZodString;
+        size: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        sha256: string;
+        size: number;
+    }, {
+        path: string;
+        sha256: string;
+        size: number;
+    }>>;
+    payload: z.ZodOptional<z.ZodUnknown>;
+    feedsMaterial: z.ZodDefault<z.ZodBoolean>;
+    extensions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    materialId: string;
+    sourceKind: "runtime_session" | "proxy_trace";
+    sourcePath: string;
+    kind: "session_log" | "tool_event" | "llm_trace";
+    watermark: {
+        path: string;
+        size: number;
+        mtime: number;
+        contentHash?: string | undefined;
+    };
+    capturedAt: string;
+    consumerGroup: string;
+    feedsMaterial: boolean;
+    extensions: Record<string, unknown>;
+    sourceAgent?: "claude-code" | "codex" | "cursor" | "gemini" | "kimi" | "kiro" | "opencode" | "generic-chat" | undefined;
+    payloadRef?: {
+        path: string;
+        sha256: string;
+        size: number;
+    } | undefined;
+    payload?: unknown;
+}, {
+    materialId: string;
+    sourcePath: string;
+    kind: "session_log" | "tool_event" | "llm_trace";
+    watermark: {
+        path: string;
+        size: number;
+        mtime: number;
+        contentHash?: string | undefined;
+    };
+    capturedAt: string;
+    consumerGroup: string;
+    sourceAgent?: "claude-code" | "codex" | "cursor" | "gemini" | "kimi" | "kiro" | "opencode" | "generic-chat" | undefined;
+    sourceKind?: "runtime_session" | "proxy_trace" | undefined;
+    payloadRef?: {
+        path: string;
+        sha256: string;
+        size: number;
+    } | undefined;
+    payload?: unknown;
+    feedsMaterial?: boolean | undefined;
+    extensions?: Record<string, unknown> | undefined;
+}>, {
+    materialId: string;
+    sourceKind: "runtime_session" | "proxy_trace";
+    sourcePath: string;
+    kind: "session_log" | "tool_event" | "llm_trace";
+    watermark: {
+        path: string;
+        size: number;
+        mtime: number;
+        contentHash?: string | undefined;
+    };
+    capturedAt: string;
+    consumerGroup: string;
+    feedsMaterial: boolean;
+    extensions: Record<string, unknown>;
+    sourceAgent?: "claude-code" | "codex" | "cursor" | "gemini" | "kimi" | "kiro" | "opencode" | "generic-chat" | undefined;
+    payloadRef?: {
+        path: string;
+        sha256: string;
+        size: number;
+    } | undefined;
+    payload?: unknown;
+}, {
+    materialId: string;
+    sourcePath: string;
+    kind: "session_log" | "tool_event" | "llm_trace";
+    watermark: {
+        path: string;
+        size: number;
+        mtime: number;
+        contentHash?: string | undefined;
+    };
+    capturedAt: string;
+    consumerGroup: string;
+    sourceAgent?: "claude-code" | "codex" | "cursor" | "gemini" | "kimi" | "kiro" | "opencode" | "generic-chat" | undefined;
+    sourceKind?: "runtime_session" | "proxy_trace" | undefined;
+    payloadRef?: {
+        path: string;
+        sha256: string;
+        size: number;
+    } | undefined;
+    payload?: unknown;
+    feedsMaterial?: boolean | undefined;
+    extensions?: Record<string, unknown> | undefined;
+}>;
+export type Material = z.infer<typeof material>;
+/** 增量读取游标 (硬化 A14): 与 Material 解耦. */
+export declare const sourceCursor: z.ZodObject<{
+    sourcePath: z.ZodString;
+    consumerGroup: z.ZodString;
+    byteOffset: z.ZodDefault<z.ZodNumber>;
+    lineSeq: z.ZodDefault<z.ZodNumber>;
+    lastWatermark: z.ZodOptional<z.ZodObject<{
+        path: z.ZodString;
+        mtime: z.ZodNumber;
+        size: z.ZodNumber;
+        contentHash: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        size: number;
+        mtime: number;
+        contentHash?: string | undefined;
+    }, {
+        path: string;
+        size: number;
+        mtime: number;
+        contentHash?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    sourcePath: string;
+    consumerGroup: string;
+    byteOffset: number;
+    lineSeq: number;
+    lastWatermark?: {
+        path: string;
+        size: number;
+        mtime: number;
+        contentHash?: string | undefined;
+    } | undefined;
+}, {
+    sourcePath: string;
+    consumerGroup: string;
+    byteOffset?: number | undefined;
+    lineSeq?: number | undefined;
+    lastWatermark?: {
+        path: string;
+        size: number;
+        mtime: number;
+        contentHash?: string | undefined;
+    } | undefined;
+}>;
+export type SourceCursor = z.infer<typeof sourceCursor>;
+/** Material payload inline 上限 (硬化 B): 超走 artifact 引用. */
+export declare const MATERIAL_PAYLOAD_INLINE_MAX_BYTES: number;

package/dist/schema/material.js

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { ulid, extensions, artifactRef, sourceAgent } from './common.js';
+/** 去重 watermark (批注#15): (path,mtime,size)+contentHash 兜底. */
+export const watermark = z.object({
+    path: z.string(),
+    mtime: z.number(),
+    size: z.number().int().nonnegative(),
+    contentHash: z.string().optional(),
+});
+/** 进化原材料 (环境). 来自 runtime session/tool 日志, 或 agent-无关的 proxy LLM-trace (#95). */
+export const material = z.object({
+    materialId: ulid,
+    /** Runtime agent that produced a session/tool source. Absent for agent-agnostic origins (proxy trace), #95. */
+    sourceAgent: sourceAgent.optional(),
+    /** Origin class: a runtime agent session, or the proxy gateway's LLM trace (agent-agnostic), #95.
+     *  Defaults to runtime_session so pre-#95 records (which only ever held sessions) parse unchanged. */
+    sourceKind: z.enum(['runtime_session', 'proxy_trace']).default('runtime_session'),
+    sourcePath: z.string(),
+    kind: z.enum(['session_log', 'tool_event', 'llm_trace']), // 双吃分级 D17; llm_trace = proxy 网关遥测 (#95)
+    watermark,
+    capturedAt: z.string().datetime(),
+    consumerGroup: z.string(),
+    payloadRef: artifactRef.optional(),
+    payload: z.unknown().optional(), // <=64KB inline; 超走 payloadRef (硬化 B)
+    feedsMaterial: z.boolean().default(true),
+    extensions,
+}).superRefine((m, ctx) => {
+    // Origin self-consistency (#95): a runtime session must name its agent; an agent-agnostic proxy trace must
+    // NOT carry one (there is no honest runtime-agent identity to record). Turns the convention into a hard gate.
+    if (m.sourceKind === 'runtime_session' && !m.sourceAgent)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['sourceAgent'], message: 'runtime_session material requires sourceAgent' });
+    if (m.sourceKind === 'proxy_trace' && m.sourceAgent)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['sourceAgent'], message: 'proxy_trace material is agent-agnostic and must not carry sourceAgent' });
+    // kind ↔ origin (#100 bugbot): llm_trace is proxy-only; runtime sessions are session_log/tool_event. Without
+    // this, a record could be llm_trace yet runtime_session+agent, contradicting the agent-agnostic trace model.
+    if (m.sourceKind === 'proxy_trace' && m.kind !== 'llm_trace')
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['kind'], message: 'proxy_trace material must have kind llm_trace' });
+    if (m.sourceKind === 'runtime_session' && m.kind === 'llm_trace')
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['kind'], message: 'llm_trace kind is proxy-only; a runtime_session cannot be llm_trace' });
+});
+/** 增量读取游标 (硬化 A14): 与 Material 解耦. */
+export const sourceCursor = z.object({
+    sourcePath: z.string(),
+    consumerGroup: z.string(),
+    byteOffset: z.number().int().nonnegative().default(0),
+    lineSeq: z.number().int().nonnegative().default(0),
+    lastWatermark: watermark.optional(),
+});
+/** Material payload inline 上限 (硬化 B): 超走 artifact 引用. */
+export const MATERIAL_PAYLOAD_INLINE_MAX_BYTES = 64 * 1024;

package/dist/schema/problem.d.ts

@@ -0,0 +1,160 @@
+import { z } from 'zod';
+/** value 命名因子, 禁黑盒 (军杰 §5.3). */
+export declare const valueFactors: z.ZodObject<{
+    severity: z.ZodDefault<z.ZodNumber>;
+    reach: z.ZodDefault<z.ZodNumber>;
+    strategicFit: z.ZodDefault<z.ZodNumber>;
+    novelty: z.ZodDefault<z.ZodNumber>;
+    costEst: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    severity: number;
+    reach: number;
+    strategicFit: number;
+    novelty: number;
+    costEst: number;
+}, {
+    severity?: number | undefined;
+    reach?: number | undefined;
+    strategicFit?: number | undefined;
+    novelty?: number | undefined;
+    costEst?: number | undefined;
+}>;
+export type ValueFactors = z.infer<typeof valueFactors>;
+export declare const problemPattern: z.ZodObject<{
+    id: z.ZodString;
+    signature: z.ZodString;
+    signatureV: z.ZodDefault<z.ZodNumber>;
+    firstSeenAt: z.ZodString;
+    lastSeenAt: z.ZodString;
+    occurrences: z.ZodDefault<z.ZodNumber>;
+    linkedSignals: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    resolvedBy: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    status: z.ZodDefault<z.ZodEnum<["open", "cooling", "resolved", "abandoned"]>>;
+    value: z.ZodDefault<z.ZodObject<{
+        severity: z.ZodDefault<z.ZodNumber>;
+        reach: z.ZodDefault<z.ZodNumber>;
+        strategicFit: z.ZodDefault<z.ZodNumber>;
+        novelty: z.ZodDefault<z.ZodNumber>;
+        costEst: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        severity: number;
+        reach: number;
+        strategicFit: number;
+        novelty: number;
+        costEst: number;
+    }, {
+        severity?: number | undefined;
+        reach?: number | undefined;
+        strategicFit?: number | undefined;
+        novelty?: number | undefined;
+        costEst?: number | undefined;
+    }>>;
+    consecutiveFailures: z.ZodDefault<z.ZodNumber>;
+    cooldownUntil: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    extensions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    value: {
+        severity: number;
+        reach: number;
+        strategicFit: number;
+        novelty: number;
+        costEst: number;
+    };
+    status: "open" | "cooling" | "resolved" | "abandoned";
+    extensions: Record<string, unknown>;
+    signatureV: number;
+    id: string;
+    signature: string;
+    firstSeenAt: string;
+    lastSeenAt: string;
+    occurrences: number;
+    linkedSignals: string[];
+    resolvedBy: string | null;
+    consecutiveFailures: number;
+    cooldownUntil: string | null;
+}, {
+    id: string;
+    signature: string;
+    firstSeenAt: string;
+    lastSeenAt: string;
+    value?: {
+        severity?: number | undefined;
+        reach?: number | undefined;
+        strategicFit?: number | undefined;
+        novelty?: number | undefined;
+        costEst?: number | undefined;
+    } | undefined;
+    status?: "open" | "cooling" | "resolved" | "abandoned" | undefined;
+    extensions?: Record<string, unknown> | undefined;
+    signatureV?: number | undefined;
+    occurrences?: number | undefined;
+    linkedSignals?: string[] | undefined;
+    resolvedBy?: string | null | undefined;
+    consecutiveFailures?: number | undefined;
+    cooldownUntil?: string | null | undefined;
+}>;
+export type ProblemPattern = z.infer<typeof problemPattern>;
+export declare const problemInstance: z.ZodObject<{
+    instanceId: z.ZodString;
+    signature: z.ZodString;
+    signatureV: z.ZodDefault<z.ZodNumber>;
+    occurredAt: z.ZodString;
+    linkedSignal: z.ZodOptional<z.ZodString>;
+    extensions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    extensions: Record<string, unknown>;
+    signatureV: number;
+    signature: string;
+    instanceId: string;
+    occurredAt: string;
+    linkedSignal?: string | undefined;
+}, {
+    signature: string;
+    instanceId: string;
+    occurredAt: string;
+    extensions?: Record<string, unknown> | undefined;
+    signatureV?: number | undefined;
+    linkedSignal?: string | undefined;
+}>;
+export type ProblemInstance = z.infer<typeof problemInstance>;
+/** 解法边界 = gene 唯一登场处 (军杰 §4.4). */
+export declare const resolutionScope: z.ZodObject<{
+    scopeId: z.ZodString;
+    targetProblems: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    proposedByGene: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    boundary: z.ZodObject<{
+        codePaths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        dataSurfaces: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        blastRadius: z.ZodDefault<z.ZodEnum<["file", "module", "package", "system"]>>;
+    }, "strip", z.ZodTypeAny, {
+        codePaths: string[];
+        dataSurfaces: string[];
+        blastRadius: "file" | "module" | "package" | "system";
+    }, {
+        codePaths?: string[] | undefined;
+        dataSurfaces?: string[] | undefined;
+        blastRadius?: "file" | "module" | "package" | "system" | undefined;
+    }>;
+    extensions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    extensions: Record<string, unknown>;
+    scopeId: string;
+    targetProblems: string[];
+    proposedByGene: string | null;
+    boundary: {
+        codePaths: string[];
+        dataSurfaces: string[];
+        blastRadius: "file" | "module" | "package" | "system";
+    };
+}, {
+    scopeId: string;
+    boundary: {
+        codePaths?: string[] | undefined;
+        dataSurfaces?: string[] | undefined;
+        blastRadius?: "file" | "module" | "package" | "system" | undefined;
+    };
+    extensions?: Record<string, unknown> | undefined;
+    targetProblems?: string[] | undefined;
+    proposedByGene?: string | null | undefined;
+}>;
+export type ResolutionScope = z.infer<typeof resolutionScope>;

package/dist/schema/problem.js

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { extensions, blastRadius } from './common.js';
+/** value 命名因子, 禁黑盒 (军杰 §5.3). */
+export const valueFactors = z.object({
+    severity: z.number().default(0),
+    reach: z.number().default(0),
+    strategicFit: z.number().default(0),
+    novelty: z.number().default(0),
+    costEst: z.number().default(0),
+});
+export const problemPattern = z.object({
+    id: z.string(),
+    signature: z.string(),
+    signatureV: z.number().int().positive().default(1),
+    firstSeenAt: z.string().datetime(),
+    lastSeenAt: z.string().datetime(),
+    occurrences: z.number().int().nonnegative().default(0),
+    linkedSignals: z.array(z.string()).default([]),
+    resolvedBy: z.string().nullable().default(null),
+    status: z.enum(['open', 'cooling', 'resolved', 'abandoned']).default('open'),
+    value: valueFactors.default({}),
+    consecutiveFailures: z.number().int().nonnegative().default(0),
+    cooldownUntil: z.string().datetime().nullable().default(null),
+    extensions,
+});
+export const problemInstance = z.object({
+    instanceId: z.string(),
+    signature: z.string(),
+    signatureV: z.number().int().positive().default(1),
+    occurredAt: z.string().datetime(),
+    linkedSignal: z.string().optional(),
+    extensions,
+});
+/** 解法边界 = gene 唯一登场处 (军杰 §4.4). */
+export const resolutionScope = z.object({
+    scopeId: z.string(),
+    targetProblems: z.array(z.string()).default([]),
+    proposedByGene: z.string().nullable().default(null),
+    boundary: z.object({
+        codePaths: z.array(z.string()).default([]),
+        dataSurfaces: z.array(z.string()).default([]),
+        blastRadius: blastRadius.default('module'),
+    }),
+    extensions,
+});