@evo-dev/core 0.0.1-alpha.1 → 0.0.1-alpha.3

package/src/evolution/index.ts

@@ -1,16 +1,24 @@
 import { createHash } from "node:crypto";
 import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { readCodeAgentTraceRef } from "../code-agent-traces/index.ts";
 import { resolveEvoDevPaths } from "../config/paths.ts";
-import { resolveProjectLogKey } from "../runtime-logs/index.ts";
+import {
+  type OkfKnowledgeActivationResult,
+  activateOkfKnowledgePlan,
+  createOkfKnowledgePlanFromDistillationBatch,
+} from "../knowledge/index.ts";
+import { type EvoDevExecutionEventV1, resolveProjectLogKey } from "../runtime-logs/index.ts";
 
 export type EvolutionEvidenceSourceKind =
+  | "evodev-execution-event"
   | "team-agent-trace"
   | "session-trace"
   | "task-contract"
   | "verification"
   | "review-summary"
-  | "user-feedback";
+  | "user-feedback"
+  | "code-agent-trace-ref";
 
 export type EvolutionEvidenceEventKind =
   | "trace"
@@ -77,10 +85,13 @@ export type EvolutionKnowledgeKind =
   | "verification-pattern";
 
 export type EvolutionReviewState =
+  | "auto-accepted"
   | "auto-stored/unreviewed"
+  | "needs-human"
   | "accepted"
   | "rejected"
   | "deferred"
+  | "stale"
   | "deprecated"
   | "superseded"
   | "revoked";
