@evo-dev/core 0.0.1-alpha.15 → 0.0.1-alpha.17

package/src/evolution/knowledge/review.ts

@@ -0,0 +1,446 @@
+import { detectSessionMemorySensitivity } from "../evidence/session-memory/sensitivity.ts";
+import {
+  type OkfKnowledgeChangeCandidateV1,
+  readOkfKnowledgeChangeCandidate,
+  replaceOkfKnowledgeChangeCandidate,
+  withOkfKnowledgeChangeLock,
+} from "./change-store.ts";
+import {
+  type OkfKnowledgeChangeState,
+  createOkfKnowledgeRevision,
+  createOkfKnowledgeRuntimeProjectionFromConcept,
+} from "./changes.ts";
+import {
+  type OkfKnowledgeActivationResult,
+  type OkfKnowledgePlan,
+  activateOkfKnowledgePlan,
+  listOkfKnowledgeConcepts,
+  readOkfKnowledgeConcept,
+  revokeOkfKnowledgeConcept,
+  supersedeOkfKnowledgeConcept,
+} from "./index.ts";
+
+export type OkfKnowledgeChangeReviewDecision = "accept" | "reject" | "defer";
+
+export interface OkfKnowledgeChangeDecisionPreview {
+  changeId: string;
+  operation: OkfKnowledgeChangeCandidateV1["operation"];
+  currentState: OkfKnowledgeChangeState;
+  decision: OkfKnowledgeChangeReviewDecision;
+  baseRevision: string | null;
+  candidateRevision: string;
+  runtimeFields: string[];
+  willMutateActiveKnowledge: boolean;
+}
+
+export interface OkfKnowledgeChangeDecisionResult extends OkfKnowledgeChangeDecisionPreview {
+  state: OkfKnowledgeChangeState;
+  activation: OkfKnowledgeActivationResult | null;
+  conceptPaths: string[];
+}
+
+export async function previewOkfKnowledgeChangeDecision(input: {
+  homeDir: string;
+  changeId: string;
+  decision: OkfKnowledgeChangeReviewDecision;
+  expectedState: OkfKnowledgeChangeState;
+  expectedBaseRevision: string | null;
+}): Promise<OkfKnowledgeChangeDecisionPreview> {
+  const { change } = await readOkfKnowledgeChangeCandidate({
+    homeDir: input.homeDir,
+    changeId: input.changeId,
+  });
+  await assertReviewPreconditions({
+    homeDir: input.homeDir,
+    change,
+    expectedState: input.expectedState,
+    expectedBaseRevision: input.expectedBaseRevision,
+  });
+  return toPreview(change, input.decision);
+}
+
+export async function decideOkfKnowledgeChange(input: {
+  homeDir: string;
+  changeId: string;
+  decision: OkfKnowledgeChangeReviewDecision;
+  expectedState: OkfKnowledgeChangeState;
+  expectedBaseRevision: string | null;
+  reason?: string | null;
+  now?: string | Date;
+}): Promise<OkfKnowledgeChangeDecisionResult> {
+  const initial = await readOkfKnowledgeChangeCandidate({
+    homeDir: input.homeDir,
+    changeId: input.changeId,
+  });
+  return await withOkfKnowledgeChangeLock({
+    homeDir: input.homeDir,
+    projectKey: initial.change.projectKey,
+    stableKey: initial.change.stableKey,
+    conceptId: initial.change.base?.conceptId ?? null,
+    run: async () => {
+      const { change } = await readOkfKnowledgeChangeCandidate({
+        homeDir: input.homeDir,
+        changeId: input.changeId,
+        projectKey: initial.change.projectKey,
+      });
+      assertReviewInputPreconditions({
+        change,
+        expectedState: input.expectedState,
+        expectedBaseRevision: input.expectedBaseRevision,
+      });
+      if (change.state === "accepted" && input.decision !== "accept") {
+        throw new Error(
+          "Knowledge change state conflict: an accepted change can only resume acceptance.",
+        );
+      }
+      if (change.state === "accepted" && input.decision === "accept") {
+        const recovered = await readAlreadyAppliedKnowledgeChange({
+          homeDir: input.homeDir,
+          change,
+        });
+        if (recovered !== null) {
+          const completed: OkfKnowledgeChangeCandidateV1 = {
+            ...change,
+            state: "applied",
+            updatedAt: resolveNow(input.now),
+          };
+          await replaceOkfKnowledgeChangeCandidate({
+            homeDir: input.homeDir,
+            previous: change,
+            next: completed,
+            reason: input.reason ?? null,
+          });
+          return {
+            ...toPreview(change, input.decision),
+            state: "applied",
+            activation: null,
+            conceptPaths: recovered.conceptPaths,
+          };
+        }
+      }
+      try {
+        await assertReviewPreconditions({
+          homeDir: input.homeDir,
+          change,
+          expectedState: input.expectedState,
+          expectedBaseRevision: input.expectedBaseRevision,
+        });
+      } catch (error) {
+        if (isBaseRevisionConflict(error) && change.state !== "superseded") {
+          const superseded = {
+            ...change,
+            state: "superseded" as const,
+            updatedAt: resolveNow(input.now),
+          };
+          await replaceOkfKnowledgeChangeCandidate({
+            homeDir: input.homeDir,
+            previous: change,
+            next: superseded,
+            reason: "Base revision changed before review.",
+          });
+        }
+        throw error;
+      }
+
+      const reason = normalizeDecisionReason(input.reason);
+      const decidedAt = resolveNow(input.now);
+      const decisionState =
+        input.decision === "accept"
+          ? ("accepted" as const)
+          : input.decision === "reject"
+            ? ("rejected" as const)
+            : ("deferred" as const);
+      const decided =
+        change.state === "accepted" && input.decision === "accept"
+          ? change
+          : {
+              ...change,
+              state: decisionState,
+              decision: {
+                state: decisionState,
+                reason,
+                decidedAt,
+              },
+              updatedAt: decidedAt,
+            };
+      if (decided !== change) {
+        await replaceOkfKnowledgeChangeCandidate({
+          homeDir: input.homeDir,
+          previous: change,
+          next: decided,
+          reason,
+        });
+      }
+      const preview = toPreview(change, input.decision);
+      if (input.decision !== "accept") {
+        return {
+          ...preview,
+          state: decided.state,
+          activation: null,
+          conceptPaths: [],
+        };
+      }
+
+      const applied = await applyAcceptedChange({
+        homeDir: input.homeDir,
+        change: decided,
+        now: decidedAt,
+        reason,
+      });
+      const current = (
+        await readOkfKnowledgeChangeCandidate({
+          homeDir: input.homeDir,
+          changeId: input.changeId,
+          projectKey: change.projectKey,
+        })
+      ).change;
+      const completed: OkfKnowledgeChangeCandidateV1 = {
+        ...current,
+        state: "applied",
+        updatedAt: resolveNow(input.now),
+      };
+      await replaceOkfKnowledgeChangeCandidate({
+        homeDir: input.homeDir,
+        previous: current,
+        next: completed,
+        reason,
+      });
+      return {
+        ...preview,
+        state: "applied",
+        activation: applied.activation,
+        conceptPaths: applied.conceptPaths,
+      };
+    },
+  });
+}
+
+async function assertReviewPreconditions(input: {
+  homeDir: string;
+  change: OkfKnowledgeChangeCandidateV1;
+  expectedState: OkfKnowledgeChangeState;
+  expectedBaseRevision: string | null;
+}): Promise<void> {
+  assertReviewInputPreconditions(input);
+  if (input.change.base === null) {
+    const concepts = await listOkfKnowledgeConcepts({ homeDir: input.homeDir });
+    if (
+      concepts.some(
+        (concept) =>
+          concept.stableKey === input.change.stableKey ||
+          concept.id === conceptIdFromTargetPath(input.change.targetPath),
+      )
+    ) {
+      throw createBaseRevisionConflict(
+        "Knowledge change base revision conflict: a concept now uses this stable key or target path.",
+      );
+    }
+    return;
+  }
+  const current = await readOkfKnowledgeConcept({
+    homeDir: input.homeDir,
+    conceptId: input.change.base.conceptId,
+  });
+  const currentRevision = createOkfKnowledgeRevision(
+    createOkfKnowledgeRuntimeProjectionFromConcept(current),
+  );
+  if (currentRevision !== input.change.base.revision) {
+    throw createBaseRevisionConflict(
+      `Knowledge change base revision conflict: expected ${input.change.base.revision}, found ${currentRevision}.`,
+    );
+  }
+}
+
+function assertReviewInputPreconditions(input: {
+  change: OkfKnowledgeChangeCandidateV1;
+  expectedState: OkfKnowledgeChangeState;
+  expectedBaseRevision: string | null;
+}): void {
+  if (input.change.state !== input.expectedState) {
+    throw new Error(
+      `Knowledge change state conflict: expected ${input.expectedState}, found ${input.change.state}.`,
+    );
+  }
+  const storedBaseRevision = input.change.base?.revision ?? null;
+  if (storedBaseRevision !== input.expectedBaseRevision) {
+    throw new Error(
+      `Knowledge change base revision input does not match candidate: expected ${storedBaseRevision ?? "none"}.`,
+    );
+  }
+}
+
+async function readAlreadyAppliedKnowledgeChange(input: {
+  homeDir: string;
+  change: OkfKnowledgeChangeCandidateV1;
+}): Promise<{ conceptPaths: string[] } | null> {
+  if (input.change.operation === "supersede") {
+    if (input.change.base === null) return null;
+    const replacement = await readConceptIfPresent(
+      input.homeDir,
+      conceptIdFromTargetPath(input.change.targetPath),
+    );
+    const previous = await readConceptIfPresent(input.homeDir, input.change.base.conceptId);
+    if (
+      replacement === null ||
+      previous === null ||
+      replacement.stableKey !== input.change.stableKey ||
+      previous.lifecycle.status !== "superseded" ||
+      previous.lifecycle.supersededBy !== replacement.id ||
+      !replacement.lifecycle.supersedes.includes(previous.id)
+    ) {
+      return null;
+    }
+    return { conceptPaths: [previous.path, replacement.path] };
+  }
+
+  const conceptId =
+    input.change.operation === "create"
+      ? conceptIdFromTargetPath(input.change.targetPath)
+      : input.change.base?.conceptId;
+  if (conceptId === undefined) return null;
+  const concept = await readConceptIfPresent(input.homeDir, conceptId);
+  if (concept === null || concept.stableKey !== input.change.stableKey) return null;
+  const revision = createOkfKnowledgeRevision(
+    createOkfKnowledgeRuntimeProjectionFromConcept(concept),
+  );
+  return revision === input.change.candidate.revision ? { conceptPaths: [concept.path] } : null;
+}
+
+async function readConceptIfPresent(
+  homeDir: string,
+  conceptId: string,
+): Promise<Awaited<ReturnType<typeof readOkfKnowledgeConcept>> | null> {
+  try {
+    return await readOkfKnowledgeConcept({ homeDir, conceptId });
+  } catch (error) {
+    if (error instanceof Error && /not found/iu.test(error.message)) return null;
+    throw error;
+  }
+}
+
+function conceptIdFromTargetPath(targetPath: string): string {
+  return targetPath.replace(/^\/+/u, "").replace(/\.md$/u, "");
+}
+
+function createBaseRevisionConflict(message: string): Error {
+  return Object.assign(new Error(message), {
+    code: "KNOWLEDGE_BASE_REVISION_CONFLICT",
+  });
+}
+
+async function applyAcceptedChange(input: {
+  homeDir: string;
+  change: OkfKnowledgeChangeCandidateV1;
+  now: string;
+  reason: string | null;
+}): Promise<{ activation: OkfKnowledgeActivationResult | null; conceptPaths: string[] }> {
+  if (input.change.operation === "revoke") {
+    if (input.change.base === null) throw new Error("Knowledge revoke requires an active base.");
+    const result = await revokeOkfKnowledgeConcept({
+      homeDir: input.homeDir,
+      conceptId: input.change.base.conceptId,
+      reason: input.reason ?? input.change.candidate.planCandidate.decisionReason.slice(0, 500),
+      now: input.now,
+    });
+    return { activation: null, conceptPaths: result.conceptPaths };
+  }
+
+  const planCandidate = {
+    ...input.change.candidate.planCandidate,
+    decision: input.change.operation === "update" ? ("update" as const) : ("create" as const),
+    reviewState: "accepted" as const,
+    targetPath:
+      input.change.operation === "update" && input.change.base !== null
+        ? input.change.base.sourceLink.replace(/^\/+/u, "")
+        : input.change.targetPath,
+  };
+  const plan: OkfKnowledgePlan = {
+    schemaVersion: 1,
+    kind: "evodev-knowledge-plan",
+    projectKey: input.change.projectKey,
+    runId: input.change.runId,
+    createdAt: input.now,
+    evidenceWindowId: input.change.provenance.evidenceWindowId,
+    summary: `Apply reviewed knowledge change ${input.change.id}.`,
+    evidenceRefs: input.change.provenance.evidenceRefs.map((id) => ({
+      id,
+      kind: "knowledge-change-evidence",
+      source: `knowledge-change:${input.change.id}`,
+      rawContentStored: false,
+      externalContentCopied: false,
+    })),
+    evoEvalSets: input.change.candidate.evalSets,
+    candidates: [planCandidate],
+    droppedSignals: [],
+    conflicts: [],
+    privacyCheck: planCandidate.privacyCheck,
+  };
+  const activation = await activateOkfKnowledgePlan({
+    homeDir: input.homeDir,
+    plan,
+    overwrite: input.change.operation === "update",
+    reviewedChangeId: input.change.id,
+  });
+  const conceptPaths = [...activation.conceptPaths];
+  if (input.change.operation === "supersede") {
+    if (input.change.base === null) throw new Error("Knowledge supersede requires an active base.");
+    const replacementId = input.change.targetPath.replace(/^\/+/u, "").replace(/\.md$/u, "");
+    const lifecycle = await supersedeOkfKnowledgeConcept({
+      homeDir: input.homeDir,
+      oldConceptId: input.change.base.conceptId,
+      newConceptId: replacementId,
+      now: input.now,
+    });
+    conceptPaths.push(...lifecycle.conceptPaths);
+  }
+  return { activation, conceptPaths: [...new Set(conceptPaths)] };
+}
+
+function toPreview(
+  change: OkfKnowledgeChangeCandidateV1,
+  decision: OkfKnowledgeChangeReviewDecision,
+): OkfKnowledgeChangeDecisionPreview {
+  return {
+    changeId: change.id,
+    operation: change.operation,
+    currentState: change.state,
+    decision,
+    baseRevision: change.base?.revision ?? null,
+    candidateRevision: change.candidate.revision,
+    runtimeFields: change.diff.runtimeFields,
+    willMutateActiveKnowledge: decision === "accept",
+  };
+}
+
+function normalizeDecisionReason(value: string | null | undefined): string | null {
+  if (value === undefined || value === null || value.trim() === "") return null;
+  const reason = [...value]
+    .filter((character) => {
+      const code = character.charCodeAt(0);
+      return code === 9 || code === 10 || code === 13 || (code >= 32 && code !== 127);
+    })
+    .join("")
+    .trim();
+  if (reason.length > 500)
+    throw new Error("Knowledge review reason must be 500 characters or less.");
+  if (detectSessionMemorySensitivity(reason).classification === "credential") {
+    throw new Error("Knowledge review reason contains a credential.");
+  }
+  return reason;
+}
+
+function resolveNow(value: string | Date | undefined): string {
+  const date =
+    value instanceof Date ? value : typeof value === "string" ? new Date(value) : new Date();
+  if (!Number.isFinite(date.getTime())) throw new Error("Invalid knowledge review timestamp.");
+  return date.toISOString();
+}
+
+function isBaseRevisionConflict(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    error.code === "KNOWLEDGE_BASE_REVISION_CONFLICT"
+  );
+}

