@evomap/evolver-core 2.0.0-beta.17 → 2.0.0-beta.19

package/dist/strategy/constraintAblationPredicates.js

@@ -0,0 +1,339 @@
+const FACTUAL_TAIL_PREFIX_TERMS = new Set([
+    'after', 'although', 'as', 'because', 'before', 'however', 'since', 'than', 'though',
+    'whereas', 'yet',
+]);
+const RELATIVE_TERMS = new Set(['that', 'which', 'who']);
+const SUBORDINATOR_TERMS = new Set(['after', 'as', 'before']);
+const NOMINAL_MODIFIER_TERMS = new Set([
+    'access', 'audit', 'backup', 'cold', 'data', 'offline', 'ongoing',
+    'policy', 'remote', 'secure', 'security', 'token',
+]);
+const NOMINAL_HEAD_TERMS = new Set([
+    'access', 'approval', 'archive', 'audit', 'auditor', 'credentials', 'data', 'details',
+    'leak', 'leaks', 'metadata', 'policy', 'receipt', 'records', 'request', 'review', 'server',
+    'storage', 'system', 'transit',
+]);
+const MATRIX_NOMINAL_COLLOCATIONS = new Set(['access:policy']);
+const OBJECT_COORDINATOR_TERMS = new Set(['and', 'or', 'then']);
+const FACTUAL_COORDINATOR_TERMS = new Set(['and', 'but', 'then']);
+const TRAILING_MODIFIER_TERMS = new Set([
+    'earlier', 'here', 'now', 'soon', 'today', 'tonight', 'there', 'yesterday',
+]);
+const MATRIX_PREDICATE_TERMS = new Set([
+    'arrive', 'arrives', 'become', 'becomes', 'exist', 'exists', 'expire', 'expires',
+    'leak', 'leaks', 'match', 'matches', 'pass', 'passes', 'remain', 'remains', 'trigger', 'triggers',
+]);
+class ProvidedTargetPrefixClassifier {
+    input;
+    tokens;
+    matchedObjectForms = new Set();
+    matchedObjectIndexes = new Set();
+    constructor(input) {
+        this.input = input;
+        this.tokens = input.predicates.tokenize(input.source).tokens;
+    }
+    classify() {
+        const objectPrefixEnd = this.matchObjectPrefix();
+        if (objectPrefixEnd < 0)
+            return 'none';
+        if (this.hasFiniteNonObjectPrefix(objectPrefixEnd))
+            return 'conditional';
+        const tailStart = this.consumeRemainingObjectTerms(objectPrefixEnd + 1);
+        return this.classifyObjectTail(tailStart);
+    }
+    matchObjectPrefix() {
+        const requiredMatches = Math.min(2, this.input.objectForms.length);
+        const deferredOverlaps = [];
+        for (let tokenIndex = 0; tokenIndex < this.tokens.length; tokenIndex += 1) {
+            const [formIndex, ...overlaps] = this.unmatchedObjectFormIndexes(this.valueAt(tokenIndex));
+            if (formIndex === undefined)
+                continue;
+            this.matchedObjectForms.add(formIndex);
+            this.matchedObjectIndexes.add(tokenIndex);
+            deferredOverlaps.push(...overlaps.map((overlap) => ({ formIndex: overlap, tokenIndex })));
+            if (this.matchedObjectForms.size >= requiredMatches)
+                return tokenIndex;
+        }
+        for (const { formIndex, tokenIndex } of deferredOverlaps) {
+            if (this.matchedObjectForms.has(formIndex))
+                continue;
+            this.matchedObjectForms.add(formIndex);
+            this.matchedObjectIndexes.add(tokenIndex);
+            if (this.matchedObjectForms.size >= requiredMatches) {
+                return Math.max(...this.matchedObjectIndexes);
+            }
+        }
+        return -1;
+    }
+    unmatchedObjectFormIndexes(value) {
+        return this.input.objectForms.flatMap((forms, candidateIndex) => (!this.matchedObjectForms.has(candidateIndex) && forms.has(value) ? [candidateIndex] : []));
+    }
+    hasFiniteNonObjectPrefix(objectPrefixEnd) {
+        const prefix = this.tokens
+            .slice(0, objectPrefixEnd + 1)
+            .filter((_, index) => !this.matchedObjectIndexes.has(index))
+            .map((token) => token.value)
+            .join(' ');
+        return this.input.predicates.finiteClauseSubjectPolarity(prefix) !== 'absent'
+            || this.input.predicates.hasIndependentAffirmativeAction(prefix, this.input.actionForms);
+    }
+    skipModifiers(initialIndex) {
+        let index = initialIndex;
+        while (index < this.tokens.length && this.isSkippableModifier(this.valueAt(index)))
+            index += 1;
+        return index;
+    }
+    isSkippableModifier(term) {
+        return this.input.lexicon.leadingClauseModifiers.has(term)
+            || TRAILING_MODIFIER_TERMS.has(term)
+            || /ly$/u.test(term);
+    }
+    consumeRemainingObjectTerms(initialIndex) {
+        let index = this.skipModifiers(initialIndex);
+        const remaining = new Set(this.input.objectForms.keys());
+        for (const matched of this.matchedObjectForms)
+            remaining.delete(matched);
+        while (index < this.tokens.length) {
+            const candidate = [...remaining].find((formIndex) => (this.input.objectForms[formIndex]?.has(this.valueAt(index))));
+            if (candidate === undefined)
+                break;
+            remaining.delete(candidate);
+            index = this.skipModifiers(index + 1);
+        }
+        return index;
+    }
+    isPastPredicate(term) {
+        return term.endsWith('ed')
+            || this.input.lexicon.irregularSimplePast.has(term)
+            || this.input.lexicon.irregularPastParticiples.has(term);
+    }
+    consumeNominal(initialIndex) {
+        let index = this.skipModifiers(initialIndex);
+        if (this.input.lexicon.subjectArticles.has(this.valueAt(index)))
+            index += 1;
+        while (index + 1 < this.tokens.length && this.isSimpleNominalModifier(this.valueAt(index)))
+            index += 1;
+        if (index < this.tokens.length)
+            index += 1;
+        return this.skipModifiers(index);
+    }
+    isSimpleNominalModifier(term) {
+        return this.input.predicates.isAttributiveTargetModifier(term) || NOMINAL_MODIFIER_TERMS.has(term);
+    }
+    isObjectForm(term) {
+        return this.input.objectForms.some((forms) => forms.has(term));
+    }
+    isMatrixPredicate(term) {
+        return MATRIX_PREDICATE_TERMS.has(term)
+            || this.input.predicates.isFinitePredicateTerm(term)
+            || (this.input.actionForms.has(term) && !this.isObjectForm(term));
+    }
+    isNominalHead(term) {
+        return NOMINAL_HEAD_TERMS.has(term) || this.isObjectForm(term);
+    }
+    isNominalModifier(term) {
+        return this.input.predicates.isAttributiveTargetModifier(term)
+            || NOMINAL_MODIFIER_TERMS.has(term)
+            || this.isObjectForm(term);
+    }
+    reachesKnownNominalHead(initialIndex, genericModifierBudget) {
+        let index = initialIndex;
+        let remainingBudget = genericModifierBudget;
+        while (index < this.tokens.length) {
+            const term = this.valueAt(index);
+            if (this.isNominalHead(term))
+                return true;
+            if (!this.isNominalModifier(term)) {
+                if (remainingBudget <= 0)
+                    return false;
+                remainingBudget -= 1;
+            }
+            index = this.skipModifiers(index + 1);
+        }
+        return false;
+    }
+    isMatrixNominalCollocation(initialIndex) {
+        const modifier = this.valueAt(initialIndex);
+        let index = this.skipModifiers(initialIndex + 1);
+        while (index < this.tokens.length) {
+            const term = this.valueAt(index);
+            if (this.isNominalHead(term))
+                return MATRIX_NOMINAL_COLLOCATIONS.has(`${modifier}:${term}`);
+            if (!this.isNominalModifier(term))
+                return false;
+            index = this.skipModifiers(index + 1);
+        }
+        return false;
+    }
+    consumeNominalPhrase(initialIndex) {
+        let index = this.skipModifiers(initialIndex);
+        const hadArticle = this.input.lexicon.subjectArticles.has(this.valueAt(index));
+        if (hadArticle)
+            index += 1;
+        const prenominal = this.consumePrenominalModifiers(index, hadArticle ? 2 : 1);
+        index = prenominal.index;
+        const head = this.valueAt(index);
+        if (!this.isValidNominalHead(head, prenominal.sawModifier))
+            return index;
+        return this.consumeGerundComplements(this.skipModifiers(index + 1));
+    }
+    consumePrenominalModifiers(initialIndex, genericLimit) {
+        let index = initialIndex;
+        let genericModifiers = 0;
+        let sawModifier = false;
+        while (index + 1 < this.tokens.length) {
+            const nextIndex = this.skipModifiers(index + 1);
+            const term = this.valueAt(index);
+            if (this.isPrenominalBoundary(nextIndex))
+                break;
+            const knownModifier = this.isNominalModifier(term);
+            const genericModifier = !knownModifier
+                && !this.isNominalHead(term)
+                && genericModifiers < genericLimit
+                && this.reachesKnownNominalHead(nextIndex, genericLimit - genericModifiers - 1);
+            if (!knownModifier && !genericModifier)
+                break;
+            if (genericModifier)
+                genericModifiers += 1;
+            sawModifier = true;
+            index = nextIndex;
+        }
+        return { index, sawModifier };
+    }
+    isPrenominalBoundary(nextIndex) {
+        const next = this.valueAt(nextIndex);
+        return nextIndex >= this.tokens.length
+            || RELATIVE_TERMS.has(next)
+            || this.input.lexicon.conditionalMarkers.has(next)
+            || this.isFactualTailPrefix(next)
+            || this.input.lexicon.subjectArticles.has(next)
+            || (this.isMatrixPredicate(next) && !this.isMatrixNominalCollocation(nextIndex));
+    }
+    isValidNominalHead(head, sawPrenominalModifier) {
+        return Boolean(head)
+            && !RELATIVE_TERMS.has(head)
+            && !this.input.lexicon.conditionalMarkers.has(head)
+            && !this.isFactualTailPrefix(head)
+            && !this.input.lexicon.subjectArticles.has(head)
+            && !this.isMatrixPredicate(head)
+            && (!sawPrenominalModifier || this.isNominalHead(head));
+    }
+    consumeGerundComplements(initialIndex) {
+        let index = initialIndex;
+        while (this.valueAt(index).endsWith('ing')) {
+            const complementStart = this.skipModifiers(index + 1);
+            const complementEnd = this.consumeNominalPhrase(complementStart);
+            if (complementEnd <= complementStart)
+                break;
+            index = complementEnd;
+        }
+        return index;
+    }
+    consumeTerminalNominal(initialIndex) {
+        const nominalEnd = this.consumeNominalPhrase(initialIndex);
+        if (nominalEnd >= this.tokens.length)
+            return nominalEnd;
+        const prefixHead = this.firstNominalHead(initialIndex, nominalEnd);
+        return this.isNominalHead(this.valueAt(nominalEnd))
+            && prefixHead === nominalEnd
+            && this.skipModifiers(nominalEnd + 1) >= this.tokens.length
+            ? this.tokens.length
+            : nominalEnd;
+    }
+    firstNominalHead(initialIndex, nominalEnd) {
+        let index = this.skipModifiers(initialIndex);
+        if (this.input.lexicon.subjectArticles.has(this.valueAt(index))) {
+            index = this.skipModifiers(index + 1);
+        }
+        while (index < nominalEnd && !this.isNominalHead(this.valueAt(index))) {
+            index = this.skipModifiers(index + 1);
+        }
+        return index;
+    }
+    classifyRelativeTail(initialIndex) {
+        let index = this.skipModifiers(initialIndex);
+        const first = this.valueAt(index);
+        if (this.input.lexicon.subjectArticles.has(first)) {
+            index = this.consumeNominal(index);
+        }
+        else if (this.hasElidedPastSubject(index)) {
+            index = this.skipModifiers(index + 1);
+        }
+        while (this.input.lexicon.passiveAuxiliaries.has(this.valueAt(index))) {
+            index = this.skipModifiers(index + 1);
+        }
+        if (!this.isPastPredicate(this.valueAt(index)))
+            return 'conditional';
+        index = this.skipModifiers(index + 1);
+        return this.isFactualTerminalNominal(index);
+    }
+    hasElidedPastSubject(index) {
+        const first = this.valueAt(index);
+        return !this.isPastPredicate(first)
+            && !this.input.lexicon.passiveAuxiliaries.has(first)
+            && this.isPastPredicate(this.valueAt(index + 1));
+    }
+    classifySubordinateTail(initialIndex) {
+        let index = this.skipModifiers(initialIndex);
+        if (index >= this.tokens.length)
+            return 'factual';
+        if (this.isPastPredicate(this.valueAt(index)))
+            index = this.skipModifiers(index + 1);
+        return this.isFactualTerminalNominal(index);
+    }
+    isFactualTerminalNominal(index) {
+        if (index >= this.tokens.length)
+            return 'factual';
+        return this.consumeTerminalNominal(index) >= this.tokens.length ? 'factual' : 'conditional';
+    }
+    classifyObjectTail(initialIndex) {
+        const index = this.skipModifiers(initialIndex);
+        if (index >= this.tokens.length)
+            return 'factual';
+        const term = this.valueAt(index);
+        if (OBJECT_COORDINATOR_TERMS.has(term))
+            return this.classifyCoordinatedTail(index + 1);
+        if (RELATIVE_TERMS.has(term))
+            return this.classifyRelativeTail(index + 1);
+        if (this.input.lexicon.commaDelimitedPrepositions.has(term)) {
+            return this.classifyObjectTail(this.consumeTerminalNominal(index + 1));
+        }
+        if (this.input.lexicon.conditionalMarkers.has(term))
+            return 'conditional';
+        if (SUBORDINATOR_TERMS.has(term))
+            return this.classifySubordinateTail(index + 1);
+        if (this.isFactualTailPrefix(term))
+            return 'factual';
+        if (term.endsWith('ing'))
+            return this.classifyObjectTail(this.consumeTerminalNominal(index + 1));
+        return 'conditional';
+    }
+    classifyCoordinatedTail(initialIndex) {
+        let index = this.skipModifiers(initialIndex);
+        if (index >= this.tokens.length)
+            return 'factual';
+        const coordinatedTerm = this.valueAt(index);
+        if (this.input.actionForms.has(coordinatedTerm) && this.isPastPredicate(coordinatedTerm)) {
+            index = this.skipModifiers(index + 1);
+            if (index >= this.tokens.length)
+                return 'factual';
+            if (this.input.lexicon.commaDelimitedPrepositions.has(this.valueAt(index))) {
+                return this.classifyObjectTail(index);
+            }
+        }
+        return this.classifyObjectTail(this.consumeTerminalNominal(index));
+    }
+    isFactualTailPrefix(term) {
+        return FACTUAL_TAIL_PREFIX_TERMS.has(term)
+            || this.input.lexicon.commaDelimitedPrepositions.has(term)
+            || FACTUAL_COORDINATOR_TERMS.has(term);
+    }
+    valueAt(index) {
+        return this.tokens[index]?.value ?? '';
+    }
+}
+export function classifyProvidedTargetPrefix(input) {
+    if (!input.source || input.objectForms.length === 0)
+        return 'none';
+    return new ProvidedTargetPrefixClassifier(input).classify();
+}

