@evo-dev/core 0.0.1-alpha.18 → 0.0.1-alpha.19

package/dist/assets/index.js

@@ -200,10 +200,10 @@ function isNodeError(error) {
   return error instanceof Error && "code" in error;
 }
 export {
-  scanSkillAssets,
-  scanAssets,
-  scanAgentAssets,
-  parseSkillManifest,
+  EvoDevAssetError,
   parseAgentManifest,
-  EvoDevAssetError
+  parseSkillManifest,
+  scanAgentAssets,
+  scanAssets,
+  scanSkillAssets
 };

package/dist/config/index.js

@@ -2011,21 +2011,21 @@ function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 export {
-  resolveEvoDevPaths,
-  readRuntimeInjectionSettings,
-  parseSyncState,
-  parseSettings,
-  parseRegistry,
-  parseInstallState,
-  mergeSettings,
-  initializeCoreConfig,
-  createDefaultTeamRuntimeSettings,
-  createDefaultSyncState,
-  createDefaultSettings,
-  createDefaultRegistry,
-  createDefaultMemorySettings,
-  createDefaultInstallState,
-  createDefaultEvolutionSettings,
+  EvoDevConfigError,
   createCoreConfigStore,
-  EvoDevConfigError
+  createDefaultEvolutionSettings,
+  createDefaultInstallState,
+  createDefaultMemorySettings,
+  createDefaultRegistry,
+  createDefaultSettings,
+  createDefaultSyncState,
+  createDefaultTeamRuntimeSettings,
+  initializeCoreConfig,
+  mergeSettings,
+  parseInstallState,
+  parseRegistry,
+  parseSettings,
+  parseSyncState,
+  readRuntimeInjectionSettings,
+  resolveEvoDevPaths
 };

package/dist/index.js

@@ -19,48 +19,48 @@ import { readFile as readFile11 } from "node:fs/promises";
 // packages/core/src/evolution/knowledge/index.ts
 var exports_knowledge = {};
 __export(exports_knowledge, {
-  writeFailedOkfKnowledgePlanArtifact: () => writeFailedOkfKnowledgePlanArtifact,
-  writeContextInjectionReceipt: () => writeContextInjectionReceipt,
-  validateOkfKnowledgePlanContract: () => validateOkfKnowledgePlanContract,
-  supersedeOkfKnowledgeConcept: () => supersedeOkfKnowledgeConcept,
-  scoreOkfKnowledgeCandidate: () => scoreOkfKnowledgeCandidate,
-  scoreLexicalKnowledgeDocument: () => scoreLexicalKnowledgeDocument,
-  revokeOkfKnowledgeConcept: () => revokeOkfKnowledgeConcept,
-  resumeFailedOkfKnowledgePlan: () => resumeFailedOkfKnowledgePlan,
-  resolveOkfKnowledgePaths: () => resolveOkfKnowledgePaths,
-  resolveContextInjectionReceiptPath: () => resolveContextInjectionReceiptPath,
-  rebuildOkfKnowledgeIndexes: () => rebuildOkfKnowledgeIndexes,
-  readOkfKnowledgeConcept: () => readOkfKnowledgeConcept,
-  readFailedOkfKnowledgePlanArtifact: () => readFailedOkfKnowledgePlanArtifact,
-  readFailedOkfKnowledgePlan: () => readFailedOkfKnowledgePlan,
-  rankKnowledgeContextItems: () => rankKnowledgeContextItems,
-  queryScopedOkfKnowledgeContext: () => queryScopedOkfKnowledgeContext,
-  queryOkfKnowledge: () => queryOkfKnowledge,
-  quarantineLegacyGeneratedKnowledge: () => quarantineLegacyGeneratedKnowledge,
-  previewLegacyGeneratedKnowledgeCleanup: () => previewLegacyGeneratedKnowledgeCleanup,
-  parseKnowledgeDistillationOutput: () => parseKnowledgeDistillationOutput,
-  mergeAcceptedEvosCasesIntoKnowledgeQuery: () => mergeAcceptedEvosCasesIntoKnowledgeQuery,
-  markOkfKnowledgeConceptStale: () => markOkfKnowledgeConceptStale,
-  loadActiveOkfKnowledgeIndex: () => loadActiveOkfKnowledgeIndex,
-  listOkfKnowledgeConcepts: () => listOkfKnowledgeConcepts,
-  lintOkfKnowledge: () => lintOkfKnowledge,
-  hasContextInjectionReceipt: () => hasContextInjectionReceipt,
-  formatScopedKnowledgePromptBlock: () => formatScopedKnowledgePromptBlock,
-  formatOkfKnowledgeQuery: () => formatOkfKnowledgeQuery,
-  formatOkfKnowledgePlan: () => formatOkfKnowledgePlan,
-  formatOkfKnowledgeList: () => formatOkfKnowledgeList,
-  formatOkfKnowledgeLint: () => formatOkfKnowledgeLint,
-  findCandidateConflictOrDuplicate: () => findCandidateConflictOrDuplicate,
-  finalizeCuratedKnowledgePlan: () => finalizeCuratedKnowledgePlan,
-  ensureOkfKnowledgeBase: () => ensureOkfKnowledgeBase,
-  discardFailedOkfKnowledgePlan: () => discardFailedOkfKnowledgePlan,
-  decideOkfKnowledgeCandidate: () => decideOkfKnowledgeCandidate,
-  createScopedKnowledgeContextPack: () => createScopedKnowledgeContextPack,
-  createOkfKnowledgePlanFromDistillationBatch: () => createOkfKnowledgePlanFromDistillationBatch,
-  createLexicalKnowledgeDocumentFromOkfConcept: () => createLexicalKnowledgeDocumentFromOkfConcept,
-  createLexicalKnowledgeDocumentFromEvosCase: () => createLexicalKnowledgeDocumentFromEvosCase,
+  activateOkfKnowledgePlan: () => activateOkfKnowledgePlan,
   assertOkfKnowledgePlanContract: () => assertOkfKnowledgePlanContract,
-  activateOkfKnowledgePlan: () => activateOkfKnowledgePlan
+  createLexicalKnowledgeDocumentFromEvosCase: () => createLexicalKnowledgeDocumentFromEvosCase,
+  createLexicalKnowledgeDocumentFromOkfConcept: () => createLexicalKnowledgeDocumentFromOkfConcept,
+  createOkfKnowledgePlanFromDistillationBatch: () => createOkfKnowledgePlanFromDistillationBatch,
+  createScopedKnowledgeContextPack: () => createScopedKnowledgeContextPack,
+  decideOkfKnowledgeCandidate: () => decideOkfKnowledgeCandidate,
+  discardFailedOkfKnowledgePlan: () => discardFailedOkfKnowledgePlan,
+  ensureOkfKnowledgeBase: () => ensureOkfKnowledgeBase,
+  finalizeCuratedKnowledgePlan: () => finalizeCuratedKnowledgePlan,
+  findCandidateConflictOrDuplicate: () => findCandidateConflictOrDuplicate,
+  formatOkfKnowledgeLint: () => formatOkfKnowledgeLint,
+  formatOkfKnowledgeList: () => formatOkfKnowledgeList,
+  formatOkfKnowledgePlan: () => formatOkfKnowledgePlan,
+  formatOkfKnowledgeQuery: () => formatOkfKnowledgeQuery,
+  formatScopedKnowledgePromptBlock: () => formatScopedKnowledgePromptBlock,
+  hasContextInjectionReceipt: () => hasContextInjectionReceipt,
+  lintOkfKnowledge: () => lintOkfKnowledge,
+  listOkfKnowledgeConcepts: () => listOkfKnowledgeConcepts,
+  loadActiveOkfKnowledgeIndex: () => loadActiveOkfKnowledgeIndex,
+  markOkfKnowledgeConceptStale: () => markOkfKnowledgeConceptStale,
+  mergeAcceptedEvosCasesIntoKnowledgeQuery: () => mergeAcceptedEvosCasesIntoKnowledgeQuery,
+  parseKnowledgeDistillationOutput: () => parseKnowledgeDistillationOutput,
+  previewLegacyGeneratedKnowledgeCleanup: () => previewLegacyGeneratedKnowledgeCleanup,
+  quarantineLegacyGeneratedKnowledge: () => quarantineLegacyGeneratedKnowledge,
+  queryOkfKnowledge: () => queryOkfKnowledge,
+  queryScopedOkfKnowledgeContext: () => queryScopedOkfKnowledgeContext,
+  rankKnowledgeContextItems: () => rankKnowledgeContextItems,
+  readFailedOkfKnowledgePlan: () => readFailedOkfKnowledgePlan,
+  readFailedOkfKnowledgePlanArtifact: () => readFailedOkfKnowledgePlanArtifact,
+  readOkfKnowledgeConcept: () => readOkfKnowledgeConcept,
+  rebuildOkfKnowledgeIndexes: () => rebuildOkfKnowledgeIndexes,
+  resolveContextInjectionReceiptPath: () => resolveContextInjectionReceiptPath,
+  resolveOkfKnowledgePaths: () => resolveOkfKnowledgePaths,
+  resumeFailedOkfKnowledgePlan: () => resumeFailedOkfKnowledgePlan,
+  revokeOkfKnowledgeConcept: () => revokeOkfKnowledgeConcept,
+  scoreLexicalKnowledgeDocument: () => scoreLexicalKnowledgeDocument,
+  scoreOkfKnowledgeCandidate: () => scoreOkfKnowledgeCandidate,
+  supersedeOkfKnowledgeConcept: () => supersedeOkfKnowledgeConcept,
+  validateOkfKnowledgePlanContract: () => validateOkfKnowledgePlanContract,
+  writeContextInjectionReceipt: () => writeContextInjectionReceipt,
+  writeFailedOkfKnowledgePlanArtifact: () => writeFailedOkfKnowledgePlanArtifact
 });
 import { createHash as createHash5 } from "node:crypto";
 import { existsSync, readFileSync as readFileSync2, readdirSync } from "node:fs";
