@evomap/evolver-core 2.0.0-beta.16 → 2.0.0-beta.18

package/dist/exec/autoExec.d.ts

@@ -11,6 +11,7 @@ import type { ReuseOutcomeSummary, ReuseOutcomeEvent } from '../ops/reuseOutcome
 import type { PersonalityStore } from '../personality/store.js';
 import type { MemoryGraphProvider } from '../algo/memoryGraph.js';
 import { type LearningPacketSink, type TraceSink } from '../trace/learningTrace.js';
+import type { TraceReadOptions } from '../trace/trajectoryExport.js';
 export interface AutoExecTask {
     id: string;
     repo: string;
@@ -124,6 +125,22 @@ export interface AutoExecDeps {
         traceSink?: TraceSink;
         /** Hub packet sourceRepo column; default 'evolver-v2'. */
         sourceRepo?: string;
+        /**
+         * Proxy llm_turn fold (Learning Ops slice 5): when set, after the cycle (and BEFORE run.completed, so
+         * sequence order holds) the run's wall-clock window of proxy trace records is read from `dir`
+         * (llm-trace-*.jsonl day-files) and folded into the recorder via recordLlmTurn — real per-request
+         * model.called + tool.called/tool.failed detail instead of only the bridge's coarse spawn event.
+         * Correlation is the time window + session-first-turn heuristic (see trace/proxyTurns.ts). Best-effort:
+         * a missing dir / unreadable file / no proxy degrades to zero folded turns, never a verdict change.
+         */
+        proxyTraces?: {
+            /** Proxy trace day-file dir (events/paths.ts tracesDir()). */
+            dir: string;
+            /** Decryption material for encrypted trace envelopes (allowPartial is always forced on). */
+            readOptions?: TraceReadOptions;
+            /** Injected clock for deterministic tests. Default Date.now. */
+            now?: () => number;
+        };
     };
 }
 export interface ForcedGeneFields {

package/dist/exec/autoExec.js

@@ -12,6 +12,7 @@ import { runEvolutionCycle } from '../algo/orchestrator.js';
 import { makeSafeExecute, makeTrustedGeneResolver } from './autonomousCycle.js';
 import { findSignalHints } from './openPrRegistry.js';
 import { AgentRunTraceRecorder, buildLearningPacketDraft } from '../trace/learningTrace.js';
+import { collectRunLlmTurns } from '../trace/proxyTurns.js';
 /** Same path-containment as the bridge guard — used here to refuse before running anything (clean verdict). */
 function withinAllowlist(repo, roots) {
     const c = resolvePath(repo);
@@ -147,6 +148,10 @@ export async function runAutoExecTask(deps, rawTask, safety) {
             ...(deps.learningTrace.traceSink ? { sink: deps.learningTrace.traceSink } : {}),
         })
         : undefined;
+    // Wall-clock window of this run, used to correlate the proxy's llm_turn records (slice 5). Captured
+    // unconditionally-cheaply only when the fold is configured.
+    const proxyTraceClock = deps.learningTrace?.proxyTraces?.now ?? Date.now;
+    const runStartMs = deps.learningTrace?.proxyTraces ? proxyTraceClock() : 0;
     try {
         traceRecorder?.runStarted({ taskSummary: task.expectedEffect, signals: cycleSignals, metadata: { repo: task.repo, target: task.target } });
     }
@@ -159,12 +164,25 @@ export async function runAutoExecTask(deps, rawTask, safety) {
             hubCandidates = [];
         }
     }