package/dist/trace/index.d.ts

@@ -1,3 +1,4 @@
 export * from './trajectory.js';
 export * from './trajectoryExport.js';
-export * from './learningTrace.js';
+export * from './learningTrace.js';
+export * from './proxyTurns.js';

package/dist/trace/index.js

@@ -1,3 +1,4 @@
 export * from './trajectory.js';
 export * from './trajectoryExport.js';
-export * from './learningTrace.js';
+export * from './learningTrace.js';
+export * from './proxyTurns.js';

package/dist/trace/proxyTurns.d.ts

@@ -0,0 +1,31 @@
+import { type TraceReadOptions } from './trajectoryExport.js';
+import { type TraceTurnDraft } from './trajectory.js';
+/** One agent run's wall-clock window (epoch ms, same host clock as the proxy's ts). */
+export interface RunTurnWindow {
+    startMs: number;
+    endMs: number;
+}
+export interface SelectRunLlmTurnsOptions {
+    /**
+     * Exact-match correlation key: when the caller knows the spawned agent's session id, only that session's
+     * turns are returned (the window heuristic is skipped — the id is authoritative).
+     */
+    sessionId?: string;
+}
+export interface CollectRunLlmTurnsOptions extends SelectRunLlmTurnsOptions {
+    /** Decryption material forwarded to readTraceRowsFromJsonl. allowPartial is always forced on. */
+    readOptions?: TraceReadOptions;
+}
+/**
+ * Pure selector (unit-testable without fs): pick the turns that belong to the run per the correlation
+ * contract above, sorted by ts ascending (stable — equal timestamps keep day-file append order, and the
+ * recorder's fold order becomes the sequence order).
+ */
+export declare function selectRunLlmTurns(turns: readonly TraceTurnDraft[], window: RunTurnWindow, opts?: SelectRunLlmTurnsOptions): TraceTurnDraft[];
+/**
+ * Read the proxy trace day-files in `dir` and return this run's llm_turns (see the correlation contract
+ * above), ready to fold via recordLlmTurn. Reuses readTraceRowsFromJsonl (decryption + row parsing) and
+ * traceRecordToTurnDraft (normalization). Never throws: any failure — no proxy, missing dir, unreadable
+ * file, undecryptable rows — degrades to [].
+ */
+export declare function collectRunLlmTurns(dir: string, window: RunTurnWindow, opts?: CollectRunLlmTurnsOptions): TraceTurnDraft[];

