@evo-dev/core 0.0.1-alpha.5 → 0.0.1-alpha.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evo-dev/core",
-  "version": "0.0.1-alpha.5",
+  "version": "0.0.1-alpha.6",
   "type": "module",
   "repository": {
     "type": "git",

package/src/agents/index.ts

@@ -4,17 +4,8 @@ import {
   createScopedKnowledgeContextPack,
   formatScopedKnowledgePromptBlock,
 } from "../evolution/knowledge/index.ts";
-import type { TaskContract, TaskExecutionMode } from "../task/index.ts";
 
 export type AgentPersistence = "named" | "dynamic";
-export type AgentLens =
-  | "review"
-  | "qa"
-  | "security"
-  | "release"
-  | "architecture"
-  | "migration"
-  | "test";
 export type AgentOutputSchemaId =
   | "review-findings-v1"
   | "verification-summary-v1"
@@ -61,34 +52,6 @@ export interface AgentProfile {
   };
 }
 
-export interface AgentPlannedInvocation {
-  profile: AgentProfile;
-  lens: AgentLens;
-  reason: string;
-  plannedOnly: true;
-}
-
-export interface AgentMergePlan {
-  strategy: "none" | "single-output" | "dedupe-preserve-conflicts";
-  outputSchema: AgentOutputSchemaId | null;
-  dedupeBy: string[];
-  conflictPolicy: string[];
-  advisoryCategories: string[];
-}
-
-export interface AgentComposeDryRunPlan {
-  ok: boolean;
-  taskId: string;
-  mode: TaskExecutionMode | null;
-  workflowId: string | null;
-  agents: AgentPlannedInvocation[];
-  permissions: AgentPermissions;
-  mergePlan: AgentMergePlan;
-  warnings: string[];
-  advisories: string[];
-  rationale: string;
-}
-
 export interface AgentContextDryRunBundle {
   profile: AgentProfile;
   context: {
@@ -138,17 +101,6 @@ const DEFAULT_AGENT_PERMISSIONS: AgentPermissions = {
 };
 const FORBIDDEN_INPUTS = ["rawPrompts", "secrets", "rawCommandLogs", "sourceCorpus"];
 const SAFE_AGENT_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
-const PRIVACY_ADVISORY_PATTERN =
-  /raw prompt|rawprompt|source corpus|sourcecorpus|secret|\.env|raw command|raw log|internal url|private url|network|write files|run commands|spawn agents|write memory/i;
-const LENS_TO_EXPERTISE: Record<AgentLens, string[]> = {
-  review: ["code-review"],
-  qa: ["qa", "verification"],
-  security: ["security", "privacy"],
-  release: ["release", "packaging"],
-  architecture: ["architecture"],
-  migration: ["migration", "impact-analysis"],
-  test: ["testing"],
-};
 
 export function createDefaultAgentPermissions(): AgentPermissions {
   return { ...DEFAULT_AGENT_PERMISSIONS };
@@ -202,67 +154,6 @@ export async function readAgentProfile(path: string): Promise<AgentProfile> {
   return parseAgentProfile(JSON.parse(await readFile(path, "utf8")));
 }
 
-export function composeAgentDryRun(input: {
-  contract: TaskContract;
-  workflowId?: string;
-  lenses?: AgentLens[];
-}): AgentComposeDryRunPlan {
-  const mode = input.contract.route.mode;
-  const workflowId = input.workflowId ?? input.contract.route.workflowId;
-  const warnings: string[] = [];
-  const permissions = createDefaultAgentPermissions();
-  const requestedLenses = dedupeLenses(input.lenses ?? []);
-  const advisories = collectPrivacyBoundaryAdvisories(input.contract, requestedLenses, workflowId);
-
-  if (mode === "minimal") {
-    return {
-      ok: advisories.length === 0,
-      taskId: input.contract.taskId,
-      mode,
-      workflowId,
-      agents: [],
-      permissions,
-      mergePlan: createMergePlan([]),
-      warnings,
-      advisories,
-      rationale: "Minimal mode does not force dynamic agents by default.",
-    };
-  }
-
-  const selectedLenses = selectLenses(
-    mode,
-    requestedLenses,
-    workflowId,
-    input.contract.route.requiredReview,
-  );
-  const agents = selectedLenses.map((lens) => ({
-    profile: createDynamicProfile(lens, input.contract, permissions),
-    lens,
-    reason: createLensReason(lens, mode, workflowId),
-    plannedOnly: true as const,
-  }));
-
-  if (mode === "standard" && agents.length > 1) {
-    warnings.push("Standard mode advisory selected more than one reviewer/triager.");
-  }
-
-  return {
-    ok: advisories.length === 0,
-    taskId: input.contract.taskId,
-    mode,
-    workflowId,
-    agents,
-    permissions,
-    mergePlan: createMergePlan(agents),
-    warnings,
-    advisories,
-    rationale:
-      agents.length === 0
-        ? "No dynamic agents selected; deterministic verification may be sufficient."
-        : `Selected ${agents.length} planned-only agent(s) based on mode/workflow/lenses.`,
-  };
-}
-
 export function loadAgentContextDryRun(profile: AgentProfile): AgentContextDryRunBundle {
   const parsed = parseAgentProfile(profile);
   return {
@@ -376,47 +267,6 @@ export function mergeReviewFindings(outputs: ReviewFindingOutput[]): {
   return { acceptedFindings: [...byKey.values()], unresolvedConflicts: conflicts };
 }
 
-export function formatAgentComposeDryRun(plan: AgentComposeDryRunPlan): string {
-  return [
-    "EvoDev agent compose dry-run",
-    "",
-    `Task: ${plan.taskId}`,
-    `Mode: ${plan.mode ?? "not routed"}`,
-    `Workflow: ${plan.workflowId ?? "none"}`,
-    `Rationale: ${plan.rationale}`,
-    "No-write/no-spawn: true",
-    "Privacy: local-private, metadata-only, raw prompts/source/secrets/logs forbidden",
-    "Agents:",
-    ...(plan.agents.length === 0
-      ? ["  - none"]
-      : plan.agents.map(
-          (agent) =>
-            `  - ${agent.profile.id} [${agent.lens}] traits=${agent.profile.traits.expertise.join(",")} schema=${agent.profile.output.schema} plannedOnly=${agent.plannedOnly}`,
-        )),
-    "Inputs:",
-    ...(plan.agents.length === 0
-      ? ["  - none"]
-      : [
-          `  - required: ${plan.agents[0].profile.inputs.required.join(",")}`,
-          `  - optional: ${plan.agents[0].profile.inputs.optional.join(",")}`,
-          `  - forbidden: ${plan.agents[0].profile.inputs.forbidden.join(",")}`,
-        ]),
-    "Permissions:",
-    ...Object.entries(plan.permissions).map(([key, value]) => `  - ${key}: ${value}`),
-    "Merge plan:",
-    `  - strategy: ${plan.mergePlan.strategy}`,
-    `  - outputSchema: ${plan.mergePlan.outputSchema ?? "none"}`,
-    "Warnings:",
-    ...(plan.warnings.length === 0
-      ? ["  - none"]
-      : plan.warnings.map((warning) => `  - ${warning}`)),
-    "Advisories:",
-    ...(plan.advisories.length === 0
-      ? ["  - none"]
-      : plan.advisories.map((advisory) => `  - ${advisory}`)),
-  ].join("\n");
-}
-
 export function formatAgentContextDryRun(bundle: AgentContextDryRunBundle): string {
   return [
     "EvoDev agent load-context dry-run",
@@ -436,116 +286,6 @@ export function formatAgentContextDryRun(bundle: AgentContextDryRunBundle): stri
   ].join("\n");
 }
 
-function createDynamicProfile(
-  lens: AgentLens,
-  contract: TaskContract,
-  permissions: AgentPermissions,
-): AgentProfile {
-  return {
-    version: 1,
-    id: `dynamic-${lens}-${contract.taskId}`.slice(0, 100),
-    name: `Dynamic ${lens} reviewer`,
-    persistence: "dynamic",
-    description: `Task-scoped ${lens} profile for metadata-only dry-run planning.`,
-    traits: {
-      expertise: LENS_TO_EXPERTISE[lens],
-      stance: ["skeptical-reviewer"],
-      approach: ["evidence-first", "advisory"],
-      domain: ["software-rd"],
-    },
-    inputs: {
-      required: ["taskContract", "scope", "evidenceSummary"],
-      optional: ["workflowPlan"],
-      forbidden: FORBIDDEN_INPUTS,
-    },
-    permissions,
-    output: {
-      schema: "review-findings-v1",
-      requiredFields: ["summary", "findings", "confidence", "evidenceRefs"],
-    },
-    privacy: {
-      classification: "local-private",
-      metadataOnly: true,
-      rawPromptStored: false,
-      sourceContentStored: false,
-    },
-  };
-}
-
-function selectLenses(
-  mode: TaskExecutionMode | null,
-  requested: AgentLens[],
-  workflowId: string | null,
-  requiredReview: string[],
-): AgentLens[] {
-  if (requested.length > 0) return mode === "standard" ? requested.slice(0, 1) : requested;
-  if (mode === "standard") return requiredReview.length > 0 ? ["review"] : [];
-  if (mode === "rigorous") {
-    if (workflowId?.includes("security")) return ["security", "review"];
-    if (workflowId?.includes("release")) return ["release", "security"];
-    if (workflowId?.includes("migration")) return ["migration", "architecture"];
-    if (workflowId?.includes("architecture")) return ["architecture", "review"];
-    return requiredReview.length > 0 ? ["review", "qa"] : [];
-  }
-  return [];
-}
-
-function createMergePlan(agents: AgentPlannedInvocation[]): AgentMergePlan {
-  if (agents.length === 0)
-    return {
-      strategy: "none",
-      outputSchema: null,
-      dedupeBy: [],
-      conflictPolicy: [],
-      advisoryCategories: [],
-    };
-  if (agents.length === 1)
-    return {
-      strategy: "single-output",
-      outputSchema: agents[0].profile.output.schema,
-      dedupeBy: [],
-      conflictPolicy: [],
-      advisoryCategories: [],
-    };
-  return {
-    strategy: "dedupe-preserve-conflicts",
-    outputSchema: "review-findings-v1",
-    dedupeBy: ["category", "path", "line", "title"],
-    conflictPolicy: ["preserve dissent", "keep higher severity unless evidence refutes"],
-    advisoryCategories: ["security", "privacy", "release"],
-  };
-}
-
-function createLensReason(
-  lens: AgentLens,
-  mode: TaskExecutionMode | null,
-  workflowId: string | null,
-): string {
-  return `${lens} lens selected for ${mode ?? "unrouted"} mode${workflowId ? ` and workflow ${workflowId}` : ""}.`;
-}
-
-function collectPrivacyBoundaryAdvisories(
-  contract: TaskContract,
-  lenses: AgentLens[],
-  workflowId: string | null,
-): string[] {
-  const text = [
-    contract.source.summary,
-    contract.currentState.summary,
-    contract.targetState.summary,
-    contract.route.rationale,
-    workflowId ?? "",
-    ...contract.scope.allowedOperations,
-    ...contract.scope.requiresUserConfirmation,
-    ...lenses,
-  ].join(" ");
-  return PRIVACY_ADVISORY_PATTERN.test(text)
-    ? [
-        "Agent planning detected privacy/risky context requiring raw data, writes, commands, network, spawning, or memory.",
-      ]
-    : [];
-}
-
 function validateRequiredObject(
   output: unknown,
   fields: string[],
@@ -569,10 +309,6 @@ function isKnownOutputSchema(value: unknown): value is AgentOutputSchemaId {
   );
 }
 
-function dedupeLenses(lenses: AgentLens[]): AgentLens[] {
-  return [...new Set(lenses)];
-}
-
 function severityRank(severity: AgentFindingSeverity): number {
   return { info: 0, low: 1, medium: 2, high: 3, critical: 4 }[severity];
 }

package/src/code-agent-traces/index.ts

@@ -1,6 +1,7 @@
 import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, normalize, relative } from "node:path";
 import { resolveEvoDevPaths } from "../config/paths.ts";
+import { resolveProjectWorkspaceFromCwd } from "../projects/index.ts";
 import { resolveTraceSessionKey, resolveTraceTeamContext } from "../runtime-logs/index.ts";
 import { normalizeTimestamp, sha256Short } from "../utils/index.ts";
 
@@ -264,6 +265,11 @@ export async function recordCodeAgentTraceRefFromHook(
     payload: input.payload,
     environment,
   });
+  const cwd = optionalString(input.payload.cwd);
+  const workspace =
+    team === null && cwd !== null
+      ? await resolveProjectWorkspaceFromCwd({ homeDir: input.homeDir, cwd })
+      : null;
   const source =
     sessionIdFromPayload !== null || tracePathFromPayload !== null ? "hook-payload" : "environment";
 
@@ -271,10 +277,10 @@ export async function recordCodeAgentTraceRefFromHook(
     target: input.target,
     sessionKey: resolveTraceSessionKey(input.payload),
     nativeSessionId,
-    projectKey: team?.projectKey ?? null,
+    projectKey: team?.projectKey ?? workspace?.projectKey ?? null,
     runId: team?.runId ?? null,
     roleId: team?.roleId ?? null,
-    cwd: optionalString(input.payload.cwd),
+    cwd,
     discoveredAt: input.now,
     source,
     tracePath: normalizedPath,

package/src/daemon/index.ts

@@ -251,8 +251,6 @@ export async function handleDaemonRequest(
   }
   if (input.method !== "GET") return notFound(warnings);
 
-  if (input.path === "/tasks")
-    return ok(await collectTaskSummaries(input.homeDir, warnings), warnings);
   if (input.path === "/observability/events")
     return ok(await collectObservabilitySummaries(input.homeDir, warnings), warnings);
   if (input.path === "/memory/candidates")
@@ -407,33 +405,6 @@ function isAllowedLocalOrigin(origin: string | null): boolean {
   }
 }
 
-async function collectTaskSummaries(homeDir: string, warnings: string[]): Promise<unknown[]> {
-  const root = join(homeDir, ".evodev", "STATE", "tasks");
-  if (!(await pathExists(root))) {
-    warnings.push("Task store not found; returning empty tasks.");
-    return [];
-  }
-  const contracts = await collectNamedFiles(root, "contract.json");
-  const summaries: unknown[] = [];
-  for (const file of contracts) {
-    try {
-      const contract = JSON.parse(await readFile(file, "utf8"));
-      summaries.push(
-        sanitizeMetadata({
-          taskId: contract.taskId,
-          status: contract.status,
-          mode: contract.route?.mode ?? null,
-          workflowId: contract.route?.workflowId ?? null,
-          verificationStatus: contract.verification?.status ?? null,
-        }),
-      );
-    } catch {
-      warnings.push(`Skipped unreadable task contract: ${file}`);
-    }
-  }
-  return summaries;
-}
-
 async function collectObservabilitySummaries(
   homeDir: string,
   warnings: string[],
@@ -841,17 +812,6 @@ function describeError(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
-async function collectNamedFiles(root: string, name: string): Promise<string[]> {
-  const entries = await readdir(root, { withFileTypes: true });
-  const files: string[] = [];
-  for (const entry of entries) {
-    const path = join(root, entry.name);
-    if (entry.isDirectory()) files.push(...(await collectNamedFiles(path, name)));
-    else if (entry.isFile() && entry.name === name) files.push(path);
-  }
-  return files;
-}
-
 function ok(data: unknown, warnings: string[]): { status: number; body: DaemonResponseBody } {
   return { status: 200, body: { ok: true, data: sanitizeMetadata(data), warnings } };
 }

package/src/evolution/candidates/index.ts

@@ -411,29 +411,88 @@ export async function updateEvolutionRepoProposalReviewState(input: {
         },
       };
       validateEvolutionRepoProposal(next);
-      await writeJson(path, next, { overwrite: true });
-      const allRunProposals = await readJsonFiles(paths.repoProposalsDir, parseRepoProposal);
-      await writeJson(
-        paths.repoProposalsIndexPath,
-        {
-          schemaVersion: 1,
-          projectKey: next.projectKey,
-          runId: next.provenance.runId,
-          updatedAt: changedAt,
-          proposals: allRunProposals.map((proposal) => ({
-            id: proposal.id,
-            kind: proposal.kind,
-            title: proposal.title,
-            reviewState: proposal.reviewState,
-          })),
-        },
-        { overwrite: true },
-      );
+      await writeRepoProposalAndIndex({ homeDir: input.homeDir, proposal: next, changedAt });
+      return { path, record: next, changed: true };
+    },
+  );
+}
+
+export async function markEvolutionRepoProposalApplied(input: {
+  homeDir: string;
+  proposalId: string;
+  projectKey?: string;
+  expectedReviewState?: EvolutionRepoProposal["reviewState"];
+  now?: string | Date;
+}): Promise<{ path: string; record: EvolutionRepoProposal; changed: boolean }> {
+  return await withEvolutionReviewDecisionLock(
+    { homeDir: input.homeDir, kind: "repo-proposal", itemId: input.proposalId },
+    async () => {
+      const record = await readEvolutionRepoProposalById(input);
+      if (!hasConcreteRepoProposalChanges(record)) {
+        throw new Error("Repo proposal has no concrete repository changes to apply.");
+      }
+      if (
+        input.expectedReviewState !== undefined &&
+        record.reviewState !== input.expectedReviewState
+      ) {
+        throw new Error("Repo proposal review state changed before it was marked applied.");
+      }
+      const paths = resolveEvolutionPaths({
+        homeDir: input.homeDir,
+        projectKey: record.projectKey,
+        runId: record.provenance.runId,
+      });
+      const path = join(paths.repoProposalsDir, `${record.id}.json`);
+      if (record.reviewState === "applied") return { path, record, changed: false };
+      if (record.reviewState !== "accepted") {
+        throw new Error("Only accepted repo proposals can be marked applied.");
+      }
+
+      const changedAt = normalizeTimestamp(input.now);
+      const next: EvolutionRepoProposal = {
+        ...record,
+        reviewState: "applied",
+        reviewStateChangedAt: changedAt,
+      };
+      validateEvolutionRepoProposal(next);
+      await writeRepoProposalAndIndex({ homeDir: input.homeDir, proposal: next, changedAt });
       return { path, record: next, changed: true };
     },
   );
 }
 
+async function writeRepoProposalAndIndex(input: {
+  homeDir: string;
+  proposal: EvolutionRepoProposal;
+  changedAt: string;
+}): Promise<void> {
+  const paths = resolveEvolutionPaths({
+    homeDir: input.homeDir,
+    projectKey: input.proposal.projectKey,
+    runId: input.proposal.provenance.runId,
+  });
+  await writeJson(join(paths.repoProposalsDir, `${input.proposal.id}.json`), input.proposal, {
+    overwrite: true,
+  });
+  const allRunProposals = await readJsonFiles(paths.repoProposalsDir, parseRepoProposal);
+  await writeJson(
+    paths.repoProposalsIndexPath,
+    {
+      schemaVersion: 1,
+      projectKey: input.proposal.projectKey,
+      runId: input.proposal.provenance.runId,
+      updatedAt: input.changedAt,
+      proposals: allRunProposals.map((proposal) => ({
+        id: proposal.id,
+        kind: proposal.kind,
+        title: proposal.title,
+        reviewState: proposal.reviewState,
+      })),
+    },
+    { overwrite: true },
+  );
+}
+
 function parseKnowledgeReviewHistoryRecord(value: unknown): EvolutionKnowledgeReviewHistoryRecord {
   if (!isRecord(value)) throw new Error("Knowledge review history record must be an object.");
   const allowedKeys = new Set([

package/src/evolution/evidence/session-memory/storage.ts

@@ -55,6 +55,34 @@ export async function listSessionEvidenceSegments(input: {
   return segments.sort((left, right) => right.createdAt.localeCompare(left.createdAt));
 }
 
+export async function listSessionMemoryStates(input: {
+  homeDir: string;
+  projectKey?: string;
+}): Promise<SessionMemoryStateV1[]> {
+  const rootDir = join(resolveEvoDevPaths(input.homeDir).stateDir, "session-memory");
+  const projectDirs =
+    input.projectKey === undefined ? await listDirectoryNames(rootDir) : [input.projectKey];
+  const states: SessionMemoryStateV1[] = [];
+  for (const projectKey of projectDirs) {
+    const projectDir = join(rootDir, projectKey);
+    for (const sessionKey of await listDirectoryNames(projectDir)) {
+      try {
+        const state = parseSessionMemoryState(
+          JSON.parse(await readFile(join(projectDir, sessionKey, "state.json"), "utf8")) as unknown,
+        );
+        if (state.projectKey === projectKey && state.sessionKey === sessionKey) states.push(state);
+      } catch {
+        // Invalid local state is omitted from listings and remains available for diagnostics.
+      }
+    }
+  }
+  return states.sort(
+    (left, right) =>
+      right.updatedAt.localeCompare(left.updatedAt) ||
+      left.sessionKey.localeCompare(right.sessionKey),
+  );
+}
+
 export async function readSessionEvidenceSegment(input: {
   homeDir: string;
   projectKey: string;
@@ -241,6 +269,28 @@ function parseSessionEvidenceSegment(value: unknown): SessionEvidenceSegmentV1 {
   return segment as SessionEvidenceSegmentV1;
 }
 
+function parseSessionMemoryState(value: unknown): SessionMemoryStateV1 {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new SessionMemoryEvidenceError("invalid", "Session Memory state must be an object.");
+  }
+  const state = value as Partial<SessionMemoryStateV1>;
+  if (
+    state.schemaVersion !== 1 ||
+    state.kind !== "session-memory-state" ||
+    typeof state.projectKey !== "string" ||
+    typeof state.sessionKey !== "string" ||
+    !(state.runId === null || typeof state.runId === "string") ||
+    !(state.roleId === null || typeof state.roleId === "string") ||
+    typeof state.createdAt !== "string" ||
+    typeof state.updatedAt !== "string" ||
+    typeof state.counters !== "object" ||
+    state.counters === null
+  ) {
+    throw new SessionMemoryEvidenceError("invalid", "Session Memory state fields are invalid.");
+  }
+  return state as SessionMemoryStateV1;
+}
+
 async function listDirectoryNames(path: string): Promise<string[]> {
   try {
     return (await readdir(path, { withFileTypes: true }))

package/src/evolution/evidence/session-memory/updater.ts

@@ -1,4 +1,5 @@
 import { join } from "node:path";
+import { resolveProjectWorkspaceFromCwd } from "../../../projects/index.ts";
 import {
   resolveProjectLogKey,
   resolveTraceSessionKey,
@@ -42,9 +43,15 @@ export async function updateSessionMemoryFromHook(
     environment: input.environment,
     payload: input.rawPayload,
   });
+  const cwd = optionalString(input.rawPayload.cwd);
+  const workspace =
+    team === null && cwd !== null
+      ? await resolveProjectWorkspaceFromCwd({ homeDir: input.homeDir, cwd })
+      : null;
   const projectKey = sanitizeStorageId(
     team?.projectKey ??
-      resolveProjectLogKey(input.homeDir, optionalString(input.rawPayload.cwd) ?? input.homeDir),
+      workspace?.projectKey ??
+      resolveProjectLogKey(input.homeDir, cwd ?? input.homeDir),
     "project",
   );
   const sessionKey = sanitizeStorageId(resolveTraceSessionKey(input.rawPayload), "session");

package/src/evolution/review/index.ts

@@ -31,7 +31,6 @@ export interface LearningCandidate {
   };
   provenance: {
     taskId: string | null;
-    taskContractRef: string | null;
     workflowRunId: string | null;
     evidenceRefs: string[];
     sourceType:
@@ -198,7 +197,6 @@ export function createLearningCandidate(input: {
     },
     provenance: {
       taskId: sanitizeNullableId(input.provenance.taskId),
-      taskContractRef: sanitizeNullableText(input.provenance.taskContractRef),
       workflowRunId: sanitizeNullableId(input.provenance.workflowRunId),
       evidenceRefs: input.provenance.evidenceRefs.map(sanitizeText),
       sourceType: input.provenance.sourceType,
@@ -626,13 +624,9 @@ async function parseJsonOrJsonlFile<T>(
 }
 
 function candidatePathFields(candidate: LearningCandidate): Array<[string, string]> {
-  return [
-    ["provenance.taskContractRef", candidate.provenance.taskContractRef],
-    ...candidate.provenance.evidenceRefs.map((ref, index): [string, string] => [
-      `provenance.evidenceRefs[${index}]`,
-      ref,
-    ]),
-  ].filter((entry): entry is [string, string] => typeof entry[1] === "string");
+  return candidate.provenance.evidenceRefs
+    .map((ref, index): [string, string] => [`provenance.evidenceRefs[${index}]`, ref])
+    .filter((entry): entry is [string, string] => typeof entry[1] === "string");
 }
 
 function isCandidateStale(candidate: LearningCandidate, now: string | undefined): boolean {

package/src/evolution/schema.ts

@@ -4,7 +4,6 @@ export type EvolutionEvidenceSourceKind =
   | "evodev-execution-event"
   | "team-agent-trace"
   | "session-trace"
-  | "task-contract"
   | "verification"
   | "review-summary"
   | "user-feedback"