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

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

@@ -198,6 +198,37 @@ export async function appendRawEvent(
   return { lineNumber: existingLineCount + 1 };
 }
 
+export async function resetSessionRawEvents(path: string): Promise<void> {
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+  await writeFile(path, "", { encoding: "utf8", mode: 0o600 });
+  await chmod(path, 0o600);
+}
+
+export async function rewriteSessionRawEvents(
+  path: string,
+  lines: string[],
+  expectedCurrent: string,
+): Promise<boolean> {
+  await ensurePrivateSessionMemoryDirectory(dirname(path));
+  const temporaryPath = join(dirname(path), `.${randomUUID()}.tmp`);
+  try {
+    const handle = await open(temporaryPath, "wx", 0o600);
+    try {
+      await handle.writeFile(lines.length === 0 ? "" : `${lines.join("\n")}\n`, "utf8");
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    const current = await readFile(path, "utf8").catch(() => null);
+    if (current !== expectedCurrent) return false;
+    await rename(temporaryPath, path);
+    await chmod(path, 0o600);
+    return true;
+  } finally {
+    await rm(temporaryPath, { force: true }).catch(() => undefined);
+  }
+}
+
 export async function readLineRange(
   path: string,
   fromLine: number,
@@ -401,7 +432,7 @@ export async function writeSessionEvidenceSegmentAtomic(input: {
   homeDir: string;
   segment: SessionEvidenceSegmentV1;
 }): Promise<void> {
-  assertHistoricalRetentionState(input.segment);
+  assertSessionEvidenceRetentionState(input.segment);
   const paths = resolveSessionMemoryPaths({
     homeDir: input.homeDir,
     projectKey: input.segment.projectKey,
@@ -410,9 +441,9 @@ export async function writeSessionEvidenceSegmentAtomic(input: {
   await writePrivateAtomicJson(paths.segmentPath(input.segment.id), input.segment);
 }
 
-function assertHistoricalRetentionState(segment: SessionEvidenceSegmentV1): void {
-  if (segment.origin?.kind !== "historical-import" || segment.retention === undefined) {
-    throw new Error("Atomic Session Evidence rewrite is limited to historical retention.");
+function assertSessionEvidenceRetentionState(segment: SessionEvidenceSegmentV1): void {
+  if (segment.retention === undefined) {
+    throw new Error("Atomic Session Evidence rewrite requires retention metadata.");
   }
   if (segment.retention.rawState === "available") {
     if (
@@ -421,7 +452,7 @@ function assertHistoricalRetentionState(segment: SessionEvidenceSegmentV1): void
       segment.rawExcerpt.sha256 !== sha256Hex(segment.rawExcerpt.content) ||
       segment.retention.originalRawSha256 !== segment.rawExcerpt.sha256
     ) {
-      throw new Error("Available historical Session Evidence raw state is invalid.");
+      throw new Error("Available Session Evidence raw state is invalid.");
     }
     return;
   }
@@ -433,7 +464,7 @@ function assertHistoricalRetentionState(segment: SessionEvidenceSegmentV1): void
     segment.retention.rawPurgedAt === null ||
     segment.lifecycle.status !== "raw-expired"
   ) {
-    throw new Error("Purged historical Session Evidence raw state is invalid.");
+    throw new Error("Purged Session Evidence raw state is invalid.");
   }
 }
 

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

@@ -104,7 +104,7 @@ export interface HistoricalImportOriginV1 {
   recordCount: number;
 }
 
-export interface HistoricalImportRetentionV1 {
+export interface SessionEvidenceRetentionV1 {
   policyDays: number;
   expiresAt: string;
   rawState: "available" | "purged";
@@ -112,6 +112,8 @@ export interface HistoricalImportRetentionV1 {
   originalRawSha256: string;
 }
 
+export type HistoricalImportRetentionV1 = SessionEvidenceRetentionV1;
+
 export interface HistoricalImportStoredRecordV1 {
   schemaVersion: 1;
   kind: "historical-import-record";
@@ -168,7 +170,7 @@ export interface SessionEvidenceSegmentV1 {
   reason: SessionMemorySegmentReason;
   strength: SessionMemorySignalStrength;
   origin?: HistoricalImportOriginV1;
-  retention?: HistoricalImportRetentionV1;
+  retention?: SessionEvidenceRetentionV1;
   source: {
     traceRefId: string | null;
     sourcePath: string | null;
@@ -233,6 +235,7 @@ export interface SessionMemoryRawEventV1 {
   rawPayloadJson: string;
   rawPayloadByteLength: number;
   rawPayloadTruncated: boolean;
+  rawPayloadExpired?: boolean;
   secretsDetected: boolean;
   sensitivity?: SessionMemorySensitivity;
   sensitivityReasons?: SessionMemorySensitivityReason[];

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

@@ -21,6 +21,7 @@ import {
   appendRawEvent,
   readSessionCursor,
   readSessionState,
+  resetSessionRawEvents,
   writeJson,
   writeSessionIndex,
 } from "./storage.ts";
@@ -126,21 +127,24 @@ export async function updateSessionMemoryFromHook(
     segmentPath = paths.segmentPath(segment.id);
     await writeJson(segmentPath, segment);
     await writeSessionIndex(paths, state, segment, now);
-    const trigger = await enqueueSegmentEvolutionTrigger({
-      homeDir: input.homeDir,
-      projectKey: segment.projectKey,
-      sessionKey: segment.sessionKey,
-      runId: segment.runId,
-      roleId: segment.roleId,
-      segmentId: segment.id,
-      segmentPath,
-      strength: segment.strength,
-      reason: segment.reason,
-      summary: segment.normalized.summary,
-      now,
-    });
-    queuedSegmentTriggerId = trigger.id;
-    cursor.lastCapturedLine = appended.lineNumber;
+    if (shouldQueueSegmentForEvolution(segment)) {
+      const trigger = await enqueueSegmentEvolutionTrigger({
+        homeDir: input.homeDir,
+        projectKey: segment.projectKey,
+        sessionKey: segment.sessionKey,
+        runId: segment.runId,
+        roleId: segment.roleId,
+        segmentId: segment.id,
+        segmentPath,
+        strength: segment.strength,
+        reason: segment.reason,
+        summary: segment.normalized.summary,
+        now,
+      });
+      queuedSegmentTriggerId = trigger.id;
+    }
+    await resetSessionRawEvents(paths.eventsPath);
+    cursor.lastCapturedLine = 0;
     cursor.lastCapturedEventId = input.event.eventId;
     cursor.updatedAt = now;
     state.lastSegmentId = segment.id;
@@ -179,6 +183,10 @@ export async function updateSessionMemoryFromHook(
   };
 }
 
+function shouldQueueSegmentForEvolution(segment: SessionEvidenceSegmentV1): boolean {
+  return segment.reason !== "session-memory-threshold" && segment.reason !== "session-memory-init";
+}
+
 function emptyResult(): SessionMemoryUpdateResult {
   return {
     state: null,

package/src/evolution/knowledge/changes.ts

@@ -4,6 +4,7 @@ import type {
   OkfKnowledgeLifecycleStatus,
   OkfKnowledgePlanCandidate,
 } from "./index.ts";
+import type { OkfKnowledgeSupportRef } from "./support.ts";
 
 export const OKF_KNOWLEDGE_RENDER_CONTRACT_VERSION = 2;
 
@@ -46,6 +47,7 @@ export interface OkfKnowledgeRuntimeProjectionV1 {
     pathScopes: string[];
   };
   relatedConceptLinks: string[];
+  supportRef: OkfKnowledgeSupportRef | null;
   lifecycle: {
     status: OkfKnowledgeLifecycleStatus;
     supersedes: string[];
@@ -97,6 +99,7 @@ export function createOkfKnowledgeRuntimeProjectionFromCandidate(
       pathScopes: candidate.pathScopes,
     },
     relatedConceptLinks: candidate.relatedConceptLinks,
+    supportRef: candidate.supportRef ?? null,
     lifecycle: {
       status: candidate.decision === "revoke" ? "revoked" : "active",
       supersedes: [],
@@ -139,6 +142,7 @@ export function createOkfKnowledgeRuntimeProjectionFromConcept(
     relatedConceptLinks: readSectionList(sections, "Related Concepts").filter(
       (item) => item !== "No related concepts yet.",
     ),
+    supportRef: concept.supportRef ?? null,
     lifecycle: {
       status: concept.lifecycle.status,
       supersedes: concept.lifecycle.supersedes,
@@ -343,6 +347,7 @@ function normalizeRuntimeProjection(
       pathScopes: normalizeArray(value.scopes.pathScopes),
     },
     relatedConceptLinks: normalizeArray(value.relatedConceptLinks),
+    supportRef: value.supportRef,
     lifecycle: {
       status: value.lifecycle.status,
       supersedes: normalizeArray(value.lifecycle.supersedes),
@@ -375,6 +380,7 @@ function listChangedProjectionFields(
     ["scopes.workflowTags", base.scopes.workflowTags, candidate.scopes.workflowTags],
     ["scopes.pathScopes", base.scopes.pathScopes, candidate.scopes.pathScopes],
     ["relatedConceptLinks", base.relatedConceptLinks, candidate.relatedConceptLinks],
+    ["supportRef", base.supportRef, candidate.supportRef],
     ["lifecycle", base.lifecycle, candidate.lifecycle],
   ];
   return fields

package/src/evolution/knowledge/freshness.ts

@@ -1,4 +1,5 @@
 import type { OkfKnowledgeConcept, OkfKnowledgePlanCandidate } from "./index.ts";
+import { isDirectKnowledgeSupport, resolveOkfKnowledgeRuntimeEligibility } from "./support.ts";
 
 export type OkfKnowledgeFreshness = "verified" | "review-due" | "unknown" | "stale";
 
@@ -27,46 +28,22 @@ export function deriveOkfKnowledgeFreshness(input: {
   repositoryFingerprintChanged?: boolean;
   verifiedContradiction?: boolean;
 }): OkfKnowledgeFreshnessResult {
-  const now = normalizeNow(input.now);
-  const concept = input.concept;
-  if (
-    input.verifiedContradiction === true ||
-    concept.lifecycle.status === "stale" ||
-    concept.lifecycle.status === "deprecated" ||
-    concept.lifecycle.status === "revoked" ||
-    concept.lifecycle.status === "superseded" ||
-    concept.reviewState === "stale" ||
-    concept.reviewState === "deprecated" ||
-    concept.reviewState === "revoked" ||
-    concept.reviewState === "superseded" ||
-    isDue(concept.lifecycle.staleAfter, now)
-  ) {
-    return {
-      freshness: "stale",
-      reason:
-        input.verifiedContradiction === true
-          ? "Verified evidence contradicts the active claim."
-          : "Lifecycle status or staleAfter excludes this concept from new runtime context.",
-    };
-  }
-  if (concept.verificationSnapshot === null) {
-    return {
-      freshness: "unknown",
-      reason: "No verifiable knowledge snapshot is stored for this legacy concept.",
-    };
-  }
-  if (input.repositoryFingerprintChanged === true || isDue(concept.lifecycle.reviewAfter, now)) {
-    return {
-      freshness: "review-due",
-      reason:
-        input.repositoryFingerprintChanged === true
-          ? "A checked repository path changed after the last verification."
-          : `Review was due at ${concept.lifecycle.reviewAfter}.`,
-    };
-  }
+  const eligibility = resolveOkfKnowledgeRuntimeEligibility({
+    reviewState: input.concept.reviewState,
+    lifecycle: input.concept.lifecycle,
+    supportRef: input.concept.supportRef ?? null,
+    now: input.now,
+    sourceStatus:
+      input.repositoryFingerprintChanged === true
+        ? "changed"
+        : input.repositoryFingerprintChanged === false
+          ? "current"
+          : undefined,
+    verifiedContradiction: input.verifiedContradiction,
+  });
   return {
-    freshness: "verified",
-    reason: `Verified at ${concept.verificationSnapshot.verifiedAt}.`,
+    freshness: eligibility.freshness,
+    reason: eligibility.reason,
   };
 }
 
@@ -75,10 +52,7 @@ export function createOkfKnowledgeVerificationSnapshot(input: {
   verifiedAt: string;
   projectKey: string;
 }): OkfKnowledgeVerificationSnapshotV1 | null {
-  const hasVerification =
-    input.candidate.bodySections.verification.length > 0 ||
-    input.candidate.verificationNotApplicableReason !== undefined;
-  if (!hasVerification) return null;
+  if (!isDirectKnowledgeSupport(input.candidate.supportRef)) return null;
   const verifiedAt = normalizeIso(input.verifiedAt);
   if (verifiedAt === null) return null;
   return {
@@ -89,20 +63,6 @@ export function createOkfKnowledgeVerificationSnapshot(input: {
   };
 }
 
-function normalizeNow(value: string | Date | undefined): Date {
-  if (value instanceof Date && Number.isFinite(value.getTime())) return value;
-  if (typeof value === "string") {
-    const normalized = normalizeIso(value);
-    if (normalized !== null) return new Date(normalized);
-  }
-  return new Date();
-}
-
-function isDue(value: string, now: Date): boolean {
-  const normalized = normalizeIso(value);
-  return normalized !== null && Date.parse(normalized) <= now.getTime();
-}
-
 function normalizeIso(value: string): string | null {
   const time = Date.parse(value);
   return Number.isFinite(time) ? new Date(time).toISOString() : null;