package/dist/trace/proxyTurns.js

@@ -0,0 +1,137 @@
+// Proxy llm_turn → run fold (Learning Ops slice 5): collect the per-request llm_turn records the LLM proxy
+// captured DURING one agent run's wall-clock window, normalized as TraceTurnDrafts ready for
+// AgentRunTraceRecorder.recordLlmTurn. This is what upgrades a run's trajectory from the bridge's single
+// coarse model.called (the headless runner is a black box) to real per-request fidelity
+// (provider/model/usage/latency/stop_reason + tool-call detail).
+//
+// Correlation contract (why time window + session-first-turn, not session_id alone): the headless runner does
+// not report its session id back to the bridge (`claude -p --output-format text` is opaque), and llm_turn rows
+// carry no cwd — so the run has no exact key to look up. What the run DOES own is its wall-clock window on the
+// same host the proxy writes from (one shared clock, no skew). A turn belongs to the run iff:
+//   1. its ts falls inside [startMs, endMs], AND
+//   2. its session's FIRST observed turn also falls inside the window — a session spawned by this run cannot
+//      have traffic predating the run, while a concurrent interactive session (started earlier) is excluded by
+//      its pre-window history. Sessionless turns (session_id null) fall back to the window test alone.
+// Callers that DO know the spawned agent's session id (e.g. a future runner passing --session-id) can pass
+// `sessionId` for exact-match correlation instead of the heuristic.
+//
+// Residual risk, accepted + documented: an interactive session whose very first request starts inside the run
+// window is indistinguishable from the run's own agent. On an unattended daemon host this is rare, and the
+// fold is observability-only — it can bias a trace, never a verdict.
+//
+// Everything degrades silently to [] (missing dir, unreadable file, undecryptable envelope, bad ts): the
+// learning trace must never fail or slow a task.
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { readTraceRowsFromJsonl } from './trajectoryExport.js';
+import { traceRecordToTurnDraft } from './trajectory.js';
+/** Any proxy day-file (`llm-trace-*.jsonl`). */
+const TRACE_FILE_RE = /^llm-trace-.*\.jsonl$/i;
+/** The canonical day-stamped name the proxy's JsonlTraceSink writes (`llm-trace-YYYYMMDD.jsonl`, UTC). */
+const DAY_STAMPED_FILE_RE = /^llm-trace-(\d{8})\.jsonl$/i;
+function utcDayStamp(ms) {
+    const d = new Date(ms);
+    const p = (n) => String(n).padStart(2, '0');
+    return `${d.getUTCFullYear()}${p(d.getUTCMonth() + 1)}${p(d.getUTCDate())}`;
+}
+/**
+ * Keep day-stamped files that could contain the window's turns. Heuristic correlation must inspect all earlier
+ * day files to prove that an in-window session did not start before the run; exact session-id correlation only
+ * needs files that overlap the run window.
+ * Non-day-stamped `llm-trace-*.jsonl` names (custom sinks/tests) are kept conservatively — the ts window
+ * filter below is the authority; the filename filter only trims read volume.
+ */
+function fileCoversWindow(name, window, includeSessionHistory) {
+    const match = DAY_STAMPED_FILE_RE.exec(name);
+    if (!match)
+        return true;
+    const stamp = match[1];
+    return (includeSessionHistory || stamp >= utcDayStamp(window.startMs)) && stamp <= utcDayStamp(window.endMs);
+}
+function turnTsMs(turn) {
+    if (turn.ts === null)
+        return null;
+    const ms = Date.parse(turn.ts);
+    return Number.isFinite(ms) ? ms : null;
+}
+/**
+ * Pure selector (unit-testable without fs): pick the turns that belong to the run per the correlation
+ * contract above, sorted by ts ascending (stable — equal timestamps keep day-file append order, and the
+ * recorder's fold order becomes the sequence order).
+ */
+export function selectRunLlmTurns(turns, window, opts = {}) {
+    const stamped = turns
+        .map((turn) => ({ turn, tsMs: turnTsMs(turn) }))
+        .filter((entry) => entry.tsMs !== null);
+    let selected;
+    if (opts.sessionId !== undefined) {
+        selected = stamped.filter(({ turn }) => turn.session_id === opts.sessionId);
+    }
+    else {
+        // First observed turn per session across ALL provided turns (including pre-window rows from the same
+        // day files) — this is what tells an in-run spawned session apart from an older concurrent one.
+        const firstTsBySession = new Map();
+        for (const { turn, tsMs } of stamped) {
+            if (turn.session_id === null)
+                continue;
+            const prev = firstTsBySession.get(turn.session_id);
+            if (prev === undefined || tsMs < prev)
+                firstTsBySession.set(turn.session_id, tsMs);
+        }
+        selected = stamped.filter(({ turn, tsMs }) => {
+            if (tsMs < window.startMs || tsMs > window.endMs)
+                return false;
+            if (turn.session_id === null)
+                return true;
+            const firstTs = firstTsBySession.get(turn.session_id);
+            return firstTs !== undefined && firstTs >= window.startMs;
+        });
+    }
+    return selected
+        .map((entry, index) => ({ ...entry, index }))
+        .sort((a, b) => a.tsMs - b.tsMs || a.index - b.index)
+        .map(({ turn }) => turn);
+}
+/**
+ * Read the proxy trace day-files in `dir` and return this run's llm_turns (see the correlation contract
+ * above), ready to fold via recordLlmTurn. Reuses readTraceRowsFromJsonl (decryption + row parsing) and
+ * traceRecordToTurnDraft (normalization). Never throws: any failure — no proxy, missing dir, unreadable
+ * file, undecryptable rows — degrades to [].
+ */
+export function collectRunLlmTurns(dir, window, opts = {}) {
+    try {
+        if (!(window.endMs >= window.startMs))
+            return [];
+        const names = readdirSync(dir)
+            .filter((name) => TRACE_FILE_RE.test(name) && fileCoversWindow(name, window, opts.sessionId === undefined))
+            .sort();
+        const turns = [];
+        for (const name of names) {
+            const dayMatch = DAY_STAMPED_FILE_RE.exec(name);
+            const isHistoricalDay = opts.sessionId === undefined
+                && dayMatch !== null
+                && dayMatch[1] < utcDayStamp(window.startMs);
+            let text;
+            try {
+                text = readFileSync(join(dir, name), 'utf8');
+            }
+            catch {
+                continue;
+            }
+            // allowPartial forced on: an undecryptable envelope is a coverage gap, never a fold failure.
+            const { rows } = readTraceRowsFromJsonl(text, { ...(opts.readOptions ?? {}), allowPartial: true });
+            for (const row of rows) {
+                const turn = traceRecordToTurnDraft(row);
+                if (turn !== null) {
+                    // Older day files establish that a session predates this run; they can never contribute candidate
+                    // turns even if a malformed row carries an in-window timestamp.
+                    turns.push(isHistoricalDay ? { ...turn, ts: new Date(window.startMs - 1).toISOString() } : turn);
+                }
+            }
+        }
+        return selectRunLlmTurns(turns, window, opts.sessionId !== undefined ? { sessionId: opts.sessionId } : {});
+    }
+    catch {
+        return [];
+    }
+}