+    // evaluation fill-in (slice 6): the validate hook is the run's external verifier (sandboxed validation
+    // commands), so its result — when it actually RAN — becomes the packet's evaluation.verification
+    // (verifier 'automated_test'). Observation is a pass-through wrapper: the hook's result reaches the
+    // bridge unchanged, and a run where validation never fired keeps the evaluation placeholder.
+    let observedVerification;
+    const baseValidate = deps.validate?.(task);
+    const observingValidate = baseValidate
+        ? async (mutation, decision, cwd) => {
+            const v = await baseValidate(mutation, decision, cwd);
+            observedVerification = { verifier: 'automated_test', passed: v.passed, ...(v.score !== undefined ? { score: v.score } : {}) };
+            return v;
+        }
+        : undefined;
     const execute = makeSafeExecute(task.repo, deps.store, safety, {
         ...(deps.provenance ? { provenance: deps.provenance } : {}),
         ...(deps.review ? { review: deps.review } : {}),
         ...(deps.includeProbation ? { includeProbation: true } : {}),
         ...(task.validationCmds ? { validationCmds: task.validationCmds } : {}),
-        ...(deps.validate ? { validate: deps.validate(task) } : {}),
+        ...(observingValidate ? { validate: observingValidate } : {}),
         ...(deps.personality ? { personality: deps.personality } : {}),
         ...(deps.agent ? { agent: deps.agent } : {}),
         ...(deps.git ? { git: deps.git } : {}),
@@ -211,6 +229,18 @@ export async function runAutoExecTask(deps, rawTask, safety) {
     const status = res.finalStage === 'solidified' ? 'solidified' : res.finalStage === 'failed' ? 'failed' : 'innovated';
     const cap = res.capsule;
     if (traceRecorder && deps.learningTrace) {
+        // Proxy llm_turn fold (slice 5): fold the run window's per-request turns BEFORE run.completed so the
+        // trajectory stays sequence-ordered (model/tool detail inside the run, completion last). Own try — a
+        // throwing sink mid-fold must not cost the run its completion event or packet draft.
+        try {
+            const proxyTraces = deps.learningTrace.proxyTraces;
+            if (proxyTraces) {
+                const turns = collectRunLlmTurns(proxyTraces.dir, { startMs: runStartMs, endMs: proxyTraceClock() }, proxyTraces.readOptions ? { readOptions: proxyTraces.readOptions } : {});
+                for (const turn of turns)
+                    traceRecorder.recordLlmTurn(turn);
+            }
+        }
+        catch { /* observability only */ }
         try {
             traceRecorder.runCompleted({
                 status: res.finalStage === 'solidified' ? 'success' : 'failed',
@@ -224,6 +254,7 @@ export async function runAutoExecTask(deps, rawTask, safety) {
                 taskSummary: task.expectedEffect,
                 signals: cycleSignals,
                 environment: { repo: task.repo, runner: safety.runner ?? 'claude' },
+                ...(observedVerification !== undefined ? { verification: observedVerification } : {}),
             }));
         }
         catch { /* packet delivery is best-effort; never fail the task */ }

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/learningTrace.d.ts

@@ -128,12 +128,24 @@ export declare function learningTraceObserver(deps: {
     recorder: AgentRunTraceRecorder;
     timeoutMs?: number;
 }): Observer;
+/**
+ * Externally-verified run evidence (Learning Ops slice 6): the runtime's validate hook (sandboxed
+ * validation commands) is an `automated_test` verifier in the hub VERIFIERS vocabulary. Only a hook
+ * that actually RAN produces one of these — agent self-report never fills evaluation.
+ */
+export interface LearningPacketVerification {
+    verifier: 'automated_test';
+    passed: boolean;
+    score?: number;
+}
 export interface LearningPacketDraftInput {
     /** e.g. 'evolver-v2'. Hub column sourceRepo. */
     sourceRepo: string;
     taskSummary?: string;
     signals?: readonly string[];
     environment?: Record<string, unknown>;
+    /** When present, fills evaluation (placeholder → false). Omit when no external verifier ran. */
+    verification?: LearningPacketVerification;
 }
 /** Local draft aligned with hub LearningOpsPacket ingest fields; placeholders are explicit, not implied. */
 export interface LearningPacketDraft {
@@ -160,10 +172,13 @@ export interface LearningPacketDraft {
         placeholder: true;
         items: never[];
     };
+    /** placeholder:false ⇔ an external verifier ran (verification input) — then verifier/verifierPassed are set. */
     evaluation: {
-        placeholder: true;
+        placeholder: boolean;
         outcomeStatus: 'success' | 'failed' | 'unknown';
-        verifier: null;
+        verifier: 'automated_test' | null;
+        verifierPassed?: boolean;
+        verifierScore?: number;
         failureCategory: string | null;
     };
     governance: {

package/dist/trace/learningTrace.js

@@ -244,9 +244,11 @@ export function buildLearningPacketDraft(recorder, input) {
         trajectory: events,
         artifacts: { placeholder: true, items: [] },
         evaluation: {
-            placeholder: true,
+            placeholder: input.verification === undefined,
             outcomeStatus: completedStatus === 'success' ? 'success' : completedStatus === 'failed' ? 'failed' : 'unknown',
-            verifier: null,
+            verifier: input.verification?.verifier ?? null,
+            ...(input.verification !== undefined ? { verifierPassed: input.verification.passed } : {}),
+            ...(input.verification?.score !== undefined ? { verifierScore: input.verification.score } : {}),
             failureCategory: typeof failureKind === 'string' ? failureKind : null,
         },
         governance: { placeholder: true, redactionStatus: 'metadata_only', consentStatus: 'unknown', trainingEligible: false, retentionPolicy: 'standard' },

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,129 @@
+// 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. One extra preceding day is included so the
+ * session-first-turn heuristic can see the pre-window history of a session that started before midnight.
+ * 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) {
+    const match = DAY_STAMPED_FILE_RE.exec(name);
+    if (!match)
+        return true;
+    const stamp = match[1];
+    return stamp >= utcDayStamp(window.startMs - 24 * 60 * 60 * 1000) && 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))
+            .sort();
+        const turns = [];
+        for (const name of names) {
+            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)
+                    turns.push(turn);
+            }
+        }
+        return selectRunLlmTurns(turns, window, opts.sessionId !== undefined ? { sessionId: opts.sessionId } : {});
+    }
+    catch {
+        return [];
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evomap/evolver-core",
-  "version": "2.0.0-beta.16",
+  "version": "2.0.0-beta.18",
   "private": false,
   "type": "module",
   "description": "hub-无关核心: 算法引擎/原材料/mailbox/资产库/workflow",