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

package/dist/exec/autoExec.js

@@ -159,12 +159,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 } : {}),
@@ -224,6 +237,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/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/package.json

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