package/dist/verify/validation.d.ts

@@ -38,4 +38,14 @@ export declare function summarizeStdout(stdout: string): string;
 export declare function runValidation(plan: ValidationPlan, run: CommandRunner): Promise<{
     results: ValidationResult[];
     passed: boolean;
-}>;
+}>;
+/**
+ * 检查验证命令是否安全可作为 Gene.validation 条目使用（忠实移植 v1 policyCheck.isValidationCommandAllowed）。
+ * Gene 验证命令只允许 `node …` 形式，不允许非 node 命令（如 pnpm/npm/echo 等）。
+ * 安全条件：
+ * 1. 必须以 `node ` 开头
+ * 2. 不包含命令替换（` 或 $(）
+ * 3. 不包含 shell 元字符（引号外）
+ * 4. 不包含被阻止的 node 标志（-e/--eval/--print 等）
+ */
+export declare function isValidationCommandAllowed(cmd: string): boolean;

package/dist/verify/validation.js

@@ -82,4 +82,35 @@ export async function runValidation(plan, run) {
     // 全部 allowed 的命令都 exit 0 才算通过; 有命令被 deny 视为未通过(校验不完整)
     const passed = results.length > 0 && results.every((r) => r.allowed && r.passed);
     return { results, passed };
+}
+/**
+ * 检查验证命令是否安全可作为 Gene.validation 条目使用（忠实移植 v1 policyCheck.isValidationCommandAllowed）。
+ * Gene 验证命令只允许 `node …` 形式，不允许非 node 命令（如 pnpm/npm/echo 等）。
+ * 安全条件：
+ * 1. 必须以 `node ` 开头
+ * 2. 不包含命令替换（` 或 $(）
+ * 3. 不包含 shell 元字符（引号外）
+ * 4. 不包含被阻止的 node 标志（-e/--eval/--print 等）
+ */
+export function isValidationCommandAllowed(cmd) {
+    const c = String(cmd || '').trim();
+    if (!c)
+        return false;
+    // 只允许 node 命令作为验证命令
+    if (!c.startsWith('node '))
+        return false;
+    // 不允许命令替换
+    if (/`|\$\(/.test(c))
+        return false;
+    // 移除引号内的内容后检查 shell 元字符
+    const stripped = c.replace(/"[^"]*"/g, '').replace(/'[^']*'/g, '');
+    if (SHELL_METACHARS.test(stripped))
+        return false;
+    // 检查被阻止的 node 标志
+    const tokens = c.split(/\s+/);
+    const executable = tokens[0] ?? '';
+    const args = tokens.slice(1);
+    if (nodeFlagViolation(executable, args))
+        return false;
+    return true;
 }

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@evomap/evolver-core",
-  "version": "2.0.0-beta.17",
+  "version": "2.0.0-beta.19",
   "private": false,
   "type": "module",
+  "engines": {
+    "node": "^22.13.0 || >=23.4.0"
+  },
   "description": "hub-无关核心: 算法引擎/原材料/mailbox/资产库/workflow",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",