@@ -120,35 +120,35 @@ import { readFile as readFile8 } from "node:fs/promises";
 // packages/core/src/evolution/evidence/session-memory/index.ts
 var exports_session_memory = {};
 __export(exports_session_memory, {
-  writeSessionIndex: () => writeSessionIndex,
-  writeSessionEvidenceSegmentAtomic: () => writeSessionEvidenceSegmentAtomic,
-  writeJson: () => writeJson,
-  writeHistoricalSessionStateAndIndex: () => writeHistoricalSessionStateAndIndex,
-  writeHistoricalSessionEvidenceSegment: () => writeHistoricalSessionEvidenceSegment,
-  updateSessionMemoryFromHook: () => updateSessionMemoryFromHook,
-  updateSessionEvidenceSegmentLifecycle: () => updateSessionEvidenceSegmentLifecycle,
-  resolveSessionMemoryPaths: () => resolveSessionMemoryPaths,
-  redactSessionMemoryCredentials: () => redactSessionMemoryCredentials,
-  redactSessionMemoryCredentialText: () => redactSessionMemoryCredentialText,
-  readSessionState: () => readSessionState,
-  readSessionEvidenceSegment: () => readSessionEvidenceSegment,
-  readSessionCursor: () => readSessionCursor,
-  readLineRange: () => readLineRange,
-  purgeExpiredHistoricalSessionEvidence: () => purgeExpiredHistoricalSessionEvidence,
-  parseSessionMemoryPolicy: () => parseSessionMemoryPolicy,
-  mergeSessionMemorySensitivity: () => mergeSessionMemorySensitivity,
-  listSessionMemoryStates: () => listSessionMemoryStates,
-  listSessionEvidenceSegments: () => listSessionEvidenceSegments,
-  inspectHistoricalSessionEvidenceRetention: () => inspectHistoricalSessionEvidenceRetention,
-  detectSessionMemorySensitivity: () => detectSessionMemorySensitivity,
-  createSemanticPacketMessageKey: () => createSemanticPacketMessageKey,
-  createHistoricalSemanticEvidencePacket: () => createHistoricalSemanticEvidencePacket,
-  createDefaultSessionMemoryPolicy: () => createDefaultSessionMemoryPolicy,
-  classifySessionEvidenceSegment: () => classifySessionEvidenceSegment,
-  appendRawEvent: () => appendRawEvent,
-  analyzeSessionEvidenceSegment: () => analyzeSessionEvidenceSegment,
+  SESSION_MEMORY_CREDENTIAL_REDACTION: () => SESSION_MEMORY_CREDENTIAL_REDACTION,
   SessionMemoryEvidenceError: () => SessionMemoryEvidenceError,
-  SESSION_MEMORY_CREDENTIAL_REDACTION: () => SESSION_MEMORY_CREDENTIAL_REDACTION
+  analyzeSessionEvidenceSegment: () => analyzeSessionEvidenceSegment,
+  appendRawEvent: () => appendRawEvent,
+  classifySessionEvidenceSegment: () => classifySessionEvidenceSegment,
+  createDefaultSessionMemoryPolicy: () => createDefaultSessionMemoryPolicy,
+  createHistoricalSemanticEvidencePacket: () => createHistoricalSemanticEvidencePacket,
+  createSemanticPacketMessageKey: () => createSemanticPacketMessageKey,
+  detectSessionMemorySensitivity: () => detectSessionMemorySensitivity,
+  inspectHistoricalSessionEvidenceRetention: () => inspectHistoricalSessionEvidenceRetention,
+  listSessionEvidenceSegments: () => listSessionEvidenceSegments,
+  listSessionMemoryStates: () => listSessionMemoryStates,
+  mergeSessionMemorySensitivity: () => mergeSessionMemorySensitivity,
+  parseSessionMemoryPolicy: () => parseSessionMemoryPolicy,
+  purgeExpiredHistoricalSessionEvidence: () => purgeExpiredHistoricalSessionEvidence,
+  readLineRange: () => readLineRange,
+  readSessionCursor: () => readSessionCursor,
+  readSessionEvidenceSegment: () => readSessionEvidenceSegment,
+  readSessionState: () => readSessionState,
+  redactSessionMemoryCredentialText: () => redactSessionMemoryCredentialText,
+  redactSessionMemoryCredentials: () => redactSessionMemoryCredentials,
+  resolveSessionMemoryPaths: () => resolveSessionMemoryPaths,
+  updateSessionEvidenceSegmentLifecycle: () => updateSessionEvidenceSegmentLifecycle,
+  updateSessionMemoryFromHook: () => updateSessionMemoryFromHook,
+  writeHistoricalSessionEvidenceSegment: () => writeHistoricalSessionEvidenceSegment,
+  writeHistoricalSessionStateAndIndex: () => writeHistoricalSessionStateAndIndex,
+  writeJson: () => writeJson,
+  writeSessionEvidenceSegmentAtomic: () => writeSessionEvidenceSegmentAtomic,
+  writeSessionIndex: () => writeSessionIndex
 });
 
 // packages/core/src/utils/errors.ts