package/src/evolution/processor/process.ts

@@ -62,6 +62,7 @@ export async function processEvolutionTriggers(
       pending: 0,
       triggerIds: [],
       batchIds: [],
+      pendingChangeIds: [],
       warnings,
       dryRun,
     };
@@ -108,6 +109,7 @@ export async function processEvolutionTriggers(
         ...pending.map((trigger) => trigger.id),
       ],
       batchIds: [],
+      pendingChangeIds: [],
       warnings,
       dryRun,
     };
@@ -215,6 +217,7 @@ export async function processEvolutionTriggers(
         });
         result.consumed += 1;
         result.batchIds.push(batch.id);
+        result.pendingChangeIds.push(...curated.activation.okf.pendingChangeIds);
         await updateSegmentTriggers(input.homeDir, [attemptedTrigger], {
           status: "consumed",
           updatedAt: now,
@@ -303,13 +306,14 @@ export async function processEvolutionTriggers(
           now,
         });
         if (lock !== null) await assertEvolutionProcessLockOwned(lock);
-        await activateEvolutionDistillationBatch({
+        const activation = await activateEvolutionDistillationBatch({
           homeDir: input.homeDir,
           batch,
           overwrite: true,
         });
         result.consumed += triggers.length;
         result.batchIds.push(batch.id);
+        result.pendingChangeIds.push(...activation.okf.pendingChangeIds);
         await updateTriggers(input.homeDir, attemptedTriggers, {
           status: "consumed",
           updatedAt: now,

package/src/evolution/schema.ts

@@ -372,6 +372,30 @@ export interface EvolutionEvosCase {
   privacy: EvolutionPrivacyFields;
 }
 
+export interface EvolutionRepoProposalCurrentState {
+  checkedAt: string;
+  headSha: string;
+  statusFingerprint: string;
+  verdict: "unresolved" | "resolved" | "unknown";
+  ownership: "governance" | "implementation" | "not-applicable";
+  explicitUserRequest: boolean;
+  checkedPaths: string[];
+  relatedCommits: string[];
+  summary: string;
+}
+
+export interface EvolutionRepoProposalRecurrence {
+  gapKey: string;
+  independentSessionCount: number;
+  sourceSessionKeys: string[];
+}
+
+export interface EvolutionRepoProposalSupersession {
+  policy: "session-proposal-v2";
+  reason: string;
+  supersededAt: string;
+}
+
 export interface EvolutionRepoProposal {
   schemaVersion: 1;
   id: string;
@@ -382,10 +406,13 @@ export interface EvolutionRepoProposal {
   rationale: string;
   roleTags: string[];
   tags: string[];
-  reviewState: "pending" | "accepted" | "rejected" | "deferred" | "applied";
+  reviewState: "pending" | "accepted" | "rejected" | "deferred" | "applied" | "superseded";
   reviewStateChangedAt?: string;
   confidence: EvolutionConfidence;
   targetRepoPath: string | null;
+  currentState?: EvolutionRepoProposalCurrentState;
+  recurrence?: EvolutionRepoProposalRecurrence;
+  supersession?: EvolutionRepoProposalSupersession;
   plannedFiles: Array<{
     relativePath: string;
     action: "create" | "update";
@@ -606,6 +633,7 @@ export interface EvolutionProcessResult {
   pending: number;
   triggerIds: string[];
   batchIds: string[];
+  pendingChangeIds: string[];
   warnings: string[];
   dryRun: boolean;
 }

package/src/evolution/shared.ts

@@ -363,6 +363,33 @@ export function createEvolutionRepoProposal(
         ? {}
         : { proposedChange: sanitizeProposedChange(file.proposedChange) }),
     })),
+    ...(input.currentState === undefined
+      ? {}
+      : {
+          currentState: {
+            ...input.currentState,
+            checkedPaths: uniqueSorted(input.currentState.checkedPaths.map(sanitizeRelativePath)),
+            relatedCommits: uniqueSanitizedIds(input.currentState.relatedCommits),
+            summary: sanitizeText(input.currentState.summary),
+          },
+        }),
+    ...(input.recurrence === undefined
+      ? {}
+      : {
+          recurrence: {
+            ...input.recurrence,
+            gapKey: sanitizeStorageId("gapKey", input.recurrence.gapKey),
+            sourceSessionKeys: uniqueSanitizedIds(input.recurrence.sourceSessionKeys),
+          },
+        }),
+    ...(input.supersession === undefined
+      ? {}
+      : {
+          supersession: {
+            ...input.supersession,
+            reason: sanitizeText(input.supersession.reason),
+          },
+        }),
     ...(input.improvementEval === undefined
       ? {}
       : { improvementEval: sanitizeEvolutionImprovementEval(input.improvementEval) }),
@@ -394,6 +421,7 @@ export function validateEvolutionRepoProposal(proposal: EvolutionRepoProposal):
     "rejected",
     "deferred",
     "applied",
+    "superseded",
   ]);
   if (
     proposal.reviewStateChangedAt !== undefined &&
@@ -406,6 +434,72 @@ export function validateEvolutionRepoProposal(proposal: EvolutionRepoProposal):
       throw new Error("Repo proposal proposedChange must not be empty.");
     }
   }
+  if (proposal.currentState !== undefined) {
+    if (!isRecord(proposal.currentState)) {
+      throw new Error("Repo proposal currentState must be an object.");
+    }
+    assertTimestamp("currentState.checkedAt", proposal.currentState.checkedAt);
+    if (!/^[a-f0-9]{40}([a-f0-9]{24})?$/.test(proposal.currentState.headSha)) {
+      throw new Error("Repo proposal currentState.headSha must be a Git object id.");
+    }
+    if (!/^[a-f0-9]{64}$/.test(proposal.currentState.statusFingerprint)) {
+      throw new Error("Repo proposal currentState.statusFingerprint must be a SHA-256 digest.");
+    }
+    assertEnum("currentState.verdict", proposal.currentState.verdict, [
+      "unresolved",
+      "resolved",
+      "unknown",
+    ]);
+    assertEnum("currentState.ownership", proposal.currentState.ownership, [
+      "governance",
+      "implementation",
+      "not-applicable",
+    ]);
+    if (typeof proposal.currentState.explicitUserRequest !== "boolean") {
+      throw new Error("Repo proposal currentState.explicitUserRequest must be a boolean.");
+    }
+    assertStringArray("currentState.checkedPaths", proposal.currentState.checkedPaths);
+    assertStringArray("currentState.relatedCommits", proposal.currentState.relatedCommits);
+    for (const commit of proposal.currentState.relatedCommits) {
+      if (!/^[a-f0-9]{7,64}$/.test(commit)) {
+        throw new Error("Repo proposal currentState.relatedCommits must contain Git object ids.");
+      }
+    }
+    assertString("currentState.summary", proposal.currentState.summary);
+  }
+  if (proposal.recurrence !== undefined) {
+    if (!isRecord(proposal.recurrence)) {
+      throw new Error("Repo proposal recurrence must be an object.");
+    }
+    assertString("recurrence.gapKey", proposal.recurrence.gapKey);
+    assertStringArray("recurrence.sourceSessionKeys", proposal.recurrence.sourceSessionKeys);
+    if (
+      !Number.isInteger(proposal.recurrence.independentSessionCount) ||
+      proposal.recurrence.independentSessionCount < 2 ||
+      proposal.recurrence.independentSessionCount !==
+        new Set(proposal.recurrence.sourceSessionKeys).size
+    ) {
+      throw new Error(
+        "Repo proposal recurrence must contain at least two distinct source sessions.",
+      );
+    }
+  }
+  if (proposal.supersession !== undefined) {
+    if (!isRecord(proposal.supersession)) {
+      throw new Error("Repo proposal supersession must be an object.");
+    }
+    if (proposal.supersession.policy !== "session-proposal-v2") {
+      throw new Error("Repo proposal supersession policy is invalid.");
+    }
+    assertString("supersession.reason", proposal.supersession.reason);
+    assertTimestamp("supersession.supersededAt", proposal.supersession.supersededAt);
+  }
+  if (proposal.reviewState === "superseded" && proposal.supersession === undefined) {
+    throw new Error("A superseded repo proposal must include supersession metadata.");
+  }
+  if (proposal.reviewState !== "superseded" && proposal.supersession !== undefined) {
+    throw new Error("Repo proposal supersession metadata requires superseded review state.");
+  }
   if (proposal.lastDecision !== undefined) {
     assertEnum("lastDecision.state", proposal.lastDecision.state, [
       "accepted",
@@ -601,6 +695,20 @@ function assertNullableTimestamp(field: string, value: string | null): void {
   }
 }
 
+function assertTimestamp(field: string, value: unknown): asserts value is string {
+  assertString(field, value);
+  if (Number.isNaN(new Date(value).getTime())) {
+    throw new Error(`${field} must be a valid timestamp.`);
+  }
+}
+
+function assertStringArray(field: string, value: unknown): asserts value is string[] {
+  if (!Array.isArray(value)) throw new Error(`${field} must be an array.`);
+  for (const [index, item] of value.entries()) {
+    assertString(`${field}[${index}]`, item);
+  }
+}
+
 function isNonNegativeInteger(value: unknown): value is number {
   return typeof value === "number" && Number.isInteger(value) && value >= 0;
 }

package/src/index.ts

@@ -10,6 +10,10 @@ export * as evolutionEvidence from "./evolution/evidence/index.ts";
 export * from "./evolution/evidence/session-memory/index.ts";
 export * from "./evolution/knowledge/index.ts";
 export * as evolutionKnowledge from "./evolution/knowledge/index.ts";
+export * from "./evolution/knowledge/changes.ts";
+export * from "./evolution/knowledge/change-store.ts";
+export * from "./evolution/knowledge/freshness.ts";
+export * from "./evolution/knowledge/review.ts";
 export * as evolutionProcessor from "./evolution/processor/index.ts";
 export * from "./evolution/review/index.ts";
 export * as evolutionReview from "./evolution/review/index.ts";