@@ -129,6 +140,7 @@ export interface EvolutionEvidenceSourceRef {
   path: string;
   roleId: string | null;
   rawContentStored: false;
+  externalContentCopied: false;
 }
 
 export interface EvolutionEvidenceEvent {
@@ -320,6 +332,34 @@ export interface EvolutionRepoProposal {
   privacy: EvolutionPrivacyFields;
 }
 
+export interface EvolutionReviewCandidate {
+  schemaVersion: 1;
+  kind: "evolution-review-candidate";
+  id: string;
+  projectKey: string;
+  runId: string;
+  createdAt: string;
+  candidateKind: string;
+  title: string;
+  targetStore: string;
+  targetPath: string;
+  stableKey: string;
+  reviewState: "needs-human";
+  reasons: string[];
+  candidate: unknown;
+  provenance: {
+    runId: string;
+    evidenceWindowId: string;
+    evidenceRefs: string[];
+    createdBy: "evodev";
+    rawLogsStored: false;
+    rawPromptsStored: false;
+    sourceDumpsStored: false;
+    rawCommandOutputStored: false;
+  };
+  privacy: EvolutionPrivacyFields;
+}
+
 export interface EvolutionDistillationBatch {
   schemaVersion: 1;
   id: string;
@@ -356,14 +396,29 @@ export interface EvolutionWriteResult {
   evosIndexPath: string;
 }
 
+export interface EvolutionActivationResult {
+  evidenceWindowPath: string;
+  batchPath: string;
+  okf: OkfKnowledgeActivationResult;
+  evosCasePaths: string[];
+  repoProposalPaths: string[];
+  evosIndexPath: string;
+}
+
 export interface EvolutionReviewSnapshot {
   projectKey: string | null;
   knowledgeRecords: EvolutionKnowledgeRecord[];
   evosCases: EvolutionEvosCase[];
   repoProposals: EvolutionRepoProposal[];
+  reviewCandidates: EvolutionReviewCandidate[];
   triggers: EvolutionTriggerRecord[];
 }
 
+export interface EvolutionEvosCaseQueryResult {
+  cases: EvolutionEvosCase[];
+  warnings: string[];
+}
+
 export interface EvolutionResolvedPaths {
   projectKey: string;
   runId: string;
@@ -372,6 +427,7 @@ export interface EvolutionResolvedPaths {
   evidenceWindowPath: string;
   batchPath: string;
   triggersDir: string;
+  reviewCandidatesDir: string;
   repoProposalsDir: string;
   repoProposalsIndexPath: string;
   knowledgeProjectDir: string;
@@ -426,10 +482,13 @@ const MAX_EVIDENCE_EVENTS = 200;
 const MAX_TEXT_LENGTH = 600;
 const PROCESS_LOCK_STALE_MS = 5 * 60 * 1000;
 const REVIEW_STATES: readonly EvolutionReviewState[] = [
+  "auto-accepted",
   "auto-stored/unreviewed",
+  "needs-human",
   "accepted",
   "rejected",
   "deferred",
+  "stale",
   "deprecated",
   "superseded",
   "revoked",
@@ -548,9 +607,9 @@ const FORBIDDEN_RAW_KEYS = new Set([
   "transcripttext",
 ]);
 const SENSITIVE_TEXT_PATTERN =
-  /https?:\/\/\S+|\b(secret|token|password|passwd|api[_-]?key|apikey|credential|credentials|raw log|raw logs|raw output|raw source|raw prompt|shell history|command history)\b/i;
+  /https?:\/\/\S+|\b(secret|token|password|passwd|api[_-]?key|apikey|credential|credentials|secret[\s_-]*token(?:[\s_-]*repro)?|raw[\s_-]*(?:log|logs|output|source|prompt)(?:[\s_-]*repro)?|shell[\s_-]*history|command[\s_-]*history)\b/i;
 const SENSITIVE_TEXT_REPLACE_PATTERN =
-  /https?:\/\/\S+|\b(secret|token|password|passwd|api[_-]?key|apikey|credential|credentials|raw log|raw logs|raw output|raw source|raw prompt|shell history|command history)\b/gi;
+  /https?:\/\/\S+|\b(secret|token|password|passwd|api[_-]?key|apikey|credential|credentials|secret[\s_-]*token(?:[\s_-]*repro)?|raw[\s_-]*(?:log|logs|output|source|prompt)(?:[\s_-]*repro)?|shell[\s_-]*history|command[\s_-]*history)\b/gi;
 
 export async function analyzeEvolutionRun(
   input: EvolutionAnalyzeInput,
@@ -560,23 +619,54 @@ export async function analyzeEvolutionRun(
   const paths = resolveEvolutionPaths({ homeDir: input.homeDir, projectKey, runId });
   const warnings: string[] = [];
   const sourceRefs: EvolutionEvidenceSourceRef[] = [];
+  const linkedTraceRefIds = new Set<string>();
   const events: EvolutionEvidenceEvent[] = [];
-  const projectRunAgentsDir = join(
-    resolveEvoDevPaths(input.homeDir).logsDir,
-    projectKey,
-    runId,
-    "agents",
-  );
-
-  if (!(await pathExists(projectRunAgentsDir))) {
+  const logsDir = resolveEvoDevPaths(input.homeDir).logsDir;
+  const projectRunAgentsDir = join(logsDir, "teams", projectKey, runId, "agents");
+  const legacyProjectRunAgentsDir = join(logsDir, projectKey, runId, "agents");
+  const agentDirs = (await pathExists(projectRunAgentsDir))
+    ? await readdir(projectRunAgentsDir, { withFileTypes: true })
+    : [];
+  const legacyAgentDirs = (await pathExists(legacyProjectRunAgentsDir))
+    ? await readdir(legacyProjectRunAgentsDir, { withFileTypes: true })
+    : [];
+
+  if (agentDirs.length === 0 && legacyAgentDirs.length === 0) {
     warnings.push(
-      `No agent trace directory found: ${displayPath(input.homeDir, projectRunAgentsDir)}`,
+      `No agent execution event directory found: ${displayPath(input.homeDir, projectRunAgentsDir)}`,
     );
   } else {
-    const roleDirs = await readdir(projectRunAgentsDir, { withFileTypes: true });
-    for (const roleDir of roleDirs.filter((entry) => entry.isDirectory())) {
+    const rolesWithExecutionEvents = new Set<string>();
+    for (const roleDir of agentDirs.filter((entry) => entry.isDirectory())) {
       const roleId = sanitizeId(roleDir.name);
-      const tracePath = join(projectRunAgentsDir, roleDir.name, "trace.log");
+      const eventsPath = join(projectRunAgentsDir, roleDir.name, "events.jsonl");
+      if (!(await pathExists(eventsPath))) continue;
+      rolesWithExecutionEvents.add(roleId);
+
+      const sourceRef: EvolutionEvidenceSourceRef = {
+        id: `source-${sourceRefs.length + 1}`,
+        kind: "evodev-execution-event",
+        path: displayPath(input.homeDir, eventsPath),
+        roleId,
+        rawContentStored: false,
+        externalContentCopied: false,
+      };
+      sourceRefs.push(sourceRef);
+      const parsed = await readExecutionEvidenceEvents({
+        path: eventsPath,
+        roleId,
+        sourceRefId: sourceRef.id,
+        existingCount: events.length,
+      });
+      events.push(...parsed.events);
+      for (const traceRefId of parsed.traceRefIds) linkedTraceRefIds.add(traceRefId);
+      warnings.push(...parsed.warnings);
+    }
+
+    for (const roleDir of legacyAgentDirs.filter((entry) => entry.isDirectory())) {
+      const roleId = sanitizeId(roleDir.name);
+      if (rolesWithExecutionEvents.has(roleId)) continue;
+      const tracePath = join(legacyProjectRunAgentsDir, roleDir.name, "trace.log");
       if (!(await pathExists(tracePath))) continue;
 
       const sourceRef: EvolutionEvidenceSourceRef = {
@@ -585,6 +675,7 @@ export async function analyzeEvolutionRun(
         path: displayPath(input.homeDir, tracePath),
         roleId,
         rawContentStored: false,
+        externalContentCopied: false,
       };
       sourceRefs.push(sourceRef);
       const parsed = await readTraceEvidenceEvents({
@@ -598,6 +689,24 @@ export async function analyzeEvolutionRun(
     }
   }
 
+  for (const traceRefId of [...linkedTraceRefIds].sort()) {
+    try {
+      const record = await readCodeAgentTraceRef({ homeDir: input.homeDir, id: traceRefId });
+      sourceRefs.push({
+        id: `source-${sourceRefs.length + 1}`,
+        kind: "code-agent-trace-ref",
+        path: displayPath(input.homeDir, record.path),
+        roleId: record.ref.roleId,
+        rawContentStored: false,
+        externalContentCopied: false,
+      });
+    } catch {
+      warnings.push(
+        `Code Agent trace ref metadata not found for linked ref: ${sanitizeText(traceRefId)}.`,
+      );
+    }
+  }
+
   if (events.length > MAX_EVIDENCE_EVENTS) {
     warnings.push(
       `Evidence events truncated from ${events.length} to ${MAX_EVIDENCE_EVENTS} metadata events.`,
@@ -675,7 +784,7 @@ export function createEvolutionDistillationBatch(input: {
           body: [
             `Run ${input.evidenceWindow.runId} produced ${input.evidenceWindow.events.length} redacted metadata evidence event(s).`,
             `Observed role(s): ${roleIds.length === 0 ? "none" : roleIds.join(", ")}.`,
-            "This record is auto-stored and unreviewed; role agents may use it only as contextual evidence.",
+            "This record is derived from metadata-only evidence; active use depends on OKF plan review state.",
           ].join("\n"),
           roleTags: roleIds,
           tags: ["project-run", "auto-stored", "unreviewed"],
@@ -718,7 +827,7 @@ export function createEvolutionDistillationBatch(input: {
               summary: createTriggerSummary(input.evidenceWindow),
             },
             intervention: {
-              summary: `Collected ${input.evidenceWindow.events.length} redacted event(s) and ${input.evidenceWindow.episodes.length} episode(s) from role trace logs.`,
+              summary: `Collected ${input.evidenceWindow.events.length} metadata event(s) and ${input.evidenceWindow.episodes.length} episode(s) from EvoDev execution logs.`,
               roleIds,
             },
             result: {
@@ -891,6 +1000,106 @@ export async function writeEvolutionDistillationBatch(input: {
   };
 }
 
+export async function activateEvolutionDistillationBatch(input: {
+  homeDir: string;
+  batch: EvolutionDistillationBatch;
+  overwrite?: boolean;
+}): Promise<EvolutionActivationResult> {
+  validateEvolutionDistillationBatch(input.batch);
+  const paths = resolveEvolutionPaths({
+    homeDir: input.homeDir,
+    projectKey: input.batch.projectKey,
+    runId: input.batch.runId,
+  });
+  const overwrite = input.overwrite === true;
+  await writeJson(paths.evidenceWindowPath, input.batch.evidenceWindow, { overwrite });
+  await writeJson(paths.batchPath, input.batch, { overwrite });
+
+  const plan = createOkfKnowledgePlanFromDistillationBatch(input.batch, {
+    homeDir: input.homeDir,
+  });
+  const okf = await activateOkfKnowledgePlan({
+    homeDir: input.homeDir,
+    plan,
+    overwrite,
+    evidenceWindowPath: paths.evidenceWindowPath,
+  });
+
+  const evosCasePaths: string[] = [];
+  for (const evosCase of input.batch.evosCases) {
+    const matchingCandidate = plan.candidates.find((candidate) => candidate.id === evosCase.id);
+    const persistedEvosCase =
+      matchingCandidate?.decision === "auto-accept"
+        ? { ...evosCase, reviewState: "auto-accepted" as const }
+        : matchingCandidate?.decision === "needs-human"
+          ? { ...evosCase, reviewState: "needs-human" as const }
+          : evosCase;
+    validateEvolutionEvosCase(persistedEvosCase);
+    const path = join(paths.evosCasesProjectDir, `${evosCase.id}.json`);
+    await writeJson(path, persistedEvosCase, { overwrite });
+    evosCasePaths.push(path);
+  }
+
+  const repoProposalPaths: string[] = [];
+  for (const proposal of input.batch.repoProposals) {
+    const path = join(paths.repoProposalsDir, `${proposal.id}.json`);
+    await writeJson(path, proposal, { overwrite });
+    repoProposalPaths.push(path);
+  }
+
+  const evosCasesRootDir = resolveEvoDevPaths(input.homeDir).evosCasesDir;
+  const evosProjectKeys = await listDirectoryNames(evosCasesRootDir);
+  const evosProjects = await Promise.all(
+    evosProjectKeys.map(async (projectKey) => {
+      const cases = await readJsonFiles(join(evosCasesRootDir, projectKey), parseEvosCase);
+      return {
+        projectKey,
+        cases: cases.map((evosCase) => ({
+          id: evosCase.id,
+          title: evosCase.title,
+          reviewState: evosCase.reviewState,
+        })),
+      };
+    }),
+  );
+  await writeJson(
+    paths.evosIndexPath,
+    {
+      schemaVersion: 1,
+      updatedAt: input.batch.createdAt,
+      projects: evosProjects,
+    },
+    { overwrite: true },
+  );
+
+  const allRunProposals = await readJsonFiles(paths.repoProposalsDir, parseRepoProposal);
+  await writeJson(
+    paths.repoProposalsIndexPath,
+    {
+      schemaVersion: 1,
+      projectKey: input.batch.projectKey,
+      runId: input.batch.runId,
+      updatedAt: input.batch.createdAt,
+      proposals: allRunProposals.map((proposal) => ({
+        id: proposal.id,
+        kind: proposal.kind,
+        title: proposal.title,
+        reviewState: proposal.reviewState,
+      })),
+    },
+    { overwrite: true },
+  );
+
+  return {
+    evidenceWindowPath: paths.evidenceWindowPath,
+    batchPath: paths.batchPath,
+    okf,
+    evosCasePaths,
+    repoProposalPaths,
+    evosIndexPath: paths.evosIndexPath,
+  };
+}
+
 export async function readEvolutionReviewSnapshot(input: {
   homeDir: string;
   projectKey?: string;
@@ -898,11 +1107,12 @@ export async function readEvolutionReviewSnapshot(input: {
   const paths = resolveEvoDevPaths(input.homeDir);
   const projectKeys =
     input.projectKey === undefined
-      ? await listDirectoryNames(paths.knowledgeDir)
+      ? await listEvolutionReviewProjectKeys(paths)
       : [sanitizeStorageId("projectKey", input.projectKey)];
   const knowledgeRecords: EvolutionKnowledgeRecord[] = [];
   const evosCases: EvolutionEvosCase[] = [];
   const repoProposals: EvolutionRepoProposal[] = [];
+  const reviewCandidates: EvolutionReviewCandidate[] = [];
   const triggers: EvolutionTriggerRecord[] = [];
 
   for (const projectKey of projectKeys) {
@@ -927,7 +1137,9 @@ export async function readEvolutionReviewSnapshot(input: {
     const runIds = await listDirectoryNames(projectStateDir);
     for (const runId of runIds) {
       const proposalsDir = join(projectStateDir, runId, "proposals");
+      const reviewCandidatesDir = join(projectStateDir, runId, "review-candidates");
       repoProposals.push(...(await readJsonFiles(proposalsDir, parseRepoProposal)));
+      reviewCandidates.push(...(await readJsonFiles(reviewCandidatesDir, parseReviewCandidate)));
       triggers.push(
         ...(await readJsonFiles(join(projectStateDir, runId, "triggers"), parseTrigger)),
       );
@@ -940,10 +1152,29 @@ export async function readEvolutionReviewSnapshot(input: {
     knowledgeRecords,
     evosCases,
     repoProposals,
+    reviewCandidates,
     triggers,
   };
 }
 
+async function listEvolutionReviewProjectKeys(
+  paths: ReturnType<typeof resolveEvoDevPaths>,
+): Promise<string[]> {
+  const legacyKnowledgeProjectKeys = (
+    await Promise.all(
+      (
+        await listDirectoryNames(paths.knowledgeDir)
+      ).map(async (projectKey) =>
+        (await pathExists(join(paths.knowledgeDir, projectKey, "records"))) ? projectKey : null,
+      ),
+    )
+  ).filter((projectKey): projectKey is string => projectKey !== null);
+  return uniqueSorted([
+    ...legacyKnowledgeProjectKeys,
+    ...(await listDirectoryNames(paths.evosCasesDir)),
+  ]);
+}
+
 export async function listEvolutionKnowledgeRecords(input: {
   homeDir: string;
   projectKey?: string;
@@ -956,6 +1187,59 @@ export async function listEvolutionKnowledgeRecords(input: {
   ).knowledgeRecords.sort((left, right) => left.id.localeCompare(right.id));
 }
 
+export async function listEvolutionEvosCases(input: {
+  homeDir: string;
+  projectKey?: string;
+  roleId?: string;
+  reviewStates?: EvolutionReviewState[];
+}): Promise<EvolutionEvosCaseQueryResult> {
+  const paths = resolveEvoDevPaths(input.homeDir);
+  const projectKeys =
+    input.projectKey === undefined
+      ? await listDirectoryNames(paths.evosCasesDir)
+      : [sanitizeStorageId("projectKey", input.projectKey)];
+  const roleId = input.roleId === undefined ? null : sanitizeId(input.roleId);
+  const reviewStates = input.reviewStates ?? ["accepted", "auto-accepted"];
+  const cases: EvolutionEvosCase[] = [];
+  const warnings: string[] = [];
+
+  for (const projectKey of projectKeys) {
+    const projectDir = join(paths.evosCasesDir, projectKey);
+    if (!(await pathExists(projectDir))) continue;
+    const entries = await readdir(projectDir, { withFileTypes: true });
+    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+      if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+      const sourceLink = `cases/${projectKey}/${entry.name}`;
+      try {
+        const value = JSON.parse(await readFile(join(projectDir, entry.name), "utf8")) as unknown;
+        const evosCase = parseEvosCase(value);
+        if (!reviewStates.includes(evosCase.reviewState)) continue;
+        if (
+          roleId !== null &&
+          evosCase.roleTags.length > 0 &&
+          !evosCase.roleTags.includes(roleId)
+        ) {
+          continue;
+        }
+        cases.push(evosCase);
+      } catch {
+        warnings.push(
+          `Omitted unsafe or invalid evos case: ${sourceLink}. Run evodev knowledge lint.`,
+        );
+      }
+    }
+  }
+
+  return {
+    cases: cases.sort((left, right) => {
+      const project = left.projectKey.localeCompare(right.projectKey);
+      if (project !== 0) return project;
+      return left.id.localeCompare(right.id);
+    }),
+    warnings,
+  };
+}
+
 export async function readEvolutionKnowledgeRecordById(input: {
   homeDir: string;
   knowledgeId: string;
@@ -1057,8 +1341,8 @@ export function formatEvolutionDistillationBatch(batch: EvolutionDistillationBat
     `Knowledge records: ${batch.knowledgeRecords.length}`,
     `Evos cases: ${batch.evosCases.length}`,
     `Repo proposals: ${batch.repoProposals.length}`,
-    "Default review state: auto-stored/unreviewed for knowledge and evos cases.",
-    "Runtime authority: contextual only; hardBlocking=false.",
+    "Default batch review state: contextual until the OKF plan auto-accepts or queues review.",
+    "Runtime authority: accepted/auto-accepted only; hardBlocking=false.",
     ...(batch.knowledgeRecords.length === 0
       ? ["Knowledge: none"]
       : [
@@ -1109,6 +1393,30 @@ export function formatEvolutionWriteResult(result: EvolutionWriteResult): string
   ].join("\n");
 }
 
+export function formatEvolutionActivationResult(result: EvolutionActivationResult): string {
+  return [
+    "EvoDev evolution activate",
+    "",
+    `Evidence window: ${result.evidenceWindowPath}`,
+    `Distillation batch: ${result.batchPath}`,
+    `OKF concepts: ${result.okf.conceptPaths.length}`,
+    ...result.okf.conceptPaths.map((path) => `  - ${path}`),
+    `OKF overlays: ${result.okf.overlayPaths.length}`,
+    ...result.okf.overlayPaths.map((path) => `  - ${path}`),
+    `Skipped candidates: ${result.okf.skippedCandidates.length}`,
+    ...result.okf.skippedCandidates.map((id) => `  - ${id}`),
+    `Needs human: ${result.okf.needsHumanCandidates.length}`,
+    ...result.okf.needsHumanCandidates.map((id) => `  - ${id}`),
+    `Evos cases: ${result.evosCasePaths.length}`,
+    ...result.evosCasePaths.map((path) => `  - ${path}`),
+    `Repo proposals: ${result.repoProposalPaths.length}`,
+    ...result.repoProposalPaths.map((path) => `  - ${path}`),
+    `OKF derived indexes: ${result.okf.derivedIndexPaths.length}`,
+    ...result.okf.derivedIndexPaths.map((path) => `  - ${path}`),
+    `Evos index: ${result.evosIndexPath}`,
+  ].join("\n");
+}
+
 export function formatEvolutionProcessResult(result: EvolutionProcessResult): string {
   return [
     "EvoDev evolution process",
@@ -1147,6 +1455,11 @@ export function formatEvolutionReviewSnapshot(snapshot: EvolutionReviewSnapshot)
       (proposal) =>
         `  - ${proposal.id} (${proposal.projectKey}, ${proposal.kind}, ${proposal.reviewState}, ${proposal.confidence}): ${proposal.title}`,
     ),
+    `Review candidates: ${snapshot.reviewCandidates.length}`,
+    ...snapshot.reviewCandidates.map(
+      (candidate) =>
+        `  - ${candidate.id} (${candidate.projectKey}, ${candidate.candidateKind}, ${candidate.reviewState}): ${candidate.title}`,
+    ),
     `Triggers: ${snapshot.triggers.length}`,
     ...snapshot.triggers.map(
       (trigger) =>
@@ -1166,9 +1479,11 @@ export function resolveEvolutionPaths(input: {
   const evolutionStateDir = join(paths.stateDir, "evolution");
   const runStateDir = join(evolutionStateDir, projectKey, runId);
   const repoProposalsDir = join(runStateDir, "proposals");
+  const reviewCandidatesDir = join(runStateDir, "review-candidates");
   const knowledgeProjectDir = join(paths.knowledgeDir, projectKey);
   const evosCasesProjectDir = join(paths.evosCasesDir, projectKey);
   assertPathDescendant(evolutionStateDir, runStateDir, "runStateDir");
+  assertPathDescendant(evolutionStateDir, reviewCandidatesDir, "reviewCandidatesDir");
   assertPathDescendant(paths.knowledgeDir, knowledgeProjectDir, "knowledgeProjectDir");
   assertPathDescendant(paths.evosCasesDir, evosCasesProjectDir, "evosCasesProjectDir");
   return {
@@ -1179,6 +1494,7 @@ export function resolveEvolutionPaths(input: {
     evidenceWindowPath: join(runStateDir, "evidence-window.json"),
     batchPath: join(runStateDir, "distillation-batch.json"),
     triggersDir: join(runStateDir, "triggers"),
+    reviewCandidatesDir,
     repoProposalsDir,
     repoProposalsIndexPath: join(runStateDir, "proposals.index.json"),
     knowledgeProjectDir,
@@ -1204,6 +1520,9 @@ export function validateEvolutionEvidenceWindow(window: EvolutionEvidenceWindow)
     assertString("sourceRefs.path", sourceRef.path);
     if (sourceRef.rawContentStored !== false)
       throw new Error("sourceRefs.rawContentStored must be false.");
+    if (sourceRef.externalContentCopied !== false) {
+      throw new Error("sourceRefs.externalContentCopied must be false.");
+    }
   }
   if (!Array.isArray(window.events)) throw new Error("events must be an array.");
   for (const event of window.events) {
@@ -1246,7 +1565,15 @@ export function validateEvolutionKnowledgeRecord(record: EvolutionKnowledgeRecor
   assertEnum("kind", record.kind, KNOWLEDGE_KINDS);
   assertEnum("reviewState", record.reviewState, REVIEW_STATES);
   assertEnum("authority", record.authority, ["contextual", "reviewed"]);
-  if (record.reviewState === "auto-stored/unreviewed" && record.authority !== "contextual") {
+  if (record.reviewState === "accepted" && record.authority !== "reviewed") {
+    throw new Error("Accepted knowledge must use reviewed authority.");
+  }
+  if (
+    (record.reviewState === "auto-stored/unreviewed" ||
+      record.reviewState === "auto-accepted" ||
+      record.reviewState === "needs-human") &&
+    record.authority !== "contextual"
+  ) {
     throw new Error("Unreviewed knowledge must remain contextual.");
   }
   if (record.runtime.hardBlocking !== false) {
@@ -1466,7 +1793,7 @@ export async function processEvolutionTriggers(
           warnings: analysis.warnings,
           now,
         });
-        await writeEvolutionDistillationBatch({
+        await activateEvolutionDistillationBatch({
           homeDir: input.homeDir,
           batch,
           overwrite: true,
@@ -1597,6 +1924,57 @@ function validateEvolutionRepoProposal(proposal: EvolutionRepoProposal): void {
   assertNoForbiddenRawFields(proposal);
 }
 
+function validateEvolutionReviewCandidate(candidate: EvolutionReviewCandidate): void {
+  if (!isRecord(candidate)) throw new Error("Review candidate must be an object.");
+  if (candidate.schemaVersion !== 1) {
+    throw new Error("Review candidate schemaVersion must be 1.");
+  }
+  if (candidate.kind !== "evolution-review-candidate") {
+    throw new Error("Review candidate kind is invalid.");
+  }
+  assertString("reviewCandidate.id", candidate.id);
+  assertString("reviewCandidate.projectKey", candidate.projectKey);
+  assertString("reviewCandidate.runId", candidate.runId);
+  assertString("reviewCandidate.createdAt", candidate.createdAt);
+  assertString("reviewCandidate.candidateKind", candidate.candidateKind);
+  assertString("reviewCandidate.title", candidate.title);
+  assertString("reviewCandidate.targetStore", candidate.targetStore);
+  assertString("reviewCandidate.targetPath", candidate.targetPath);
+  assertString("reviewCandidate.stableKey", candidate.stableKey);
+  if (candidate.reviewState !== "needs-human") {
+    throw new Error("Review candidate reviewState must be needs-human.");
+  }
+  if (!Array.isArray(candidate.reasons))
+    throw new Error("Review candidate reasons must be an array.");
+  for (const reason of candidate.reasons) assertString("reviewCandidate.reasons", reason);
+  if (!isRecord(candidate.provenance))
+    throw new Error("Review candidate provenance must be an object.");
+  assertString("reviewCandidate.provenance.runId", candidate.provenance.runId);
+  assertString(
+    "reviewCandidate.provenance.evidenceWindowId",
+    candidate.provenance.evidenceWindowId,
+  );
+  if (candidate.provenance.createdBy !== "evodev") {
+    throw new Error("Review candidate provenance.createdBy must be evodev.");
+  }
+  if (!Array.isArray(candidate.provenance.evidenceRefs)) {
+    throw new Error("Review candidate evidenceRefs must be an array.");
+  }
+  for (const evidenceRef of candidate.provenance.evidenceRefs) {
+    assertString("reviewCandidate.provenance.evidenceRefs", evidenceRef);
+  }
+  if (
+    candidate.provenance.rawLogsStored !== false ||
+    candidate.provenance.rawPromptsStored !== false ||
+    candidate.provenance.sourceDumpsStored !== false ||
+    candidate.provenance.rawCommandOutputStored !== false
+  ) {
+    throw new Error("Review candidate provenance must remain metadata-only.");
+  }
+  assertPrivacy(candidate.privacy);
+  assertNoForbiddenRawFields(candidate);
+}
+
 function validateEvolutionTriggerRecord(trigger: EvolutionTriggerRecord): void {
   if (!isRecord(trigger)) throw new Error("Evolution trigger must be an object.");
   if (trigger.schemaVersion !== 1) throw new Error("Evolution trigger schemaVersion must be 1.");
@@ -1620,6 +1998,90 @@ function validateEvolutionTriggerRecord(trigger: EvolutionTriggerRecord): void {
   assertNoForbiddenRawFields(trigger);
 }
 
+async function readExecutionEvidenceEvents(input: {
+  path: string;
+  roleId: string;
+  sourceRefId: string;
+  existingCount: number;
+}): Promise<{ events: EvolutionEvidenceEvent[]; warnings: string[]; traceRefIds: string[] }> {
+  const raw = await readFile(input.path, "utf8");
+  const lines = raw.split("\n");
+  const events: EvolutionEvidenceEvent[] = [];
+  const warnings: string[] = [];
+  const traceRefIds = new Set<string>();
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index]?.trim();
+    if (line === undefined || line === "") continue;
+
+    try {
+      const value = JSON.parse(line) as unknown;
+      if (!isRecord(value) || value.kind !== "evodev-execution-event") continue;
+      const codeAgentTraceRefId = optionalString(value.codeAgentTraceRefId);
+      if (codeAgentTraceRefId !== null) traceRefIds.add(codeAgentTraceRefId);
+      const event = createEvidenceEventFromExecutionEvent({
+        executionEvent: value as unknown as EvoDevExecutionEventV1,
+        roleId: input.roleId,
+        sourceRefId: input.sourceRefId,
+        lineNumber: index + 1,
+        sequence: input.existingCount + events.length + 1,
+      });
+      if (event !== null) events.push(event);
+    } catch {
+      warnings.push(
+        `Skipped malformed execution event JSON at ${basename(input.path)}:${index + 1}.`,
+      );
+    }
+  }
+
+  return { events, warnings, traceRefIds: [...traceRefIds] };
+}
+
+function createEvidenceEventFromExecutionEvent(input: {
+  executionEvent: EvoDevExecutionEventV1;
+  roleId: string;
+  sourceRefId: string;
+  lineNumber: number;
+  sequence: number;
+}): EvolutionEvidenceEvent | null {
+  const metadata = isRecord(input.executionEvent.metadata) ? input.executionEvent.metadata : {};
+  const phase = optionalString(metadata.phase);
+  const target = optionalString(input.executionEvent.target);
+  const eventType = optionalString(input.executionEvent.eventType);
+  const summarySource =
+    optionalString(input.executionEvent.summary) ?? [target, phase].filter(Boolean).join(" ");
+  if (summarySource.trim() === "") return null;
+  const normalizedType = normalizeEvolutionEventType(eventType);
+  const kind = classifyEvidenceEvent({
+    error: null,
+    summary: summarySource,
+    target,
+    eventType,
+    phase,
+  });
+  const trigger = decideEvolutionTrigger({
+    eventType: normalizedType,
+    summary: summarySource,
+    kind,
+  });
+
+  return {
+    id: `event-${String(input.sequence).padStart(4, "0")}`,
+    kind,
+    eventType: normalizedType,
+    hookEventId: sanitizeOptionalId(input.executionEvent.eventId),
+    occurredAt: optionalString(input.executionEvent.timestamp),
+    summary: sanitizeText(summarySource),
+    roleId: sanitizeOptionalId(input.executionEvent.roleId) ?? sanitizeId(input.roleId),
+    taskId: sanitizeOptionalId(input.executionEvent.taskId),
+    evidenceRef: `${input.sourceRefId}#L${input.lineNumber}`,
+    episodeIds: [],
+    triggerStrength: trigger.strength,
+    triggerReason: trigger.reason,
+    rawContentStored: false,
+  };
+}
+
 async function readTraceEvidenceEvents(input: {
   path: string;
   roleId: string;
@@ -2034,6 +2496,11 @@ function parseRepoProposal(value: unknown): EvolutionRepoProposal {
   return value as EvolutionRepoProposal;
 }
 
+function parseReviewCandidate(value: unknown): EvolutionReviewCandidate {
+  validateEvolutionReviewCandidate(value as EvolutionReviewCandidate);
+  return value as EvolutionReviewCandidate;
+}
+
 function parseTrigger(value: unknown): EvolutionTriggerRecord {
   validateEvolutionTriggerRecord(value as EvolutionTriggerRecord);
   return value as EvolutionTriggerRecord;
@@ -2146,6 +2613,10 @@ async function listDirectoryNames(dir: string): Promise<string[]> {
     .sort();
 }
 
+function uniqueSorted(values: string[]): string[] {
+  return [...new Set(values)].sort();
+}
+
 async function writeJson(
   path: string,
   value: unknown,