@@ -1939,18 +1939,18 @@ function createSemanticPacketMessageKey(value) {
 // packages/core/src/evolution/candidates/index.ts
 var exports_candidates = {};
 __export(exports_candidates, {
-  withEvolutionReviewDecisionLock: () => withEvolutionReviewDecisionLock,
-  updateEvolutionRepoProposalReviewState: () => updateEvolutionRepoProposalReviewState,
-  updateEvolutionRepoProposalImprovementEval: () => updateEvolutionRepoProposalImprovementEval,
-  updateEvolutionKnowledgeReviewState: () => updateEvolutionKnowledgeReviewState,
-  supersedeEvolutionRepoProposal: () => supersedeEvolutionRepoProposal,
-  readEvolutionReviewSnapshot: () => readEvolutionReviewSnapshot,
-  readEvolutionRepoProposalById: () => readEvolutionRepoProposalById,
-  readEvolutionKnowledgeRecordById: () => readEvolutionKnowledgeRecordById,
-  markEvolutionRepoProposalApplied: () => markEvolutionRepoProposalApplied,
-  listEvolutionKnowledgeReviewHistory: () => listEvolutionKnowledgeReviewHistory,
+  listEvolutionEvosCases: () => listEvolutionEvosCases,
   listEvolutionKnowledgeRecords: () => listEvolutionKnowledgeRecords,
-  listEvolutionEvosCases: () => listEvolutionEvosCases
+  listEvolutionKnowledgeReviewHistory: () => listEvolutionKnowledgeReviewHistory,
+  markEvolutionRepoProposalApplied: () => markEvolutionRepoProposalApplied,
+  readEvolutionKnowledgeRecordById: () => readEvolutionKnowledgeRecordById,
+  readEvolutionRepoProposalById: () => readEvolutionRepoProposalById,
+  readEvolutionReviewSnapshot: () => readEvolutionReviewSnapshot,
+  supersedeEvolutionRepoProposal: () => supersedeEvolutionRepoProposal,
+  updateEvolutionKnowledgeReviewState: () => updateEvolutionKnowledgeReviewState,
+  updateEvolutionRepoProposalImprovementEval: () => updateEvolutionRepoProposalImprovementEval,
+  updateEvolutionRepoProposalReviewState: () => updateEvolutionRepoProposalReviewState,
+  withEvolutionReviewDecisionLock: () => withEvolutionReviewDecisionLock
 });
 import { createHash as createHash2 } from "node:crypto";
 import { mkdir as mkdir2, readFile as readFile2, readdir as readdir3, rm, writeFile as writeFile2 } from "node:fs/promises";
@@ -2489,15 +2489,15 @@ function isRecord2(value) {
 // packages/core/src/evolution/triggers/index.ts
 var exports_triggers = {};
 __export(exports_triggers, {
-  updateTriggers: () => updateTriggers,
-  updateSegmentTriggers: () => updateSegmentTriggers,
-  resolveSegmentEvolutionTriggerPath: () => resolveSegmentEvolutionTriggerPath,
-  resolveEvolutionTriggerDecision: () => resolveEvolutionTriggerDecision,
-  listSegmentEvolutionTriggers: () => listSegmentEvolutionTriggers,
-  listEvolutionTriggers: () => listEvolutionTriggers,
-  groupTriggersByRun: () => groupTriggersByRun,
+  enqueueEvolutionTrigger: () => enqueueEvolutionTrigger,
   enqueueSegmentEvolutionTrigger: () => enqueueSegmentEvolutionTrigger,
-  enqueueEvolutionTrigger: () => enqueueEvolutionTrigger
+  groupTriggersByRun: () => groupTriggersByRun,
+  listEvolutionTriggers: () => listEvolutionTriggers,
+  listSegmentEvolutionTriggers: () => listSegmentEvolutionTriggers,
+  resolveEvolutionTriggerDecision: () => resolveEvolutionTriggerDecision,
+  resolveSegmentEvolutionTriggerPath: () => resolveSegmentEvolutionTriggerPath,
+  updateSegmentTriggers: () => updateSegmentTriggers,
+  updateTriggers: () => updateTriggers
 });
 import { readFile as readFile3 } from "node:fs/promises";
 import { join as join5 } from "node:path";
@@ -3425,20 +3425,20 @@ import { basename as basename2, dirname as dirname5, isAbsolute as isAbsolute3,
 // packages/core/src/runtime-logs/index.ts
 var exports_runtime_logs = {};
 __export(exports_runtime_logs, {
-  resolveTraceTeamContext: () => resolveTraceTeamContext,
-  resolveTraceSessionKey: () => resolveTraceSessionKey,
-  resolveProjectLogKey: () => resolveProjectLogKey,
-  resolveProjectLogIdentity: () => resolveProjectLogIdentity,
-  resolvePathProjectLogKey: () => resolvePathProjectLogKey,
-  resolveEvoDevLogPaths: () => resolveEvoDevLogPaths,
-  createTraceLogEntry: () => createTraceLogEntry,
-  createEvoDevExecutionEvent: () => createEvoDevExecutionEvent,
-  createDebugLogEntry: () => createDebugLogEntry,
-  createCliLogEntry: () => createCliLogEntry,
-  appendTraceLogEntry: () => appendTraceLogEntry,
-  appendEvoDevExecutionEvent: () => appendEvoDevExecutionEvent,
+  appendCliLogEntry: () => appendCliLogEntry,
   appendDebugLogEntry: () => appendDebugLogEntry,
-  appendCliLogEntry: () => appendCliLogEntry
+  appendEvoDevExecutionEvent: () => appendEvoDevExecutionEvent,
+  appendTraceLogEntry: () => appendTraceLogEntry,
+  createCliLogEntry: () => createCliLogEntry,
+  createDebugLogEntry: () => createDebugLogEntry,
+  createEvoDevExecutionEvent: () => createEvoDevExecutionEvent,
+  createTraceLogEntry: () => createTraceLogEntry,
+  resolveEvoDevLogPaths: () => resolveEvoDevLogPaths,
+  resolvePathProjectLogKey: () => resolvePathProjectLogKey,
+  resolveProjectLogIdentity: () => resolveProjectLogIdentity,
+  resolveProjectLogKey: () => resolveProjectLogKey,
+  resolveTraceSessionKey: () => resolveTraceSessionKey,
+  resolveTraceTeamContext: () => resolveTraceTeamContext
 });
 import { lstatSync, readFileSync, realpathSync } from "node:fs";
 import { appendFile as appendFile2, mkdir as mkdir4 } from "node:fs/promises";
@@ -13894,13 +13894,13 @@ function isNodeError(error) {
 // packages/core/src/code-agent-traces/index.ts
 var exports_code_agent_traces = {};
 __export(exports_code_agent_traces, {
-  writeCodeAgentTraceRef: () => writeCodeAgentTraceRef,
-  resolveCodeAgentTraceRefPaths: () => resolveCodeAgentTraceRefPaths,
-  recordCodeAgentTraceRefFromHook: () => recordCodeAgentTraceRefFromHook,
-  readCodeAgentTraceRef: () => readCodeAgentTraceRef,
-  parseCodeAgentTraceRef: () => parseCodeAgentTraceRef,
+  createCodeAgentTraceRef: () => createCodeAgentTraceRef,
   listCodeAgentTraceRefs: () => listCodeAgentTraceRefs,
-  createCodeAgentTraceRef: () => createCodeAgentTraceRef
+  parseCodeAgentTraceRef: () => parseCodeAgentTraceRef,
+  readCodeAgentTraceRef: () => readCodeAgentTraceRef,
+  recordCodeAgentTraceRefFromHook: () => recordCodeAgentTraceRefFromHook,
+  resolveCodeAgentTraceRefPaths: () => resolveCodeAgentTraceRefPaths,
+  writeCodeAgentTraceRef: () => writeCodeAgentTraceRef
 });
 import { mkdir as mkdir9, readFile as readFile13, readdir as readdir10, stat as stat7, writeFile as writeFile8 } from "node:fs/promises";
 import { dirname as dirname10, isAbsolute as isAbsolute6, join as join15, normalize, relative as relative6 } from "node:path";
@@ -14615,12 +14615,12 @@ import { dirname as dirname14, join as join20 } from "node:path";
 // packages/core/src/evolution/control/index.ts
 var exports_control = {};
 __export(exports_control, {
-  readEvolutionReviewSnapshot: () => readEvolutionReviewSnapshot,
-  processEvolutionTriggers: () => processEvolutionTriggers,
-  listSegmentEvolutionTriggers: () => listSegmentEvolutionTriggers,
-  listEvolutionTriggers: () => listEvolutionTriggers,
+  formatEvolutionProcessResult: () => formatEvolutionProcessResult,
   formatEvolutionReviewSnapshot: () => formatEvolutionReviewSnapshot,
-  formatEvolutionProcessResult: () => formatEvolutionProcessResult
+  listEvolutionTriggers: () => listEvolutionTriggers,
+  listSegmentEvolutionTriggers: () => listSegmentEvolutionTriggers,
+  processEvolutionTriggers: () => processEvolutionTriggers,
+  readEvolutionReviewSnapshot: () => readEvolutionReviewSnapshot
 });
 
 // packages/core/src/evolution/formatters.ts
@@ -14751,13 +14751,13 @@ function formatEvolutionReviewSnapshot(snapshot) {
 // packages/core/src/evolution/processor/index.ts
 var exports_processor = {};
 __export(exports_processor, {
-  writeEvolutionRepoProposal: () => writeEvolutionRepoProposal,
-  writeEvolutionDistillationBatch: () => writeEvolutionDistillationBatch,
-  processEvolutionTriggers: () => processEvolutionTriggers,
-  createEvolutionDistillationBatch: () => createEvolutionDistillationBatch,
-  analyzeEvolutionRun: () => analyzeEvolutionRun,
+  activateCuratedSessionKnowledgePlan: () => activateCuratedSessionKnowledgePlan,
   activateEvolutionDistillationBatch: () => activateEvolutionDistillationBatch,
-  activateCuratedSessionKnowledgePlan: () => activateCuratedSessionKnowledgePlan
+  analyzeEvolutionRun: () => analyzeEvolutionRun,
+  createEvolutionDistillationBatch: () => createEvolutionDistillationBatch,
+  processEvolutionTriggers: () => processEvolutionTriggers,
+  writeEvolutionDistillationBatch: () => writeEvolutionDistillationBatch,
+  writeEvolutionRepoProposal: () => writeEvolutionRepoProposal
 });
 
 // packages/core/src/evolution/evidence/analysis.ts
@@ -15520,6 +15520,8 @@ var PROCESS_LOCK_STALE_MS2 = 5 * 60 * 1000;
 var PROCESS_LOCK_HEARTBEAT_MS = 30 * 1000;
 var PROCESSING_TRIGGER_STALE_MS = PROCESS_LOCK_STALE_MS2;
 var MAX_TRANSIENT_TRIGGER_ATTEMPTS = 3;
+var LOCAL_SEGMENT_SCAN_MULTIPLIER = 20;
+var MAX_LOCAL_SEGMENT_SCAN_LIMIT = 500;
 async function processEvolutionTriggers(input) {
   const now = normalizeTimestamp(input.now);
   const limit = input.limit ?? 20;
@@ -15547,13 +15549,23 @@ async function processEvolutionTriggers(input) {
     if (!dryRun) {
       await reconcileRetryableEvolutionTriggers(input, now);
     }
-    const pendingSegments = dryRun || input.distillSessionKnowledge !== undefined ? (await listSegmentEvolutionTriggers({
+    const listedPendingSegments = dryRun || input.distillSessionKnowledge !== undefined ? await listSegmentEvolutionTriggers({
       homeDir: input.homeDir,
       projectKey: input.projectKey,
       runId: input.runId,
       status: "pending"
-    })).slice(0, limit) : [];
-    const remainingLimit = Math.max(0, limit - pendingSegments.length);
+    }) : [];
+    const segmentSelection = dryRun ? {
+      triggers: listedPendingSegments.slice(0, limit),
+      semanticCandidates: Math.min(listedPendingSegments.length, limit)
+    } : await selectPendingSegmentTriggers({
+      homeDir: input.homeDir,
+      triggers: listedPendingSegments,
+      now,
+      semanticLimit: limit
+    });
+    const pendingSegments = segmentSelection.triggers;
+    const remainingLimit = Math.max(0, limit - segmentSelection.semanticCandidates);
     const pending = remainingLimit === 0 ? [] : (await listEvolutionTriggers({
       homeDir: input.homeDir,
       projectKey: input.projectKey,
@@ -15805,6 +15817,39 @@ async function processEvolutionTriggers(input) {
       await releaseEvolutionProcessLock(lock);
   }
 }
+async function selectPendingSegmentTriggers(input) {
+  const scanLimit = Math.max(input.semanticLimit, Math.min(input.semanticLimit * LOCAL_SEGMENT_SCAN_MULTIPLIER, MAX_LOCAL_SEGMENT_SCAN_LIMIT));
+  const selected = [];
+  let semanticCandidates = 0;
+  for (const trigger of input.triggers.slice(0, scanLimit)) {
+    let requiresSemanticDistillation = true;
+    try {
+      const segment = await readSessionEvidenceSegment({
+        homeDir: input.homeDir,
+        projectKey: trigger.projectKey,
+        sessionKey: trigger.sessionKey,
+        segmentId: trigger.segmentId
+      });
+      const existingBatchId = segment.lifecycle.consumedByBatchIds.at(-1);
+      if (segment.lifecycle.status === "distilled" && existingBatchId !== undefined) {
+        requiresSemanticDistillation = false;
+      } else {
+        const analysis2 = analyzeSessionEvidenceSegment({
+          homeDir: input.homeDir,
+          segment,
+          now: input.now
+        });
+        requiresSemanticDistillation = analysis2.evidenceWindow?.triggerPolicy.distillRecommended === true;
+      }
+    } catch {}
+    if (requiresSemanticDistillation && semanticCandidates >= input.semanticLimit)
+      break;
+    selected.push(trigger);
+    if (requiresSemanticDistillation)
+      semanticCandidates += 1;
+  }
+  return { triggers: selected, semanticCandidates };
+}
 async function reportProgress(input, result, phase) {
   if (input.onProgress === undefined)
     return;
@@ -18944,9 +18989,9 @@ function validateApplyInput(input) {
 // packages/core/src/evolution/evidence/index.ts
 var exports_evidence = {};
 __export(exports_evidence, {
-  traceRefs: () => exports_code_agent_traces,
+  runtimeLogs: () => exports_runtime_logs,
   sessionMemory: () => exports_session_memory,
-  runtimeLogs: () => exports_runtime_logs
+  traceRefs: () => exports_code_agent_traces
 });
 // packages/core/src/evolution/knowledge/review.ts
 async function previewOkfKnowledgeChangeDecision(input) {
@@ -19257,25 +19302,25 @@ function isBaseRevisionConflict(error) {
 // packages/core/src/evolution/review/index.ts
 var exports_review = {};
 __export(exports_review, {
-  validateLearningReviewDecisionRecord: () => validateLearningReviewDecisionRecord,
-  validateLearningCandidate: () => validateLearningCandidate,
-  resolveLearningDecisionPath: () => resolveLearningDecisionPath,
-  resolveLearningCandidateQueuePath: () => resolveLearningCandidateQueuePath,
-  readLearningReviewDecisions: () => readLearningReviewDecisions,
-  readLearningCandidates: () => readLearningCandidates,
-  pathExists: () => pathExists8,
-  parseLearningReviewDecisionRecord: () => parseLearningReviewDecisionRecord,
-  parseLearningCandidate: () => parseLearningCandidate,
-  listLearningReviewDecisions: () => listLearningReviewDecisions,
-  listLearningCandidates: () => listLearningCandidates,
-  lintLearningCandidates: () => lintLearningCandidates,
-  formatLearningReview: () => formatLearningReview,
-  formatLearningLint: () => formatLearningLint,
-  createLearningReviewDecisionRecord: () => createLearningReviewDecisionRecord,
-  createLearningCandidate: () => createLearningCandidate,
-  buildLearningReviewEntries: () => buildLearningReviewEntries,
+  appendLearningCandidate: () => appendLearningCandidate,
   appendLearningReviewDecision: () => appendLearningReviewDecision,
-  appendLearningCandidate: () => appendLearningCandidate
+  buildLearningReviewEntries: () => buildLearningReviewEntries,
+  createLearningCandidate: () => createLearningCandidate,
+  createLearningReviewDecisionRecord: () => createLearningReviewDecisionRecord,
+  formatLearningLint: () => formatLearningLint,
+  formatLearningReview: () => formatLearningReview,
+  lintLearningCandidates: () => lintLearningCandidates,
+  listLearningCandidates: () => listLearningCandidates,
+  listLearningReviewDecisions: () => listLearningReviewDecisions,
+  parseLearningCandidate: () => parseLearningCandidate,
+  parseLearningReviewDecisionRecord: () => parseLearningReviewDecisionRecord,
+  pathExists: () => pathExists8,
+  readLearningCandidates: () => readLearningCandidates,
+  readLearningReviewDecisions: () => readLearningReviewDecisions,
+  resolveLearningCandidateQueuePath: () => resolveLearningCandidateQueuePath,
+  resolveLearningDecisionPath: () => resolveLearningDecisionPath,
+  validateLearningCandidate: () => validateLearningCandidate,
+  validateLearningReviewDecisionRecord: () => validateLearningReviewDecisionRecord
 });
 import { mkdir as mkdir15, readFile as readFile20, stat as stat11, writeFile as writeFile12 } from "node:fs/promises";
 import { dirname as dirname16, join as join23 } from "node:path";
@@ -21268,364 +21313,364 @@ function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 export {
-  writeTrajectoryImportMaterializationProgress,
-  writeTrajectoryImportManifest,
-  writeSessionIndex,
-  writeSessionEvidenceSegmentAtomic,
-  writeOkfKnowledgeChangeCandidate,
-  writeJson,
-  writeImmutableTrajectoryImportReceipt,
-  writeImmutableTrajectoryImportIndex,
-  writeHistoricalSessionStateAndIndex,
-  writeHistoricalSessionEvidenceSegment,
-  writeFailedOkfKnowledgePlanArtifact,
-  writeEvolutionRepoProposal,
-  writeEvolutionDistillationBatch,
-  writeDaemonState,
-  writeContextInjectionReceipt,
-  writeCodexCapabilityVerificationArtifact,
-  writeCodeAgentTraceRef,
-  withTrajectoryImportSourceLock,
-  withOkfKnowledgeChangeLock,
-  withEvolutionReviewDecisionLock,
-  validatePack,
-  validateOkfKnowledgePlanContract,
-  validateObservabilityEvent,
-  validateLearningReviewDecisionRecord,
-  validateLearningCandidate,
-  validateEvolutionRepoProposal,
-  validateEvolutionKnowledgeRecord,
-  validateEvolutionEvidenceWindow,
-  validateEvolutionDistillationBatch,
-  validateDaemonBindHost,
-  validateCodexCapabilityVerificationArtifact,
-  validateAgentOutput,
-  updateTriggers,
-  updateTeamAgentHookState,
-  updateSessionMemoryFromHook,
-  updateSessionEvidenceSegmentLifecycle,
-  updateSegmentTriggers,
-  updateEvolutionRepoProposalReviewState,
-  updateEvolutionRepoProposalImprovementEval,
-  updateEvolutionKnowledgeReviewState,
-  unsetTeamRoleBinding,
-  supersedeOkfKnowledgeConcept,
-  supersedeEvolutionRepoProposal,
-  stopTeamRun,
-  stopTeamRole,
-  startTeamRun,
-  stageTrajectoryImportWithLock,
-  stageTrajectoryImport,
-  stableTrajectoryImportJson,
-  spawnTeamRole,
-  setTeamRoleBinding,
-  sendTeamMessage,
-  scoreOkfKnowledgeCandidate,
-  scoreLexicalKnowledgeDocument,
-  schedulePendingTeamMessageDelivery,
-  scanWorkflowManifests,
-  scanSkillAssets,
-  scanAssets,
-  scanAgentAssets,
-  sanitizeProposedChange,
-  runTeamsMcpStdioServer,
-  runSync,
-  runPluginConformance,
-  runDaemonForeground,
-  revokeOkfKnowledgeConcept,
-  resumeTeamRun,
-  resumeFailedOkfKnowledgePlan,
-  resolveTrajectoryImportSourcePaths,
-  resolveTrajectoryImportPaths,
-  resolveTraceTeamContext,
-  resolveTraceSessionKey,
-  resolveTeamRunPaths,
-  resolveTeamRole,
-  resolveTeamOverlay,
-  resolveTeamAgentReference,
-  resolveSessionMemoryPaths,
-  resolveSegmentEvolutionTriggerPath,
-  resolveProjectWorkspaceFromCwd,
-  resolveProjectRegistryPaths,
-  resolveProjectLogKey,
-  resolveProjectLogIdentity,
-  resolvePathProjectLogKey,
-  resolveOkfKnowledgePaths,
-  resolveObservabilityStorePaths,
-  resolveLearningDecisionPath,
-  resolveLearningCandidateQueuePath,
-  resolveHookRuntimeSessionPaths,
-  resolveEvolutionTriggerDecision,
-  resolveEvolutionPaths,
-  resolveEvoDevPaths,
-  resolveEvoDevLogPaths,
-  resolveDaemonPaths,
-  resolveContextInjectionReceiptPath,
-  resolveCodexCapabilityArtifactPath,
-  resolveCodeAgentTraceRefPaths,
-  replaceOkfKnowledgeChangeCandidate,
-  renderRoleAgentDefinitionContext,
-  renderMainTeamOverlayContext,
-  releaseTrajectoryImportSourceLock,
-  registerDiscoveredProject,
-  redactSessionMemoryCredentials,
-  redactSessionMemoryCredentialText,
-  recordTeamAgentNativeSession,
-  recordDiscoveredProject,
-  recordCodeAgentTraceRefFromHook,
-  reconcileTeamRun,
-  rebuildOkfKnowledgeIndexes,
-  readTrajectoryImportSnapshot,
-  readTrajectoryImportReceipt,
-  readTrajectoryImportPreviousSnapshot,
-  readTrajectoryImportMaterializationProgress,
-  readTrajectoryImportManifestAtPath,
-  readTrajectoryImportManifest,
-  readTrajectoryImportIndex,
-  readTeamAgentSummary,
-  readTeamAgentDefinition,
-  readSessionState,
-  readSessionEvidenceSegment,
-  readSessionCursor,
-  readRuntimeInjectionSettings,
-  readPendingTeamMessagesForRole,
-  readOkfKnowledgeConcept,
-  readOkfKnowledgeChangeCandidate,
-  readLineRange,
-  readLearningReviewDecisions,
-  readLearningCandidates,
-  readFailedOkfKnowledgePlanArtifact,
-  readFailedOkfKnowledgePlan,
-  readEvolutionReviewSnapshot,
-  readEvolutionRepoProposalById,
-  readEvolutionKnowledgeRecordById,
-  readDaemonToken,
-  readDaemonLock,
-  readCodexCapabilityVerificationArtifact,
-  readCodeAgentTraceRef,
-  readAgentProfile,
-  rankKnowledgeContextItems,
-  queryScopedOkfKnowledgeContext,
-  queryOkfKnowledge,
-  quarantineLegacyGeneratedKnowledge,
-  purgeExpiredHistoricalSessionEvidence,
-  processEvolutionTriggers,
-  previewOkfKnowledgeChangeDecision,
-  previewLegacyGeneratedKnowledgeCleanup,
-  planWorkflow,
-  planPackInstallDryRun,
-  pathExists8 as pathExists,
-  parseWorkflowManifest,
-  parseTeamRoleDefinition,
-  parseTeamDefinitionMarkdown,
-  parseSyncState,
-  parseSkillManifest,
-  parseSettings,
-  parseSessionMemoryPolicy,
-  parseRegistry,
-  parsePackManifest,
-  parseOkfKnowledgeChangeCandidate,
-  parseLearningReviewDecisionRecord,
-  parseLearningCandidate,
-  parseKnowledgeDistillationOutput,
-  parseInstallState,
-  parseHookSettings,
-  parseCodeAgentTraceRef,
-  parseAgentProfile,
-  parseAgentManifest,
-  normalizePackagePath,
-  normalizePackPermissions,
-  normalizeHookEvent,
-  negotiatePluginCapabilities,
-  mergeSettings,
-  mergeSessionMemorySensitivity,
-  mergeReviewFindings,
-  mergeAcceptedEvosCasesIntoKnowledgeQuery,
-  markTeamMessagesDelivered,
-  markOkfKnowledgeConceptStale,
-  markEvolutionRepoProposalApplied,
-  loadAgentContextDryRun,
-  loadAgentContext,
-  loadActiveOkfKnowledgeIndex,
-  listTeamRuns,
-  listTeamRoleBindings,
-  listTeamAgents,
-  listSessionMemoryStates,
-  listSessionEvidenceSegments,
-  listSegmentEvolutionTriggers,
-  listRegisteredProjects,
-  listProjectWorkspaces,
-  listProjectAliases,
-  listOkfKnowledgeConcepts,
-  listOkfKnowledgeChangeCandidates,
-  listObservabilityEvents,
-  listLearningReviewDecisions,
-  listLearningCandidates,
-  listEvolutionTriggers,
-  listEvolutionKnowledgeReviewHistory,
-  listEvolutionKnowledgeRecords,
-  listEvolutionEvosCases,
-  listEquivalentProjectKeys,
-  listDiscoveredProjects,
-  listCodeAgentTraceRefs,
-  lintOkfKnowledge,
-  lintLearningCandidates,
-  isMidTurnTeamAgentStatus,
-  isIdleTeamAgentStatus,
-  isEvolutionImprovementEvalRecommended,
-  isCapabilityUsable,
-  isActiveTeamAgentStatus,
-  inspectHistoricalSessionEvidenceRetention,
-  initializeCoreConfig,
-  hasContextInjectionReceipt,
-  hasConcreteRepoProposalChanges,
-  handleTeamsMcpMessage,
-  handleTeamsMcpLine,
-  handleHookRuntime,
-  handleDaemonRequest,
-  groupTriggersByRun,
-  getTeamsMcpTools,
-  getTeamStatus,
-  getTeamAttachCommand,
-  getEnabledPluginIds,
-  formatWorkflowPlan,
-  formatWorkflowList,
-  formatScopedKnowledgePromptBlock,
-  formatRetentionDryRun,
-  formatPackValidation,
-  formatPackInstallDryRun,
-  formatOkfKnowledgeQuery,
-  formatOkfKnowledgePlan,
-  formatOkfKnowledgeList,
-  formatOkfKnowledgeLint,
-  formatObservabilityEvents,
-  formatLearningReview,
-  formatLearningLint,
-  formatHookRuntimeOutput,
-  formatHookInstallDryRun,
-  formatHookEventDryRun,
-  formatEvolutionWriteResult,
-  formatEvolutionReviewSnapshot,
-  formatEvolutionProcessResult,
-  formatEvolutionDistillationBatch,
-  formatEvolutionAnalyzeResult,
-  formatEvolutionActivationResult,
-  formatCodexCapabilityVerificationArtifact,
-  formatAgentLoadedContextPromptBlock,
-  formatAgentContextDryRun,
-  findCandidateConflictOrDuplicate,
-  finalizeCuratedKnowledgePlan,
-  exports_triggers as evolutionTriggers,
-  exports_review as evolutionReview,
-  exports_processor as evolutionProcessor,
-  exports_knowledge as evolutionKnowledge,
-  exports_evidence as evolutionEvidence,
-  exports_control as evolutionControl,
-  exports_candidates as evolutionCandidates,
-  ensureTrajectoryImportStageDirectories,
-  ensurePrivateTrajectoryImportDirectory,
-  ensureOkfKnowledgeBase,
-  ensureDefaultTeamOverlay,
-  enqueueSegmentEvolutionTrigger,
-  enqueueEvolutionTrigger,
-  dryRunObservabilityRetentionCleanup,
-  discardFailedOkfKnowledgePlan,
-  diffOkfKnowledgeRuntimeProjections,
-  detectSessionMemorySensitivity,
-  deriveOkfKnowledgeFreshness,
-  decideOkfKnowledgeChange,
-  decideOkfKnowledgeCandidate,
-  createUnknownNegotiatedCapabilities,
-  createTrajectoryImportStableRecordKeyHash,
-  createTrajectoryImportSnapshotId,
-  createTrajectoryImportPreviewId,
-  createTrajectoryImportPreview,
-  createTrajectoryImportMaterializationPlan,
-  createTrajectoryImportIndexDigest,
-  createTrajectoryImportContentDigest,
-  createTrajectoryImportConfigHash,
-  createTraceLogEntry,
-  createTmuxRuntimeAdapter,
-  createTeamRunStore,
-  createTeamRoleRuntimeContext,
-  createSemanticPacketMessageKey,
-  createScopedKnowledgeContextPack,
-  createPluginRegistry,
-  createOkfKnowledgeVerificationSnapshot,
-  createOkfKnowledgeRuntimeProjectionFromConcept,
-  createOkfKnowledgeRuntimeProjectionFromCandidate,
-  createOkfKnowledgeRevision,
-  createOkfKnowledgePlanFromDistillationBatch,
-  createOkfKnowledgeChangeCandidate,
-  createObservabilityEvent,
-  createLexicalKnowledgeDocumentFromOkfConcept,
-  createLexicalKnowledgeDocumentFromEvosCase,
-  createLearningReviewDecisionRecord,
-  createLearningCandidate,
-  createHistoricalSessionEvidenceSegments,
-  createHistoricalSemanticEvidencePacket,
-  createEvolutionRepoProposal,
-  createEvolutionImprovementEval,
-  createEvolutionDistillationBatch,
-  createEvoDevExecutionEvent,
-  createDefaultTeamRuntimeSettings,
-  createDefaultSyncState,
-  createDefaultSettings,
-  createDefaultSessionMemoryPolicy,
-  createDefaultRegistry,
-  createDefaultMemorySettings,
-  createDefaultInstallState,
-  createDefaultHookSettings,
-  createDefaultEvolutionSettings,
-  createDefaultAgentPermissions,
-  createDebugLogEntry,
-  createDaemonStartPlan,
-  createCoreConfigStore,
-  createCodexCapabilityVerificationArtifact,
-  createCodeAgentTraceRef,
-  createCliLogEntry,
-  cleanupDaemonState,
-  classifySessionEvidenceSegment,
-  classifyOkfKnowledgeCandidate,
-  classifyCommandRisk,
-  checkProtectedZonePaths,
-  canonicalizeProjectKey,
-  buildSyncPlans,
-  buildLearningReviewEntries,
-  assertTrajectoryImportSourceLockOwned,
-  assertOkfKnowledgePlanContract,
-  applyTrajectoryImport,
-  applyStrictestAgentPermissions,
-  appendTraceLogEntry,
-  appendRawEvent,
-  appendObservabilityEvent,
-  appendLearningReviewDecision,
-  appendLearningCandidate,
-  appendEvoDevExecutionEvent,
-  appendDebugLogEntry,
-  appendCliLogEntry,
-  analyzeSessionEvidenceSegment,
-  analyzeEvolutionRun,
-  activateOkfKnowledgePlan,
-  activateEvolutionDistillationBatch,
-  activateCuratedSessionKnowledgePlan,
-  acquireTrajectoryImportSourceLock,
-  TmuxRuntimeAdapter,
-  TeamMessageBroker,
-  TRAJECTORY_IMPORT_PREVIEW_SCHEMA_VERSION,
-  TRAJECTORY_IMPORT_MATERIALIZER_VERSION,
-  TRAJECTORY_IMPORT_DIAGNOSTIC_POLICY_VERSION,
-  TEAM_INTERNAL_WAKE_SIGNAL,
-  SessionMemoryEvidenceError,
-  SESSION_MEMORY_CREDENTIAL_REDACTION,
-  ProjectRegistrationError,
-  PluginRegistryError,
-  PluginRegistry,
-  OkfKnowledgeChangeLockError,
-  OKF_KNOWLEDGE_RENDER_CONTRACT_VERSION,
-  NodeTeamRuntimeCommandRunner,
-  EvoDevConfigError,
-  EvoDevAssetError,
+  CANONICAL_HOOK_EVENT_TYPES,
   DEFAULT_PROTECTED_ZONE_RULES,
-  CANONICAL_HOOK_EVENT_TYPES
+  EvoDevAssetError,
+  EvoDevConfigError,
+  NodeTeamRuntimeCommandRunner,
+  OKF_KNOWLEDGE_RENDER_CONTRACT_VERSION,
+  OkfKnowledgeChangeLockError,
+  PluginRegistry,
+  PluginRegistryError,
+  ProjectRegistrationError,
+  SESSION_MEMORY_CREDENTIAL_REDACTION,
+  SessionMemoryEvidenceError,
+  TEAM_INTERNAL_WAKE_SIGNAL,
+  TRAJECTORY_IMPORT_DIAGNOSTIC_POLICY_VERSION,
+  TRAJECTORY_IMPORT_MATERIALIZER_VERSION,
+  TRAJECTORY_IMPORT_PREVIEW_SCHEMA_VERSION,
+  TeamMessageBroker,
+  TmuxRuntimeAdapter,
+  acquireTrajectoryImportSourceLock,
+  activateCuratedSessionKnowledgePlan,
+  activateEvolutionDistillationBatch,
+  activateOkfKnowledgePlan,
+  analyzeEvolutionRun,
+  analyzeSessionEvidenceSegment,
+  appendCliLogEntry,
+  appendDebugLogEntry,
+  appendEvoDevExecutionEvent,
+  appendLearningCandidate,
+  appendLearningReviewDecision,
+  appendObservabilityEvent,
+  appendRawEvent,
+  appendTraceLogEntry,
+  applyStrictestAgentPermissions,
+  applyTrajectoryImport,
+  assertOkfKnowledgePlanContract,
+  assertTrajectoryImportSourceLockOwned,
+  buildLearningReviewEntries,
+  buildSyncPlans,
+  canonicalizeProjectKey,
+  checkProtectedZonePaths,
+  classifyCommandRisk,
+  classifyOkfKnowledgeCandidate,
+  classifySessionEvidenceSegment,
+  cleanupDaemonState,
+  createCliLogEntry,
+  createCodeAgentTraceRef,
+  createCodexCapabilityVerificationArtifact,
+  createCoreConfigStore,
+  createDaemonStartPlan,
+  createDebugLogEntry,
+  createDefaultAgentPermissions,
+  createDefaultEvolutionSettings,
+  createDefaultHookSettings,
+  createDefaultInstallState,
+  createDefaultMemorySettings,
+  createDefaultRegistry,
+  createDefaultSessionMemoryPolicy,
+  createDefaultSettings,
+  createDefaultSyncState,
+  createDefaultTeamRuntimeSettings,
+  createEvoDevExecutionEvent,
+  createEvolutionDistillationBatch,
+  createEvolutionImprovementEval,
+  createEvolutionRepoProposal,
+  createHistoricalSemanticEvidencePacket,
+  createHistoricalSessionEvidenceSegments,
+  createLearningCandidate,
+  createLearningReviewDecisionRecord,
+  createLexicalKnowledgeDocumentFromEvosCase,
+  createLexicalKnowledgeDocumentFromOkfConcept,
+  createObservabilityEvent,
+  createOkfKnowledgeChangeCandidate,
+  createOkfKnowledgePlanFromDistillationBatch,
+  createOkfKnowledgeRevision,
+  createOkfKnowledgeRuntimeProjectionFromCandidate,
+  createOkfKnowledgeRuntimeProjectionFromConcept,
+  createOkfKnowledgeVerificationSnapshot,
+  createPluginRegistry,
+  createScopedKnowledgeContextPack,
+  createSemanticPacketMessageKey,
+  createTeamRoleRuntimeContext,
+  createTeamRunStore,
+  createTmuxRuntimeAdapter,
+  createTraceLogEntry,
+  createTrajectoryImportConfigHash,
+  createTrajectoryImportContentDigest,
+  createTrajectoryImportIndexDigest,
+  createTrajectoryImportMaterializationPlan,
+  createTrajectoryImportPreview,
+  createTrajectoryImportPreviewId,
+  createTrajectoryImportSnapshotId,
+  createTrajectoryImportStableRecordKeyHash,
+  createUnknownNegotiatedCapabilities,
+  decideOkfKnowledgeCandidate,
+  decideOkfKnowledgeChange,
+  deriveOkfKnowledgeFreshness,
+  detectSessionMemorySensitivity,
+  diffOkfKnowledgeRuntimeProjections,
+  discardFailedOkfKnowledgePlan,
+  dryRunObservabilityRetentionCleanup,
+  enqueueEvolutionTrigger,
+  enqueueSegmentEvolutionTrigger,
+  ensureDefaultTeamOverlay,
+  ensureOkfKnowledgeBase,
+  ensurePrivateTrajectoryImportDirectory,
+  ensureTrajectoryImportStageDirectories,
+  exports_candidates as evolutionCandidates,
+  exports_control as evolutionControl,
+  exports_evidence as evolutionEvidence,
+  exports_knowledge as evolutionKnowledge,
+  exports_processor as evolutionProcessor,
+  exports_review as evolutionReview,
+  exports_triggers as evolutionTriggers,
+  finalizeCuratedKnowledgePlan,
+  findCandidateConflictOrDuplicate,
+  formatAgentContextDryRun,
+  formatAgentLoadedContextPromptBlock,
+  formatCodexCapabilityVerificationArtifact,
+  formatEvolutionActivationResult,
+  formatEvolutionAnalyzeResult,
+  formatEvolutionDistillationBatch,
+  formatEvolutionProcessResult,
+  formatEvolutionReviewSnapshot,
+  formatEvolutionWriteResult,
+  formatHookEventDryRun,
+  formatHookInstallDryRun,
+  formatHookRuntimeOutput,
+  formatLearningLint,
+  formatLearningReview,
+  formatObservabilityEvents,
+  formatOkfKnowledgeLint,
+  formatOkfKnowledgeList,
+  formatOkfKnowledgePlan,
+  formatOkfKnowledgeQuery,
+  formatPackInstallDryRun,
+  formatPackValidation,
+  formatRetentionDryRun,
+  formatScopedKnowledgePromptBlock,
+  formatWorkflowList,
+  formatWorkflowPlan,
+  getEnabledPluginIds,
+  getTeamAttachCommand,
+  getTeamStatus,
+  getTeamsMcpTools,
+  groupTriggersByRun,
+  handleDaemonRequest,
+  handleHookRuntime,
+  handleTeamsMcpLine,
+  handleTeamsMcpMessage,
+  hasConcreteRepoProposalChanges,
+  hasContextInjectionReceipt,
+  initializeCoreConfig,
+  inspectHistoricalSessionEvidenceRetention,
+  isActiveTeamAgentStatus,
+  isCapabilityUsable,
+  isEvolutionImprovementEvalRecommended,
+  isIdleTeamAgentStatus,
+  isMidTurnTeamAgentStatus,
+  lintLearningCandidates,
+  lintOkfKnowledge,
+  listCodeAgentTraceRefs,
+  listDiscoveredProjects,
+  listEquivalentProjectKeys,
+  listEvolutionEvosCases,
+  listEvolutionKnowledgeRecords,
+  listEvolutionKnowledgeReviewHistory,
+  listEvolutionTriggers,
+  listLearningCandidates,
+  listLearningReviewDecisions,
+  listObservabilityEvents,
+  listOkfKnowledgeChangeCandidates,
+  listOkfKnowledgeConcepts,
+  listProjectAliases,
+  listProjectWorkspaces,
+  listRegisteredProjects,
+  listSegmentEvolutionTriggers,
+  listSessionEvidenceSegments,
+  listSessionMemoryStates,
+  listTeamAgents,
+  listTeamRoleBindings,
+  listTeamRuns,
+  loadActiveOkfKnowledgeIndex,
+  loadAgentContext,
+  loadAgentContextDryRun,
+  markEvolutionRepoProposalApplied,
+  markOkfKnowledgeConceptStale,
+  markTeamMessagesDelivered,
+  mergeAcceptedEvosCasesIntoKnowledgeQuery,
+  mergeReviewFindings,
+  mergeSessionMemorySensitivity,
+  mergeSettings,
+  negotiatePluginCapabilities,
+  normalizeHookEvent,
+  normalizePackPermissions,
+  normalizePackagePath,
+  parseAgentManifest,
+  parseAgentProfile,
+  parseCodeAgentTraceRef,
+  parseHookSettings,
+  parseInstallState,
+  parseKnowledgeDistillationOutput,
+  parseLearningCandidate,
+  parseLearningReviewDecisionRecord,
+  parseOkfKnowledgeChangeCandidate,
+  parsePackManifest,
+  parseRegistry,
+  parseSessionMemoryPolicy,
+  parseSettings,
+  parseSkillManifest,
+  parseSyncState,
+  parseTeamDefinitionMarkdown,
+  parseTeamRoleDefinition,
+  parseWorkflowManifest,
+  pathExists8 as pathExists,
+  planPackInstallDryRun,
+  planWorkflow,
+  previewLegacyGeneratedKnowledgeCleanup,
+  previewOkfKnowledgeChangeDecision,
+  processEvolutionTriggers,
+  purgeExpiredHistoricalSessionEvidence,
+  quarantineLegacyGeneratedKnowledge,
+  queryOkfKnowledge,
+  queryScopedOkfKnowledgeContext,
+  rankKnowledgeContextItems,
+  readAgentProfile,
+  readCodeAgentTraceRef,
+  readCodexCapabilityVerificationArtifact,
+  readDaemonLock,
+  readDaemonToken,
+  readEvolutionKnowledgeRecordById,
+  readEvolutionRepoProposalById,
+  readEvolutionReviewSnapshot,
+  readFailedOkfKnowledgePlan,
+  readFailedOkfKnowledgePlanArtifact,
+  readLearningCandidates,
+  readLearningReviewDecisions,
+  readLineRange,
+  readOkfKnowledgeChangeCandidate,
+  readOkfKnowledgeConcept,
+  readPendingTeamMessagesForRole,
+  readRuntimeInjectionSettings,
+  readSessionCursor,
+  readSessionEvidenceSegment,
+  readSessionState,
+  readTeamAgentDefinition,
+  readTeamAgentSummary,
+  readTrajectoryImportIndex,
+  readTrajectoryImportManifest,
+  readTrajectoryImportManifestAtPath,
+  readTrajectoryImportMaterializationProgress,
+  readTrajectoryImportPreviousSnapshot,
+  readTrajectoryImportReceipt,
+  readTrajectoryImportSnapshot,
+  rebuildOkfKnowledgeIndexes,
+  reconcileTeamRun,
+  recordCodeAgentTraceRefFromHook,
+  recordDiscoveredProject,
+  recordTeamAgentNativeSession,
+  redactSessionMemoryCredentialText,
+  redactSessionMemoryCredentials,
+  registerDiscoveredProject,
+  releaseTrajectoryImportSourceLock,
+  renderMainTeamOverlayContext,
+  renderRoleAgentDefinitionContext,
+  replaceOkfKnowledgeChangeCandidate,
+  resolveCodeAgentTraceRefPaths,
+  resolveCodexCapabilityArtifactPath,
+  resolveContextInjectionReceiptPath,
+  resolveDaemonPaths,
+  resolveEvoDevLogPaths,
+  resolveEvoDevPaths,
+  resolveEvolutionPaths,
+  resolveEvolutionTriggerDecision,
+  resolveHookRuntimeSessionPaths,
+  resolveLearningCandidateQueuePath,
+  resolveLearningDecisionPath,
+  resolveObservabilityStorePaths,
+  resolveOkfKnowledgePaths,
+  resolvePathProjectLogKey,
+  resolveProjectLogIdentity,
+  resolveProjectLogKey,
+  resolveProjectRegistryPaths,
+  resolveProjectWorkspaceFromCwd,
+  resolveSegmentEvolutionTriggerPath,
+  resolveSessionMemoryPaths,
+  resolveTeamAgentReference,
+  resolveTeamOverlay,
+  resolveTeamRole,
+  resolveTeamRunPaths,
+  resolveTraceSessionKey,
+  resolveTraceTeamContext,
+  resolveTrajectoryImportPaths,
+  resolveTrajectoryImportSourcePaths,
+  resumeFailedOkfKnowledgePlan,
+  resumeTeamRun,
+  revokeOkfKnowledgeConcept,
+  runDaemonForeground,
+  runPluginConformance,
+  runSync,
+  runTeamsMcpStdioServer,
+  sanitizeProposedChange,
+  scanAgentAssets,
+  scanAssets,
+  scanSkillAssets,
+  scanWorkflowManifests,
+  schedulePendingTeamMessageDelivery,
+  scoreLexicalKnowledgeDocument,
+  scoreOkfKnowledgeCandidate,
+  sendTeamMessage,
+  setTeamRoleBinding,
+  spawnTeamRole,
+  stableTrajectoryImportJson,
+  stageTrajectoryImport,
+  stageTrajectoryImportWithLock,
+  startTeamRun,
+  stopTeamRole,
+  stopTeamRun,
+  supersedeEvolutionRepoProposal,
+  supersedeOkfKnowledgeConcept,
+  unsetTeamRoleBinding,
+  updateEvolutionKnowledgeReviewState,
+  updateEvolutionRepoProposalImprovementEval,
+  updateEvolutionRepoProposalReviewState,
+  updateSegmentTriggers,
+  updateSessionEvidenceSegmentLifecycle,
+  updateSessionMemoryFromHook,
+  updateTeamAgentHookState,
+  updateTriggers,
+  validateAgentOutput,
+  validateCodexCapabilityVerificationArtifact,
+  validateDaemonBindHost,
+  validateEvolutionDistillationBatch,
+  validateEvolutionEvidenceWindow,
+  validateEvolutionKnowledgeRecord,
+  validateEvolutionRepoProposal,
+  validateLearningCandidate,
+  validateLearningReviewDecisionRecord,
+  validateObservabilityEvent,
+  validateOkfKnowledgePlanContract,
+  validatePack,
+  withEvolutionReviewDecisionLock,
+  withOkfKnowledgeChangeLock,
+  withTrajectoryImportSourceLock,
+  writeCodeAgentTraceRef,
+  writeCodexCapabilityVerificationArtifact,
+  writeContextInjectionReceipt,
+  writeDaemonState,
+  writeEvolutionDistillationBatch,
+  writeEvolutionRepoProposal,
+  writeFailedOkfKnowledgePlanArtifact,
+  writeHistoricalSessionEvidenceSegment,
+  writeHistoricalSessionStateAndIndex,
+  writeImmutableTrajectoryImportIndex,
+  writeImmutableTrajectoryImportReceipt,
+  writeJson,
+  writeOkfKnowledgeChangeCandidate,
+  writeSessionEvidenceSegmentAtomic,
+  writeSessionIndex,
+  writeTrajectoryImportManifest,
+  writeTrajectoryImportMaterializationProgress
 };

package/dist/plugins/index.js

@@ -248,18 +248,18 @@ function getEnabledPluginIds(settings) {
   return Object.entries(settings.plugins).filter(([, pluginSettings]) => pluginSettings.enabled).map(([pluginId]) => pluginId).sort((left, right) => left.localeCompare(right));
 }
 export {
-  writeCodexCapabilityVerificationArtifact,
-  validateCodexCapabilityVerificationArtifact,
-  runPluginConformance,
-  resolveCodexCapabilityArtifactPath,
-  readCodexCapabilityVerificationArtifact,
-  negotiatePluginCapabilities,
-  isCapabilityUsable,
-  getEnabledPluginIds,
-  formatCodexCapabilityVerificationArtifact,
-  createUnknownNegotiatedCapabilities,
-  createPluginRegistry,
-  createCodexCapabilityVerificationArtifact,
+  PluginRegistry,
   PluginRegistryError,
-  PluginRegistry
+  createCodexCapabilityVerificationArtifact,
+  createPluginRegistry,
+  createUnknownNegotiatedCapabilities,
+  formatCodexCapabilityVerificationArtifact,
+  getEnabledPluginIds,
+  isCapabilityUsable,
+  negotiatePluginCapabilities,
+  readCodexCapabilityVerificationArtifact,
+  resolveCodexCapabilityArtifactPath,
+  runPluginConformance,
+  validateCodexCapabilityVerificationArtifact,
+  writeCodexCapabilityVerificationArtifact
 };

package/package.json

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

package/src/evolution/processor/process.ts

@@ -14,6 +14,7 @@ import type {
   EvolutionProcessProgress,
   EvolutionProcessResult,
   EvolutionTriggerStatus,
+  SegmentEvolutionTriggerRecord,
 } from "../schema.ts";
 import { sanitizeText } from "../shared.ts";
 import {
@@ -33,6 +34,8 @@ const PROCESS_LOCK_STALE_MS = 5 * 60 * 1000;
 const PROCESS_LOCK_HEARTBEAT_MS = 30 * 1000;
 const PROCESSING_TRIGGER_STALE_MS = PROCESS_LOCK_STALE_MS;
 const MAX_TRANSIENT_TRIGGER_ATTEMPTS = 3;
+const LOCAL_SEGMENT_SCAN_MULTIPLIER = 20;
+const MAX_LOCAL_SEGMENT_SCAN_LIMIT = 500;
 
 interface EvolutionProcessLock {
   path: string;
@@ -74,18 +77,28 @@ export async function processEvolutionTriggers(
     if (!dryRun) {
       await reconcileRetryableEvolutionTriggers(input, now);
     }
-    const pendingSegments =
+    const listedPendingSegments =
       dryRun || input.distillSessionKnowledge !== undefined
-        ? (
-            await listSegmentEvolutionTriggers({
-              homeDir: input.homeDir,
-              projectKey: input.projectKey,
-              runId: input.runId,
-              status: "pending",
-            })
-          ).slice(0, limit)
+        ? await listSegmentEvolutionTriggers({
+            homeDir: input.homeDir,
+            projectKey: input.projectKey,
+            runId: input.runId,
+            status: "pending",
+          })
         : [];
-    const remainingLimit = Math.max(0, limit - pendingSegments.length);
+    const segmentSelection = dryRun
+      ? {
+          triggers: listedPendingSegments.slice(0, limit),
+          semanticCandidates: Math.min(listedPendingSegments.length, limit),
+        }
+      : await selectPendingSegmentTriggers({
+          homeDir: input.homeDir,
+          triggers: listedPendingSegments,
+          now,
+          semanticLimit: limit,
+        });
+    const pendingSegments = segmentSelection.triggers;
+    const remainingLimit = Math.max(0, limit - segmentSelection.semanticCandidates);
     const pending =
       remainingLimit === 0
         ? []
@@ -350,6 +363,55 @@ export async function processEvolutionTriggers(
   }
 }
 
+async function selectPendingSegmentTriggers(input: {
+  homeDir: string;
+  triggers: SegmentEvolutionTriggerRecord[];
+  now: string;
+  semanticLimit: number;
+}): Promise<{
+  triggers: SegmentEvolutionTriggerRecord[];
+  semanticCandidates: number;
+}> {
+  const scanLimit = Math.max(
+    input.semanticLimit,
+    Math.min(input.semanticLimit * LOCAL_SEGMENT_SCAN_MULTIPLIER, MAX_LOCAL_SEGMENT_SCAN_LIMIT),
+  );
+  const selected: SegmentEvolutionTriggerRecord[] = [];
+  let semanticCandidates = 0;
+
+  for (const trigger of input.triggers.slice(0, scanLimit)) {
+    let requiresSemanticDistillation = true;
+    try {
+      const segment = await readSessionEvidenceSegment({
+        homeDir: input.homeDir,
+        projectKey: trigger.projectKey,
+        sessionKey: trigger.sessionKey,
+        segmentId: trigger.segmentId,
+      });
+      const existingBatchId = segment.lifecycle.consumedByBatchIds.at(-1);
+      if (segment.lifecycle.status === "distilled" && existingBatchId !== undefined) {
+        requiresSemanticDistillation = false;
+      } else {
+        const analysis = analyzeSessionEvidenceSegment({
+          homeDir: input.homeDir,
+          segment,
+          now: input.now,
+        });
+        requiresSemanticDistillation =
+          analysis.evidenceWindow?.triggerPolicy.distillRecommended === true;
+      }
+    } catch {
+      // Let the normal processor record the malformed or unavailable segment as a failed attempt.
+    }
+
+    if (requiresSemanticDistillation && semanticCandidates >= input.semanticLimit) break;
+    selected.push(trigger);
+    if (requiresSemanticDistillation) semanticCandidates += 1;
+  }
+
+  return { triggers: selected, semanticCandidates };
+}
+
 async function reportProgress(
   input: EvolutionProcessInput,
   result: EvolutionProcessResult,