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

package/dist/index.js

@@ -14,7 +14,7 @@ var __export = (target, all) => {
 };
 
 // packages/core/src/agents/index.ts
-import { readFile as readFile11 } from "node:fs/promises";
+import { readFile as readFile12 } from "node:fs/promises";
 
 // packages/core/src/evolution/knowledge/index.ts
 var exports_knowledge = {};
@@ -51,8 +51,10 @@ __export(exports_knowledge, {
   readFailedOkfKnowledgePlanArtifact: () => readFailedOkfKnowledgePlanArtifact,
   readOkfKnowledgeConcept: () => readOkfKnowledgeConcept,
   rebuildOkfKnowledgeIndexes: () => rebuildOkfKnowledgeIndexes,
+  recordContextInjectionOutcome: () => recordContextInjectionOutcome,
   resolveContextInjectionReceiptPath: () => resolveContextInjectionReceiptPath,
   resolveOkfKnowledgePaths: () => resolveOkfKnowledgePaths,
+  resolveOkfKnowledgeRuntimeEligibility: () => resolveOkfKnowledgeRuntimeEligibility,
   resumeFailedOkfKnowledgePlan: () => resumeFailedOkfKnowledgePlan,
   revokeOkfKnowledgeConcept: () => revokeOkfKnowledgeConcept,
   scoreLexicalKnowledgeDocument: () => scoreLexicalKnowledgeDocument,
@@ -64,7 +66,7 @@ __export(exports_knowledge, {
 });
 import { createHash as createHash5 } from "node:crypto";
 import { existsSync, readFileSync as readFileSync2, readdirSync } from "node:fs";
-import { mkdir as mkdir8, readFile as readFile10, readdir as readdir8, rename as rename3, rm as rm4, stat as stat5, writeFile as writeFile7 } from "node:fs/promises";
+import { mkdir as mkdir8, readFile as readFile11, readdir as readdir8, rename as rename3, rm as rm4, stat as stat5, writeFile as writeFile7 } from "node:fs/promises";
 import { dirname as dirname9, isAbsolute as isAbsolute5, join as join13, relative as relative4, resolve as resolve4 } from "node:path";
 
 // packages/core/src/config/paths.ts
@@ -115,7 +117,7 @@ function stripTrailingSlash(path) {
 }
 
 // packages/core/src/config/settings.ts
-import { readFile as readFile8 } from "node:fs/promises";
+import { readFile as readFile9 } from "node:fs/promises";
 
 // packages/core/src/evolution/evidence/session-memory/index.ts
 var exports_session_memory = {};
@@ -130,18 +132,23 @@ __export(exports_session_memory, {
   createSemanticPacketMessageKey: () => createSemanticPacketMessageKey,
   detectSessionMemorySensitivity: () => detectSessionMemorySensitivity,
   inspectHistoricalSessionEvidenceRetention: () => inspectHistoricalSessionEvidenceRetention,
+  inspectSessionEvidenceRetention: () => inspectSessionEvidenceRetention,
   listSessionEvidenceSegments: () => listSessionEvidenceSegments,
   listSessionMemoryStates: () => listSessionMemoryStates,
   mergeSessionMemorySensitivity: () => mergeSessionMemorySensitivity,
+  migrateLegacySessionEvidenceRetention: () => migrateLegacySessionEvidenceRetention,
   parseSessionMemoryPolicy: () => parseSessionMemoryPolicy,
   purgeExpiredHistoricalSessionEvidence: () => purgeExpiredHistoricalSessionEvidence,
+  purgeExpiredSessionEvidence: () => purgeExpiredSessionEvidence,
   readLineRange: () => readLineRange,
   readSessionCursor: () => readSessionCursor,
   readSessionEvidenceSegment: () => readSessionEvidenceSegment,
   readSessionState: () => readSessionState,
   redactSessionMemoryCredentialText: () => redactSessionMemoryCredentialText,
   redactSessionMemoryCredentials: () => redactSessionMemoryCredentials,
+  resetSessionRawEvents: () => resetSessionRawEvents,
   resolveSessionMemoryPaths: () => resolveSessionMemoryPaths,
+  rewriteSessionRawEvents: () => rewriteSessionRawEvents,
   updateSessionEvidenceSegmentLifecycle: () => updateSessionEvidenceSegmentLifecycle,
   updateSessionMemoryFromHook: () => updateSessionMemoryFromHook,
   writeHistoricalSessionEvidenceSegment: () => writeHistoricalSessionEvidenceSegment,
@@ -1936,6 +1943,9 @@ function asRecord(value) {
 function createSemanticPacketMessageKey(value) {
   return sha256Hex(value);
 }
+// packages/core/src/evolution/evidence/session-memory/retention.ts
+import { readFile as readFile5 } from "node:fs/promises";
+
 // packages/core/src/evolution/candidates/index.ts
 var exports_candidates = {};
 __export(exports_candidates, {
@@ -2812,6 +2822,36 @@ async function appendRawEvent(path, event) {
 `, "utf8");
   return { lineNumber: existingLineCount + 1 };
 }
+async function resetSessionRawEvents(path) {
+  await mkdir3(dirname3(path), { recursive: true, mode: 448 });
+  await writeFile3(path, "", { encoding: "utf8", mode: 384 });
+  await chmod(path, 384);
+}
+async function rewriteSessionRawEvents(path, lines, expectedCurrent) {
+  await ensurePrivateSessionMemoryDirectory(dirname3(path));
+  const temporaryPath = join6(dirname3(path), `.${randomUUID()}.tmp`);
+  try {
+    const handle = await open(temporaryPath, "wx", 384);
+    try {
+      await handle.writeFile(lines.length === 0 ? "" : `${lines.join(`
+`)}
+`, "utf8");
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    const current = await readFile4(path, "utf8").catch(() => null);
+    if (current !== expectedCurrent)
+      return false;
+    await rename(temporaryPath, path);
+    await chmod(path, 384);
+    return true;
+  } finally {
+    await rm2(temporaryPath, { force: true }).catch(() => {
+      return;
+    });
+  }
+}
 async function readLineRange(path, fromLine, toLine) {
   const text2 = await readFile4(path, "utf8");
   const lines = text2.split(`
@@ -2967,7 +3007,7 @@ async function writeHistoricalSessionStateAndIndex(input) {
   return { state, segmentIds: ordered.map((segment) => segment.id) };
 }
 async function writeSessionEvidenceSegmentAtomic(input) {
-  assertHistoricalRetentionState(input.segment);
+  assertSessionEvidenceRetentionState(input.segment);
   const paths = resolveSessionMemoryPaths({
     homeDir: input.homeDir,
     projectKey: input.segment.projectKey,
@@ -2975,18 +3015,18 @@ async function writeSessionEvidenceSegmentAtomic(input) {
   });
   await writePrivateAtomicJson(paths.segmentPath(input.segment.id), input.segment);
 }
-function assertHistoricalRetentionState(segment) {
-  if (segment.origin?.kind !== "historical-import" || segment.retention === undefined) {
-    throw new Error("Atomic Session Evidence rewrite is limited to historical retention.");
+function assertSessionEvidenceRetentionState(segment) {
+  if (segment.retention === undefined) {
+    throw new Error("Atomic Session Evidence rewrite requires retention metadata.");
   }
   if (segment.retention.rawState === "available") {
     if (!segment.rawExcerpt.stored || segment.rawExcerpt.byteLength !== Buffer.byteLength(segment.rawExcerpt.content, "utf8") || 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;
   }
   if (segment.rawExcerpt.stored || segment.rawExcerpt.content !== "" || segment.rawExcerpt.byteLength !== 0 || segment.rawExcerpt.sha256 !== sha256Hex("") || 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.");
   }
 }
 async function writeJson(path, value) {
@@ -3203,69 +3243,95 @@ async function listJsonFiles(path) {
 
 // packages/core/src/evolution/evidence/session-memory/retention.ts
 var DEFAULT_RETENTION_LIMIT = 20;
-var MAX_RETENTION_LIMIT = 20;
+var MAX_RETENTION_LIMIT = 1e4;
+var DEFAULT_LEGACY_RETENTION_DAYS = 30;
+async function inspectSessionEvidenceRetention(input) {
+  const result = await inspectRetention(input, () => true);
+  const expiredEvents = await expireCapturedRawEvents({ ...input, apply: false });
+  result.expiredCapturedEventPayloads = expiredEvents.payloads;
+  result.expiredCapturedEventRawBytes = expiredEvents.rawBytes;
+  return result;
+}
 async function inspectHistoricalSessionEvidenceRetention(input) {
+  return inspectRetention(input, (segment) => segment.origin?.kind === "historical-import");
+}
+async function inspectRetention(input, include) {
   const now = normalizeTimestamp(input.now);
-  const historical = (await listSessionEvidenceSegments({
+  const segments = (await listSessionEvidenceSegments({
     homeDir: input.homeDir,
     projectKey: input.projectKey
-  })).filter((segment) => segment.origin?.kind === "historical-import" && segment.retention !== undefined);
-  const result = {
-    available: 0,
-    purged: 0,
-    overdue: 0,
-    purgeEligible: 0,
-    protected: 0,
-    protectionReasons: {}
-  };
-  const reviewSnapshots = new Map;
-  for (const segment of historical) {
-    if (segment.retention?.rawState === "purged") {
+  })).filter(include);
+  const retentionDays = await loadLegacyRetentionDays(input.homeDir, input.projectKey);
+  const result = emptyInspection();
+  const context = createRetentionContext();
+  for (const segment of segments) {
+    if (segment.retention === undefined) {
+      const rawBytes = segment.rawExcerpt.stored ? segment.rawExcerpt.byteLength : 0;
+      result.legacyWithoutRetention += 1;
+      result.legacyRawBytes += rawBytes;
+      const expiresAt = legacyExpiresAt(segment, retentionDays);
+      if (Date.parse(expiresAt) <= Date.parse(now)) {
+        result.legacyOverdue += 1;
+        result.legacyOverdueRawBytes += rawBytes;
+        const protection2 = await findRetentionProtection({
+          homeDir: input.homeDir,
+          segment,
+          context
+        });
+        if (protection2 === null)
+          result.purgeEligible += 1;
+        else
+          addProtection(result, protection2);
+      }
+      continue;
+    }
+    if (segment.retention.rawState === "purged") {
       result.purged += 1;
       continue;
     }
     result.available += 1;
     if (!hasValidAvailableRetention(segment)) {
       result.overdue += 1;
-      result.protected += 1;
-      result.protectionReasons["retention-invalid"] = (result.protectionReasons["retention-invalid"] ?? 0) + 1;
+      addProtection(result, "retention-invalid");
       continue;
     }
-    if (segment.retention === undefined || Date.parse(segment.retention.expiresAt) > Date.parse(now)) {
+    if (Date.parse(segment.retention.expiresAt) > Date.parse(now))
       continue;
-    }
     result.overdue += 1;
     const protection = await findRetentionProtection({
       homeDir: input.homeDir,
       segment,
-      reviewSnapshots
+      context
     });
-    if (protection === null) {
+    if (protection === null)
       result.purgeEligible += 1;
-      continue;
-    }
-    result.protected += 1;
-    result.protectionReasons[protection] = (result.protectionReasons[protection] ?? 0) + 1;
+    else
+      addProtection(result, protection);
   }
   return result;
 }
+async function purgeExpiredSessionEvidence(input) {
+  return purgeRetention(input, () => true);
+}
 async function purgeExpiredHistoricalSessionEvidence(input) {
+  return purgeRetention(input, (segment) => segment.origin?.kind === "historical-import");
+}
+async function purgeRetention(input, include) {
   const now = normalizeTimestamp(input.now);
   const limit = normalizeLimit(input.limit);
-  const historical = (await listSessionEvidenceSegments({
+  const segments = (await listSessionEvidenceSegments({
     homeDir: input.homeDir,
     projectKey: input.projectKey
-  })).filter((segment) => segment.origin?.kind === "historical-import" && segment.retention !== undefined).sort((left, right) => (left.retention?.expiresAt ?? "").localeCompare(right.retention?.expiresAt ?? "") || left.id.localeCompare(right.id));
+  })).filter((segment) => include(segment) && segment.retention !== undefined).sort((left, right) => (left.retention?.expiresAt ?? "").localeCompare(right.retention?.expiresAt ?? "") || left.id.localeCompare(right.id));
   const result = {
     scanned: 0,
     due: 0,
     purged: 0,
-    alreadyPurged: 0,
+    alreadyPurged: segments.filter((segment) => segment.retention?.rawState === "purged").length,
     protected: []
   };
-  const reviewSnapshots = new Map;
-  result.alreadyPurged = historical.filter((segment) => segment.retention?.rawState === "purged").length;
-  for (const segment of historical) {
+  const context = createRetentionContext();
+  for (const segment of segments) {
     if (result.scanned >= limit)
       break;
     if (segment.retention === undefined || segment.retention.rawState === "purged")
@@ -3286,7 +3352,7 @@ async function purgeExpiredHistoricalSessionEvidence(input) {
     const protection = await findRetentionProtection({
       homeDir: input.homeDir,
       segment,
-      reviewSnapshots
+      context
     });
     if (protection !== null) {
       result.protected.push({
@@ -3302,8 +3368,7 @@ async function purgeExpiredHistoricalSessionEvidence(input) {
       sessionKey: segment.sessionKey,
       segmentId: segment.id
     });
-    const currentTrigger = await findSegmentTrigger(input.homeDir, current);
-    if (!hasValidAvailableRetention(current) || current.retention?.rawState !== "available" || current.retention.expiresAt !== segment.retention.expiresAt || !current.rawExcerpt.stored || current.rawExcerpt.sha256 !== segment.rawExcerpt.sha256 || current.lifecycle.reviewState !== segment.lifecycle.reviewState || currentTrigger === null || !isTerminalTrigger(currentTrigger)) {
+    if (!hasValidAvailableRetention(current) || current.retention?.rawState !== "available" || current.retention.expiresAt !== segment.retention.expiresAt || !current.rawExcerpt.stored || current.rawExcerpt.sha256 !== segment.rawExcerpt.sha256 || current.lifecycle.reviewState !== segment.lifecycle.reviewState) {
       result.protected.push({
         projectKey: segment.projectKey,
         segmentId: segment.id,
@@ -3311,30 +3376,115 @@ async function purgeExpiredHistoricalSessionEvidence(input) {
       });
       continue;
     }
-    const freshSnapshot = await readEvolutionReviewSnapshot({
+    const freshProtection = await findRetentionProtection({
       homeDir: input.homeDir,
-      projectKey: current.projectKey
+      segment: current,
+      context: createRetentionContext()
     });
-    if (hasPendingDerivedReview(freshSnapshot, current)) {
+    if (freshProtection !== null) {
       result.protected.push({
-        projectKey: segment.projectKey,
-        segmentId: segment.id,
-        reason: "derived-review-pending"
+        projectKey: current.projectKey,
+        segmentId: current.id,
+        reason: freshProtection
       });
       continue;
     }
     await writeSessionEvidenceSegmentAtomic({
       homeDir: input.homeDir,
-      segment: createPurgedHistoricalSegment(current, now)
+      segment: createPurgedSegment(current, now)
     });
     result.purged += 1;
   }
   return result;
 }
+async function migrateLegacySessionEvidenceRetention(input) {
+  const now = normalizeTimestamp(input.now);
+  const retentionDays = await loadLegacyRetentionDays(input.homeDir, input.projectKey);
+  const segments = await listSessionEvidenceSegments({
+    homeDir: input.homeDir,
+    projectKey: input.projectKey
+  });
+  let migrated = 0;
+  const context = createRetentionContext();
+  for (const segment of segments) {
+    if (segment.retention !== undefined || !segment.rawExcerpt.stored)
+      continue;
+    const policyDays = retentionDays.get(sessionKey(segment)) ?? DEFAULT_LEGACY_RETENTION_DAYS;
+    if (Date.parse(addDays(segment.createdAt, policyDays)) > Date.parse(now))
+      continue;
+    const protection = await findRetentionProtection({
+      homeDir: input.homeDir,
+      segment,
+      context
+    });
+    if (protection !== null)
+      continue;
+    const current = await readSessionEvidenceSegment({
+      homeDir: input.homeDir,
+      projectKey: segment.projectKey,
+      sessionKey: segment.sessionKey,
+      segmentId: segment.id
+    });
+    if (current.retention !== undefined || JSON.stringify(current) !== JSON.stringify(segment)) {
+      continue;
+    }
+    await writeSessionEvidenceSegmentAtomic({
+      homeDir: input.homeDir,
+      segment: {
+        ...current,
+        retention: {
+          policyDays,
+          expiresAt: addDays(current.createdAt, policyDays),
+          rawState: "available",
+          rawPurgedAt: null,
+          originalRawSha256: current.rawExcerpt.sha256
+        }
+      }
+    });
+    migrated += 1;
+  }
+  const expiredEvents = await expireCapturedRawEvents({
+    homeDir: input.homeDir,
+    projectKey: input.projectKey,
+    now,
+    apply: true
+  });
+  return {
+    migrated,
+    expiredCapturedEventPayloads: expiredEvents.payloads,
+    expiredCapturedEventRawBytes: expiredEvents.rawBytes,
+    purge: await purgeExpiredSessionEvidence({
+      homeDir: input.homeDir,
+      projectKey: input.projectKey,
+      now,
+      limit: Math.max(DEFAULT_RETENTION_LIMIT, segments.length)
+    })
+  };
+}
+function emptyInspection() {
+  return {
+    available: 0,
+    purged: 0,
+    overdue: 0,
+    purgeEligible: 0,
+    protected: 0,
+    legacyWithoutRetention: 0,
+    legacyOverdue: 0,
+    legacyRawBytes: 0,
+    legacyOverdueRawBytes: 0,
+    expiredCapturedEventPayloads: 0,
+    expiredCapturedEventRawBytes: 0,
+    protectionReasons: {}
+  };
+}
+function addProtection(result, reason) {
+  result.protected += 1;
+  result.protectionReasons[reason] = (result.protectionReasons[reason] ?? 0) + 1;
+}
 function normalizeLimit(value) {
   const limit = value ?? DEFAULT_RETENTION_LIMIT;
   if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_RETENTION_LIMIT) {
-    throw new Error(`Historical Session Evidence retention limit must be between 1 and ${MAX_RETENTION_LIMIT}.`);
+    throw new Error(`Session Evidence retention limit must be between 1 and ${MAX_RETENTION_LIMIT}.`);
   }
   return limit;
 }
@@ -3346,26 +3496,38 @@ async function findRetentionProtection(input) {
   if (input.segment.lifecycle.reviewState === "unreviewed" || input.segment.lifecycle.reviewState === "deferred") {
     return "segment-review-pending";
   }
-  const trigger = await findSegmentTrigger(input.homeDir, input.segment);
-  if (trigger === null)
+  const trigger = await findSegmentTrigger(input.homeDir, input.segment, input.context);
+  if (trigger === null) {
+    if (input.segment.reason === "session-memory-threshold")
+      return null;
     return "trigger-missing";
+  }
   if (!isTerminalTrigger(trigger))
     return "trigger-not-terminal";
-  let snapshot = input.reviewSnapshots.get(input.segment.projectKey);
+  let snapshot = input.context.reviewSnapshots.get(input.segment.projectKey);
   if (snapshot === undefined) {
     snapshot = readEvolutionReviewSnapshot({
       homeDir: input.homeDir,
       projectKey: input.segment.projectKey
     });
-    input.reviewSnapshots.set(input.segment.projectKey, snapshot);
+    input.context.reviewSnapshots.set(input.segment.projectKey, snapshot);
   }
   return hasPendingDerivedReview(await snapshot, input.segment) ? "derived-review-pending" : null;
 }
-async function findSegmentTrigger(homeDir, segment) {
-  const matches = (await listSegmentEvolutionTriggers({
-    homeDir,
-    projectKey: segment.projectKey
-  })).filter((trigger) => trigger.segmentId === segment.id && trigger.sessionKey === segment.sessionKey);
+async function findSegmentTrigger(homeDir, segment, context) {
+  let triggerMap = context.triggerMaps.get(segment.projectKey);
+  if (triggerMap === undefined) {
+    triggerMap = listSegmentEvolutionTriggers({ homeDir, projectKey: segment.projectKey }).then((triggers) => {
+      const map = new Map;
+      for (const trigger of triggers) {
+        const key = `${trigger.sessionKey}\x00${trigger.segmentId}`;
+        map.set(key, [...map.get(key) ?? [], trigger]);
+      }
+      return map;
+    });
+    context.triggerMaps.set(segment.projectKey, triggerMap);
+  }
+  const matches = (await triggerMap).get(`${segment.sessionKey}\x00${segment.id}`) ?? [];
   return matches.length === 1 ? matches[0] ?? null : null;
 }
 function isTerminalTrigger(trigger) {
@@ -3384,10 +3546,10 @@ function hasPendingDerivedReview(snapshot, segment) {
   }
   return snapshot.reviewCandidates.some((candidate) => candidate.runId === runId && candidate.reviewState !== "accepted" && candidate.reviewState !== "rejected");
 }
-function createPurgedHistoricalSegment(segment, now) {
+function createPurgedSegment(segment, now) {
   const retention = segment.retention;
   if (retention === undefined || retention.rawState !== "available") {
-    throw new Error("Historical Session Evidence raw body is not available for purge.");
+    throw new Error("Session Evidence raw body is not available for purge.");
   }
   return {
     ...segment,
@@ -3415,11 +3577,109 @@ function createPurgedHistoricalSegment(segment, now) {
     }
   };
 }
+function createRetentionContext() {
+  return {
+    reviewSnapshots: new Map,
+    triggerMaps: new Map
+  };
+}
+async function loadLegacyRetentionDays(homeDir, projectKey) {
+  const states = await listSessionMemoryStates({ homeDir, projectKey });
+  return new Map(states.map((state) => [`${state.projectKey}\x00${state.sessionKey}`, state.policy.retentionDays]));
+}
+function legacyExpiresAt(segment, retentionDays) {
+  return addDays(segment.createdAt, retentionDays.get(sessionKey(segment)) ?? DEFAULT_LEGACY_RETENTION_DAYS);
+}
+function sessionKey(segment) {
+  return `${segment.projectKey}\x00${segment.sessionKey}`;
+}
+function addDays(value, days) {
+  const timestamp = Date.parse(value);
+  if (!Number.isFinite(timestamp))
+    throw new Error("Invalid Session Evidence retention timestamp.");
+  return new Date(timestamp + days * 24 * 60 * 60 * 1000).toISOString();
+}
+async function expireCapturedRawEvents(input) {
+  const now = Date.parse(normalizeTimestamp(input.now));
+  const states = await listSessionMemoryStates({
+    homeDir: input.homeDir,
+    projectKey: input.projectKey
+  });
+  let payloads = 0;
+  let rawBytes = 0;
+  for (const state of states) {
+    const stateUpdatedAt = Date.parse(state.updatedAt);
+    if (Number.isFinite(stateUpdatedAt) && now - stateUpdatedAt < 5 * 60 * 1000)
+      continue;
+    const paths = resolveSessionMemoryPaths({
+      homeDir: input.homeDir,
+      projectKey: state.projectKey,
+      sessionKey: state.sessionKey
+    });
+    const cursor = await readCursor(paths.cursorPath);
+    const capturedLine = cursor?.lastCapturedLine ?? 0;
+    if (capturedLine <= 0)
+      continue;
+    let text2;
+    try {
+      text2 = await readFile5(paths.eventsPath, "utf8");
+    } catch {
+      continue;
+    }
+    const lines = text2.split(`
+`).filter((line) => line.trim() !== "");
+    let changed = false;
+    let filePayloads = 0;
+    let fileRawBytes = 0;
+    const nextLines = lines.map((line, index) => {
+      if (index >= capturedLine)
+        return line;
+      let event;
+      try {
+        event = JSON.parse(line);
+      } catch {
+        return line;
+      }
+      const expiresAt = Date.parse(event.receivedAt) + state.policy.retentionDays * 24 * 60 * 60 * 1000;
+      if (!Number.isFinite(expiresAt) || expiresAt > now || event.rawPayloadExpired === true || event.rawPayloadJson === "{}") {
+        return line;
+      }
+      filePayloads += 1;
+      fileRawBytes += Buffer.byteLength(event.rawPayloadJson, "utf8");
+      if (!input.apply)
+        return line;
+      changed = true;
+      return JSON.stringify({
+        ...event,
+        rawPayloadJson: "{}",
+        rawPayloadTruncated: false,
+        rawPayloadExpired: true
+      });
+    });
+    if (!input.apply) {
+      payloads += filePayloads;
+      rawBytes += fileRawBytes;
+      continue;
+    }
+    if (changed && await rewriteSessionRawEvents(paths.eventsPath, nextLines, text2)) {
+      payloads += filePayloads;
+      rawBytes += fileRawBytes;
+    }
+  }
+  return { payloads, rawBytes };
+}
+async function readCursor(path) {
+  try {
+    return JSON.parse(await readFile5(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
 // packages/core/src/evolution/evidence/session-memory/updater.ts
 import { join as join9 } from "node:path";
 
 // packages/core/src/projects/index.ts
-import { lstat as lstat2, readFile as readFile5, readdir as readdir5, realpath, stat as stat2 } from "node:fs/promises";
+import { lstat as lstat2, readFile as readFile6, readdir as readdir5, realpath, stat as stat2 } from "node:fs/promises";
 import { basename as basename2, dirname as dirname5, isAbsolute as isAbsolute3, join as join8, parse } from "node:path";
 
 // packages/core/src/runtime-logs/index.ts
@@ -3511,14 +3771,14 @@ function createDebugLogEntry(input) {
 function createTraceLogEntry(input) {
   const timestamp = normalizeTimestamp(input.timestamp);
   const payload = input.payload ?? null;
-  const sessionKey = input.sessionKey ?? resolveTraceSessionKey(payload);
+  const sessionKey2 = input.sessionKey ?? resolveTraceSessionKey(payload);
   return {
     version: 1,
     kind: "trace",
     timestamp,
     date: formatLocalDateKey(timestamp),
     phase: input.phase,
-    sessionKey,
+    sessionKey: sessionKey2,
     target: truncateString(input.target),
     runtime: {
       surface: input.runtime.surface,
@@ -3541,7 +3801,7 @@ function createTraceLogEntry(input) {
 }
 function createEvoDevExecutionEvent(input) {
   const timestamp = normalizeTimestamp(input.timestamp);
-  const sessionKey = sanitizePersistentIdentifier(input.sessionKey, "session");
+  const sessionKey2 = sanitizePersistentIdentifier(input.sessionKey, "session");
   const target = normalizeExecutionEventTarget(input.target);
   const eventType = sanitizeEventText(input.eventType, "unknown");
   const projectKey = input.projectKey === undefined || input.projectKey === null ? null : sanitizePersistentIdentifier(input.projectKey, "project");
@@ -3562,7 +3822,7 @@ function createEvoDevExecutionEvent(input) {
       timestamp,
       target,
       eventType,
-      sessionKey,
+      sessionKey: sessionKey2,
       projectKey,
       runId,
       roleId,
@@ -3578,7 +3838,7 @@ function createEvoDevExecutionEvent(input) {
     runId,
     roleId,
     taskId,
-    sessionKey,
+    sessionKey: sessionKey2,
     summary,
     metadata,
     decision,
@@ -4415,7 +4675,7 @@ async function findNearestGitRoot(cwd) {
 }
 async function readDiscoveredProject(path) {
   try {
-    return parseDiscoveredProject(JSON.parse(await readFile5(path, "utf8")));
+    return parseDiscoveredProject(JSON.parse(await readFile6(path, "utf8")));
   } catch (error) {
     if (isNotFoundError(error) || error instanceof ProjectRegistrationError)
       return null;
@@ -4424,7 +4684,7 @@ async function readDiscoveredProject(path) {
 }
 async function readRegisteredProject(path) {
   try {
-    return parseRegisteredProject(JSON.parse(await readFile5(path, "utf8")));
+    return parseRegisteredProject(JSON.parse(await readFile6(path, "utf8")));
   } catch (error) {
     if (isNotFoundError(error) || error instanceof ProjectRegistrationError)
       return null;
@@ -4433,7 +4693,7 @@ async function readRegisteredProject(path) {
 }
 async function readProjectWorkspace(path) {
   try {
-    return parseProjectWorkspace(JSON.parse(await readFile5(path, "utf8")));
+    return parseProjectWorkspace(JSON.parse(await readFile6(path, "utf8")));
   } catch (error) {
     if (isNotFoundError(error) || error instanceof ProjectRegistrationError)
       return null;
@@ -4442,7 +4702,7 @@ async function readProjectWorkspace(path) {
 }
 async function readProjectAlias(path) {
   try {
-    return parseProjectAlias(JSON.parse(await readFile5(path, "utf8")));
+    return parseProjectAlias(JSON.parse(await readFile6(path, "utf8")));
   } catch (error) {
     if (isNotFoundError(error) || error instanceof ProjectRegistrationError)
       return null;
@@ -4521,7 +4781,7 @@ async function listLegacyHookBindings(homeDir) {
   for (const root of roots) {
     for (const sessionDir of await listDirectoryNames3(root)) {
       try {
-        const value = JSON.parse(await readFile5(join8(root, sessionDir, "binding.json"), "utf8"));
+        const value = JSON.parse(await readFile6(join8(root, sessionDir, "binding.json"), "utf8"));
         if (value === null || value.target !== "claude" && value.target !== "codex" || !isNonEmptyString(value.sessionKey) || !(value.cwd === null || isAbsoluteString(value.cwd)) || !isNonEmptyString(value.updatedAt)) {
           continue;
         }
@@ -4642,6 +4902,7 @@ async function createSegment(input) {
     String(toLine),
     input.signals.at(-1)?.eventId ?? input.now
   ]);
+  const rawSha256 = sha256Hex(truncated.content);
   return {
     schemaVersion: 1,
     kind: "session-evidence-segment",
@@ -4654,6 +4915,13 @@ async function createSegment(input) {
     createdAt: input.now,
     reason: input.reason,
     strength: input.strength,
+    retention: {
+      policyDays: input.state.policy.retentionDays,
+      expiresAt: addDays2(input.now, input.state.policy.retentionDays),
+      rawState: "available",
+      rawPurgedAt: null,
+      originalRawSha256: rawSha256
+    },
     source: {
       traceRefId: input.cursor.traceRefId,
       sourcePath: input.paths.eventsPath,
@@ -4671,7 +4939,7 @@ async function createSegment(input) {
       content: truncated.content,
       truncated: raw.truncated || truncated.truncated,
       byteLength: Buffer.byteLength(truncated.content, "utf8"),
-      sha256: sha256Hex(truncated.content)
+      sha256: rawSha256
     },
     normalized: {
       summary: createSegmentSummary(input.reason, input.strength, signalSummaries),
@@ -4700,6 +4968,12 @@ async function createSegment(input) {
     }
   };
 }
+function addDays2(value, days) {
+  const timestamp = Date.parse(value);
+  if (!Number.isFinite(timestamp))
+    throw new Error("Invalid Session Evidence retention timestamp.");
+  return new Date(timestamp + days * 24 * 60 * 60 * 1000).toISOString();
+}
 function estimateTokenCount(rawPayloadJson, summary) {
   return Math.max(1, Math.ceil((rawPayloadJson.length + summary.length) / 4));
 }
@@ -4914,8 +5188,8 @@ async function updateSessionMemoryFromHook(input) {
   const cwd = optionalString(input.rawPayload.cwd);
   const workspace = team === null && cwd !== null ? await resolveProjectWorkspaceFromCwd({ homeDir: input.homeDir, cwd }) : null;
   const projectKey = sanitizeStorageId(team?.projectKey ?? workspace?.projectKey ?? resolveProjectLogKey(input.homeDir, cwd ?? input.homeDir), "project");
-  const sessionKey = sanitizeStorageId(resolveTraceSessionKey(input.rawPayload), "session");
-  const paths = resolveSessionMemoryPaths({ homeDir: input.homeDir, projectKey, sessionKey });
+  const sessionKey2 = sanitizeStorageId(resolveTraceSessionKey(input.rawPayload), "session");
+  const paths = resolveSessionMemoryPaths({ homeDir: input.homeDir, projectKey, sessionKey: sessionKey2 });
   const now = normalizeTimestamp(input.receivedAt ?? input.event.time.receivedAt);
   const existingState = await readSessionState(paths.statePath);
   if (existingState === null && input.event.type !== "UserPromptSubmit") {
@@ -4927,7 +5201,7 @@ async function updateSessionMemoryFromHook(input) {
   const currentSignal = createSignal(input, rawEvent, appended.lineNumber);
   const state = existingState ?? createInitialState({
     projectKey,
-    sessionKey,
+    sessionKey: sessionKey2,
     target: input.target,
     runId: team?.runId ?? null,
     roleId: team?.roleId ?? null,
@@ -4936,7 +5210,7 @@ async function updateSessionMemoryFromHook(input) {
     eventId: input.event.eventId,
     tokenEstimate
   });
-  const cursor = await readSessionCursor(paths.cursorPath, sessionKey, paths.eventsPath, now);
+  const cursor = await readSessionCursor(paths.cursorPath, sessionKey2, paths.eventsPath, now);
   const previous = cloneState(state);
   applyEventToState(state, {
     input,
@@ -4978,21 +5252,24 @@ async function updateSessionMemoryFromHook(input) {
     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;
@@ -5018,6 +5295,9 @@ async function updateSessionMemoryFromHook(input) {
     queuedSegmentTriggerId
   };
 }
+function shouldQueueSegmentForEvolution(segment) {
+  return segment.reason !== "session-memory-threshold" && segment.reason !== "session-memory-init";
+}
 function emptyResult() {
   return {
     state: null,
@@ -5029,12 +5309,12 @@ function emptyResult() {
   };
 }
 // packages/core/src/hooks/index.ts
-import { mkdir as mkdir6, readFile as readFile7, writeFile as writeFile5 } from "node:fs/promises";
+import { mkdir as mkdir6, readFile as readFile8, writeFile as writeFile5 } from "node:fs/promises";
 import { dirname as dirname7, join as join11 } from "node:path";
 
 // packages/core/src/team/index.ts
 import { spawn } from "node:child_process";
-import { appendFile as appendFile3, cp, mkdir as mkdir5, readFile as readFile6, readdir as readdir6, stat as stat3, writeFile as writeFile4 } from "node:fs/promises";
+import { appendFile as appendFile3, cp, mkdir as mkdir5, readFile as readFile7, readdir as readdir6, stat as stat3, writeFile as writeFile4 } from "node:fs/promises";
 import { basename as basename3, dirname as dirname6, extname, isAbsolute as isAbsolute4, join as join10, relative as relative3, resolve as resolve3 } from "node:path";
 
 // packages/core/src/team/prompts.ts
@@ -5245,7 +5525,7 @@ function createTeamRunStore(homeDir) {
     },
     async readRun(runId) {
       await migrateLegacyRunDirIfNeeded(paths2, runId);
-      return parseTeamRunRecord(JSON.parse(await readFile6(paths2.runPath(runId), "utf8")));
+      return parseTeamRunRecord(JSON.parse(await readFile7(paths2.runPath(runId), "utf8")));
     },
     async writeLatestRunId(runId) {
       await mkdir5(paths2.runsDir, { recursive: true });
@@ -5253,13 +5533,13 @@ function createTeamRunStore(homeDir) {
     },
     async readLatestRunId() {
       try {
-        const latest = JSON.parse(await readFile6(paths2.latestRunPath, "utf8"));
+        const latest = JSON.parse(await readFile7(paths2.latestRunPath, "utf8"));
         if (latest?.version === 1 && typeof latest.runId === "string")
           return latest.runId;
         return null;
       } catch {
         try {
-          const latest = JSON.parse(await readFile6(paths2.legacyLatestRunPath, "utf8"));
+          const latest = JSON.parse(await readFile7(paths2.legacyLatestRunPath, "utf8"));
           if (latest?.version === 1 && typeof latest.runId === "string") {
             await migrateLegacyRunDirIfNeeded(paths2, latest.runId);
             await this.writeLatestRunId(latest.runId);
@@ -5277,13 +5557,13 @@ function createTeamRunStore(homeDir) {
     },
     async readAgent(runId, roleId) {
       await migrateLegacyRunDirIfNeeded(paths2, runId);
-      return parseTeamAgentRecord(JSON.parse(await readFile6(paths2.agentPath(runId, roleId), "utf8")));
+      return parseTeamAgentRecord(JSON.parse(await readFile7(paths2.agentPath(runId, roleId), "utf8")));
     },
     async readAgents(runId) {
       await migrateLegacyRunDirIfNeeded(paths2, runId);
       try {
         const entries = await readdir6(paths2.agentsDir(runId));
-        const agents = await Promise.all(entries.filter((entry) => entry.endsWith(".json")).map((entry) => readFile6(join10(paths2.agentsDir(runId), entry), "utf8").then((raw) => parseTeamAgentRecord(JSON.parse(raw)))));
+        const agents = await Promise.all(entries.filter((entry) => entry.endsWith(".json")).map((entry) => readFile7(join10(paths2.agentsDir(runId), entry), "utf8").then((raw) => parseTeamAgentRecord(JSON.parse(raw)))));
         return agents.sort((left, right) => left.roleId.localeCompare(right.roleId));
       } catch {
         return [];
@@ -5300,7 +5580,7 @@ function createTeamRunStore(homeDir) {
     async readMessageList(runId) {
       await migrateLegacyRunDirIfNeeded(paths2, runId);
       try {
-        const file = parseTeamMessageListFile(JSON.parse(await readFile6(paths2.messageListPath(runId), "utf8")));
+        const file = parseTeamMessageListFile(JSON.parse(await readFile7(paths2.messageListPath(runId), "utf8")));
         return file.messages;
       } catch (error) {
         if (isNotFoundError2(error))
@@ -6239,7 +6519,7 @@ async function resolveTeamOverlay(input) {
     return {
       source: "repo",
       teamPath: repoTeamPath,
-      definition: parseTeamDefinitionMarkdown(await readFile6(repoTeamPath, "utf8"))
+      definition: parseTeamDefinitionMarkdown(await readFile7(repoTeamPath, "utf8"))
     };
   }
   const globalTeamPath = resolveGlobalTeamMarkdownPath(input.homeDir);
@@ -6247,7 +6527,7 @@ async function resolveTeamOverlay(input) {
     return {
       source: "global",
       teamPath: globalTeamPath,
-      definition: parseTeamDefinitionMarkdown(await readFile6(globalTeamPath, "utf8"))
+      definition: parseTeamDefinitionMarkdown(await readFile7(globalTeamPath, "utf8"))
     };
   }
   return {
@@ -6262,7 +6542,7 @@ async function ensureDefaultTeamOverlay(input) {
   const files = [];
   for (const asset of assets) {
     const targetPath = asset.kind === "team" ? join10(paths2.rootDir, "team", "team.md") : join10(paths2.rootDir, "team", "agents", asset.name);
-    const content = await readFile6(asset.sourcePath, "utf8");
+    const content = await readFile7(asset.sourcePath, "utf8");
     files.push({
       sourcePath: asset.sourcePath,
       targetPath,
@@ -6809,13 +7089,13 @@ async function createScopedTeamStartupContext(input) {
   });
   if (pack === null)
     return null;
-  const sessionKey = `team-${input.runId}-${input.role.roleId}`;
-  if (await hasContextInjectionReceipt({ homeDir, sessionKey, contextPackId: pack.id })) {
+  const sessionKey2 = `team-${input.runId}-${input.role.roleId}`;
+  if (await hasContextInjectionReceipt({ homeDir, sessionKey: sessionKey2, contextPackId: pack.id })) {
     return null;
   }
   await writeContextInjectionReceipt({
     homeDir,
-    sessionKey,
+    sessionKey: sessionKey2,
     pack,
     trigger: "team-startup",
     hookEventId: null,
@@ -6934,7 +7214,7 @@ function recoveredHandle(input, window, paneId) {
 async function readSettingsOrDefault(homeDir) {
   const settingsPath = resolveEvoDevPaths(homeDir).settingsPath;
   try {
-    return parseSettings(JSON.parse(await readFile6(settingsPath, "utf8")));
+    return parseSettings(JSON.parse(await readFile7(settingsPath, "utf8")));
   } catch {
     return createDefaultSettings();
   }
@@ -7012,7 +7292,7 @@ async function assertReadableFile(path, label) {
 }
 async function writeTextFileIfMissing(path, content) {
   try {
-    await readFile6(path, "utf8");
+    await readFile7(path, "utf8");
     return false;
   } catch (error) {
     if (!isNotFoundError2(error)) {
@@ -7045,7 +7325,7 @@ async function readTeamAgentMarkdown(reference) {
     throw new Error(`Team agent file for ${reference.roleId} must be Markdown.`);
   }
   try {
-    return await readFile6(reference.sourcePath, "utf8");
+    return await readFile7(reference.sourcePath, "utf8");
   } catch (error) {
     if (isNotFoundError2(error)) {
       throw new Error(`Team agent file not found for ${reference.roleId}: ${reference.sourcePath}`);
@@ -7381,7 +7661,7 @@ function defaultRolePrompt(roleId) {
 }
 async function readRoleCandidate(path, source) {
   try {
-    const raw = await readFile6(path, "utf8");
+    const raw = await readFile7(path, "utf8");
     return { value: JSON.parse(raw), path, source };
   } catch (error) {
     if (isNotFoundError2(error))
@@ -7417,7 +7697,7 @@ function resolveTeamBindingWritePath(input) {
 }
 async function readTeamBindingConfig(path) {
   try {
-    const raw = await readFile6(path, "utf8");
+    const raw = await readFile7(path, "utf8");
     return parseTeamBindingConfig(JSON.parse(raw));
   } catch (error) {
     if (isNotFoundError2(error)) {
@@ -7494,7 +7774,7 @@ async function appendJsonLine2(path, value) {
 }
 async function readJsonLines(path, parse2) {
   try {
-    const text2 = await readFile6(path, "utf8");
+    const text2 = await readFile7(path, "utf8");
     return text2.split(`
 `).filter((line) => line.trim() !== "").map((line) => parse2(JSON.parse(line)));
   } catch (error) {
@@ -7821,8 +8101,20 @@ async function handleHookRuntime(input) {
   const evolutionDiagnostics = sessionMemoryDiagnostics.queuedSegmentTriggerId !== null || shouldSuppressLegacyEvolutionTrigger(input.event.type) ? { stateWrites: [], warnings: [] } : await recordEvolutionTriggerFromHook(input);
   const messageDiagnostics = await deliverPendingTeamMessagesFromHook(input, result);
   const scopedContextDiagnostics = await injectScopedKnowledgeContextFromHook(input, result);
+  const knowledgeOutcomeDiagnostics = await recordKnowledgeOutcomeFromHook(input);
   const teamStateDiagnostics = await recordTeamAgentHookStateFromHook(input);
-  const completed = appendRuntimeDiagnostics(appendRuntimeDiagnostics(appendRuntimeDiagnostics(appendRuntimeDiagnostics(appendRuntimeDiagnostics(appendRuntimeDiagnostics(appendRuntimeDiagnostics(result, diagnostics), projectDiagnostics), sessionMemoryDiagnostics), evolutionDiagnostics), messageDiagnostics), scopedContextDiagnostics), teamStateDiagnostics);
+  let completed = appendRuntimeDiagnostics(result, diagnostics);
+  for (const entry of [
+    projectDiagnostics,
+    sessionMemoryDiagnostics,
+    evolutionDiagnostics,
+    messageDiagnostics,
+    scopedContextDiagnostics,
+    knowledgeOutcomeDiagnostics,
+    teamStateDiagnostics
+  ]) {
+    completed = appendRuntimeDiagnostics(completed, entry);
+  }
   return appendDevelopmentHookDiagnostics(input, completed);
 }
 function formatHookRuntimeOutput(result) {
@@ -8009,7 +8301,9 @@ async function injectScopedKnowledgeContextFromHook(input, result) {
     environment: input.environment,
     payload: input.rawPayload
   });
-  if (team === null || team.roleId !== "main")
+  if (team === null)
+    return injectOrdinarySessionKnowledge(input, result);
+  if (team.roleId !== "main")
     return { stateWrites: [], warnings: [] };
   try {
     if (input.runtimeInjectionEnabled === false)
@@ -8021,17 +8315,17 @@ async function injectScopedKnowledgeContextFromHook(input, result) {
     });
     if (pack === null)
       return { stateWrites: [], warnings: [] };
-    const sessionKey = resolveHookSessionKey(input.rawPayload);
+    const sessionKey2 = resolveHookSessionKey(input.rawPayload);
     if (await hasContextInjectionReceipt({
       homeDir: input.homeDir,
-      sessionKey,
+      sessionKey: sessionKey2,
       contextPackId: pack.id
     })) {
       return { stateWrites: [], warnings: [] };
     }
     const receipt = await writeContextInjectionReceipt({
       homeDir: input.homeDir,
-      sessionKey,
+      sessionKey: sessionKey2,
       pack,
       trigger: "hook-safe-point",
       hookEventId: input.event.eventId,
@@ -8046,6 +8340,102 @@ async function injectScopedKnowledgeContextFromHook(input, result) {
     };
   }
 }
+async function injectOrdinarySessionKnowledge(input, result) {
+  if (input.event.type !== "UserPromptSubmit" || input.runtimeInjectionEnabled === false) {
+    return { stateWrites: [], warnings: [] };
+  }
+  const cwd = optionalPayloadString(input.rawPayload.cwd);
+  if (cwd === null)
+    return { stateWrites: [], warnings: [] };
+  const sessionKey2 = resolveHookSessionKey(input.rawPayload);
+  const paths2 = resolveHookRuntimeSessionPaths({ homeDir: input.homeDir, sessionKey: sessionKey2 });
+  const binding = await readSessionBinding(input.homeDir, input.rawPayload);
+  if (binding?.knowledgeContextDeliveredAt !== undefined && binding.knowledgeContextDeliveredAt !== null) {
+    return { stateWrites: [], warnings: [] };
+  }
+  try {
+    const workspace = await resolveProjectWorkspaceFromCwd({ homeDir: input.homeDir, cwd });
+    if (workspace === null)
+      return { stateWrites: [], warnings: [] };
+    const queryText = readKnowledgeQueryText(input.rawPayload);
+    const pack = await createScopedKnowledgeContextPack({
+      homeDir: input.homeDir,
+      projectKey: workspace.projectKey,
+      roleId: input.target,
+      ...queryText === null ? {} : { queryText },
+      limit: 3,
+      inlineOnly: true
+    });
+    const deliveredAt = input.receivedAt ?? new Date().toISOString();
+    const nextBinding = {
+      version: 1,
+      target: input.target,
+      sessionKey: sessionKey2,
+      cwd,
+      teamRuntimeContextDeliveredAt: binding?.teamRuntimeContextDeliveredAt ?? null,
+      knowledgeContextDeliveredAt: deliveredAt,
+      updatedAt: deliveredAt
+    };
+    await writeJsonFile2(paths2.bindingPath, nextBinding);
+    if (pack === null)
+      return { stateWrites: [paths2.bindingPath], warnings: [] };
+    const receipt = await writeContextInjectionReceipt({
+      homeDir: input.homeDir,
+      sessionKey: sessionKey2,
+      pack,
+      trigger: "ordinary-session",
+      hookEventId: input.event.eventId,
+      injectedAt: deliveredAt
+    });
+    result.output = appendAdditionalContext(result.output, input.event.type, formatScopedKnowledgePromptBlock(pack));
+    return { stateWrites: [paths2.bindingPath, receipt.path], warnings: [] };
+  } catch {
+    return {
+      stateWrites: [],
+      warnings: ["Ordinary-session knowledge context could not be injected."]
+    };
+  }
+}
+function readKnowledgeQueryText(payload) {
+  for (const value of [
+    payload.prompt,
+    payload.user_prompt,
+    payload.userPrompt,
+    payload.query,
+    payload.message,
+    payload.text
+  ]) {
+    if (typeof value === "string" && value.trim() !== "")
+      return value.trim().slice(0, 4000);
+  }
+  return null;
+}
+async function recordKnowledgeOutcomeFromHook(input) {
+  if (!isKnowledgeOutcomeSignal(input.event))
+    return { stateWrites: [], warnings: [] };
+  try {
+    const paths2 = await recordContextInjectionOutcome({
+      homeDir: input.homeDir,
+      sessionKey: resolveHookSessionKey(input.rawPayload),
+      eventId: input.event.eventId,
+      observedAt: input.receivedAt ?? input.event.time.receivedAt ?? new Date().toISOString(),
+      summary: input.event.payload.summary
+    });
+    return { stateWrites: paths2, warnings: [] };
+  } catch {
+    return {
+      stateWrites: [],
+      warnings: ["Knowledge delivery outcome metadata could not be recorded."]
+    };
+  }
+}
+function isKnowledgeOutcomeSignal(event) {
+  if (event.type !== "PostToolUse")
+    return false;
+  if (event.payload.metadata.commandClass === "test-command")
+    return true;
+  return /\b(?:test|lint|typecheck|build|verify|check)\b/iu.test(event.payload.summary);
+}
 function canDeliverTeamMessagesFromHook(target, eventType) {
   if (!TEAM_MESSAGE_DELIVERY_EVENTS.has(eventType))
     return false;
@@ -8093,17 +8483,18 @@ async function handleSessionStart(input) {
   });
 }
 async function handleUserPromptSubmit(input) {
-  const sessionKey = resolveHookSessionKey(input.rawPayload);
-  const paths2 = resolveHookRuntimeSessionPaths({ homeDir: input.homeDir, sessionKey });
+  const sessionKey2 = resolveHookSessionKey(input.rawPayload);
+  const paths2 = resolveHookRuntimeSessionPaths({ homeDir: input.homeDir, sessionKey: sessionKey2 });
   const previousBinding = await readSessionBinding(input.homeDir, input.rawPayload);
   const teamRuntimeContext = previousBinding?.teamRuntimeContextDeliveredAt === undefined || previousBinding.teamRuntimeContextDeliveredAt === null ? await createTeamRuntimeContextForUserPrompt(input) : null;
   const teamRuntimeContextDeliveredAt = teamRuntimeContext !== null ? input.receivedAt ?? new Date().toISOString() : previousBinding?.teamRuntimeContextDeliveredAt ?? null;
   const binding = {
     version: 1,
     target: input.target,
-    sessionKey,
+    sessionKey: sessionKey2,
     cwd: optionalPayloadString(input.rawPayload.cwd),
     teamRuntimeContextDeliveredAt,
+    knowledgeContextDeliveredAt: previousBinding?.knowledgeContextDeliveredAt ?? null,
     updatedAt: input.receivedAt ?? new Date().toISOString()
   };
   await writeJsonFile2(paths2.bindingPath, binding);
@@ -8261,10 +8652,10 @@ function truncateTeamMessageBody(value) {
   return `${value.slice(0, 4000)}...[truncated:${value.length - 4000}]`;
 }
 async function readSessionBinding(homeDir, payload) {
-  const sessionKey = resolveHookSessionKey(payload);
-  const paths2 = resolveHookRuntimeSessionPaths({ homeDir, sessionKey });
+  const sessionKey2 = resolveHookSessionKey(payload);
+  const paths2 = resolveHookRuntimeSessionPaths({ homeDir, sessionKey: sessionKey2 });
   try {
-    return JSON.parse(await readFile7(paths2.bindingPath, "utf8"));
+    return JSON.parse(await readFile8(paths2.bindingPath, "utf8"));
   } catch (error) {
     if (isNotFoundError3(error))
       return null;
@@ -8539,7 +8930,7 @@ function mergeSettings(existing, defaults = createDefaultSettings()) {
 async function readRuntimeInjectionSettings(homeDir) {
   const paths2 = resolveEvoDevPaths(homeDir);
   try {
-    return parseSettings(JSON.parse(await readFile8(paths2.settingsPath, "utf8"))).memory;
+    return parseSettings(JSON.parse(await readFile9(paths2.settingsPath, "utf8"))).memory;
   } catch (error) {
     if (isNotFoundError4(error))
       return createDefaultMemorySettings();
@@ -8692,7 +9083,7 @@ import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypt
 import {
   appendFile as appendFile4,
   mkdir as mkdir7,
-  readFile as readFile9,
+  readFile as readFile10,
   readdir as readdir7,
   rename as rename2,
   rm as rm3,
@@ -8790,7 +9181,7 @@ async function listOkfKnowledgeChangeCandidates(input) {
   for (const projectKey of projectKeys) {
     const paths2 = resolveKnowledgeChangePaths(input.homeDir, projectKey);
     for (const name of await listJsonFileNames(paths2.candidatesDir)) {
-      const value = JSON.parse(await readFile9(join12(paths2.candidatesDir, name), "utf8"));
+      const value = JSON.parse(await readFile10(join12(paths2.candidatesDir, name), "utf8"));
       const change = parseOkfKnowledgeChangeCandidate(value);
       if (input.state === undefined || change.state === input.state)
         changes.push(change);
@@ -8806,7 +9197,7 @@ async function readOkfKnowledgeChangeCandidate(input) {
   if (input.projectKey !== undefined) {
     const paths3 = resolveKnowledgeChangePaths(input.homeDir, input.projectKey);
     const path = join12(paths3.candidatesDir, `${changeId}.json`);
-    const change2 = parseOkfKnowledgeChangeCandidate(JSON.parse(await readFile9(path, "utf8")));
+    const change2 = parseOkfKnowledgeChangeCandidate(JSON.parse(await readFile10(path, "utf8")));
     return { path, change: change2 };
   }
   const matches = await listOkfKnowledgeChangeCandidates({ homeDir: input.homeDir });
@@ -8827,7 +9218,7 @@ async function replaceOkfKnowledgeChangeCandidate(input) {
   }
   const paths2 = resolveKnowledgeChangePaths(input.homeDir, input.next.projectKey);
   const path = join12(paths2.candidatesDir, `${input.next.id}.json`);
-  const current = parseOkfKnowledgeChangeCandidate(JSON.parse(await readFile9(path, "utf8")));
+  const current = parseOkfKnowledgeChangeCandidate(JSON.parse(await readFile10(path, "utf8")));
   if (current.state !== input.previous.state || current.updatedAt !== input.previous.updatedAt || current.candidate.revision !== input.previous.candidate.revision) {
     throw new Error("Knowledge change was modified by another decision.");
   }
@@ -8936,7 +9327,7 @@ function resolveKnowledgeChangePaths(homeDir, projectKey) {
 }
 async function readKnowledgeChangeLockToken(path) {
   try {
-    const value = JSON.parse(await readFile9(path, "utf8"));
+    const value = JSON.parse(await readFile10(path, "utf8"));
     return isRecord6(value) && typeof value.token === "string" ? value.token : null;
   } catch {
     return null;
@@ -8967,7 +9358,7 @@ async function recoverStaleKnowledgeChangeLock(path) {
 }
 async function readKnowledgeChangeLockOwner(path) {
   try {
-    const value = JSON.parse(await readFile9(path, "utf8"));
+    const value = JSON.parse(await readFile10(path, "utf8"));
     if (!isRecord6(value))
       return null;
     return {
@@ -9092,6 +9483,7 @@ function createOkfKnowledgeRuntimeProjectionFromCandidate(candidate) {
       pathScopes: candidate.pathScopes
     },
     relatedConceptLinks: candidate.relatedConceptLinks,
+    supportRef: candidate.supportRef ?? null,
     lifecycle: {
       status: candidate.decision === "revoke" ? "revoked" : "active",
       supersedes: [],
@@ -9125,6 +9517,7 @@ function createOkfKnowledgeRuntimeProjectionFromConcept(concept) {
       pathScopes: concept.pathScopes
     },
     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,
@@ -9290,6 +9683,7 @@ function normalizeRuntimeProjection(value) {
       pathScopes: normalizeArray(value.scopes.pathScopes)
     },
     relatedConceptLinks: normalizeArray(value.relatedConceptLinks),
+    supportRef: value.supportRef,
     lifecycle: {
       status: value.lifecycle.status,
       supersedes: normalizeArray(value.lifecycle.supersedes),
@@ -9317,6 +9711,7 @@ function listChangedProjectionFields(base, candidate) {
     ["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.filter(([, left, right]) => stableJsonStringify(left) !== stableJsonStringify(right)).map(([field]) => field);
@@ -9383,36 +9778,103 @@ function stableJsonStringify(value) {
   return `{${entries.map(([key, child]) => `${JSON.stringify(key)}:${stableJsonStringify(child)}`).join(",")}}`;
 }
 
-// packages/core/src/evolution/knowledge/freshness.ts
-function deriveOkfKnowledgeFreshness(input) {
+// packages/core/src/evolution/knowledge/support.ts
+function resolveOkfKnowledgeRuntimeEligibility(input) {
   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)) {
+  if (input.verifiedContradiction === true || input.lifecycle.status === "stale" || input.lifecycle.status === "deprecated" || input.lifecycle.status === "revoked" || input.lifecycle.status === "superseded" || input.reviewState === "stale" || input.reviewState === "deprecated" || input.reviewState === "revoked" || input.reviewState === "superseded" || isDue(input.lifecycle.staleAfter, now)) {
     return {
+      delivery: "blocked",
       freshness: "stale",
-      reason: input.verifiedContradiction === true ? "Verified evidence contradicts the active claim." : "Lifecycle status or staleAfter excludes this concept from new runtime context."
+      reason: input.verifiedContradiction === true ? "Verified evidence contradicts the active claim." : "Lifecycle state excludes this knowledge from runtime context."
     };
   }
-  if (concept.verificationSnapshot === null) {
+  if (input.reviewState !== "accepted" && input.reviewState !== "auto-accepted") {
     return {
+      delivery: "blocked",
       freshness: "unknown",
-      reason: "No verifiable knowledge snapshot is stored for this legacy concept."
+      reason: "Knowledge has not passed an active-compatible review state."
     };
   }
-  if (input.repositoryFingerprintChanged === true || isDue(concept.lifecycle.reviewAfter, now)) {
+  if (input.sourceStatus === "changed") {
     return {
+      delivery: "blocked",
       freshness: "review-due",
-      reason: input.repositoryFingerprintChanged === true ? "A checked repository path changed after the last verification." : `Review was due at ${concept.lifecycle.reviewAfter}.`
+      reason: "The supporting source changed and requires revalidation."
+    };
+  }
+  if (isDue(input.lifecycle.reviewAfter, now)) {
+    return {
+      delivery: "reference",
+      freshness: "review-due",
+      reason: `Review was due at ${input.lifecycle.reviewAfter}.`
+    };
+  }
+  if (input.supportRef === null) {
+    return {
+      delivery: "reference",
+      freshness: "unknown",
+      reason: "Legacy knowledge has no structured support reference."
+    };
+  }
+  if (input.supportRef.kind === "semantic-inference") {
+    if (input.reviewState === "accepted") {
+      return {
+        delivery: "inline",
+        freshness: "verified",
+        reason: "A human-accepted inference is runtime-eligible as an explicit decision."
+      };
+    }
+    return {
+      delivery: "reference",
+      freshness: "unknown",
+      reason: "Model-inferred knowledge remains on-demand until supported by a direct source."
+    };
+  }
+  if ((input.supportRef.kind === "repo-policy" || input.supportRef.kind === "state-observation") && input.sourceStatus !== "current") {
+    return {
+      delivery: "reference",
+      freshness: "unknown",
+      reason: "The supporting repository source has not been revalidated for this query."
     };
   }
   return {
+    delivery: "inline",
     freshness: "verified",
-    reason: `Verified at ${concept.verificationSnapshot.verifiedAt}.`
+    reason: `Runtime-eligible through ${input.supportRef.kind}.`
+  };
+}
+function isDirectKnowledgeSupport(supportRef) {
+  return supportRef !== undefined && supportRef !== null && supportRef.kind !== "semantic-inference";
+}
+function normalizeNow(value) {
+  if (value instanceof Date && Number.isFinite(value.getTime()))
+    return value;
+  if (typeof value === "string" && Number.isFinite(Date.parse(value)))
+    return new Date(value);
+  return new Date;
+}
+function isDue(value, now) {
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) && timestamp <= now.getTime();
+}
+
+// packages/core/src/evolution/knowledge/freshness.ts
+function deriveOkfKnowledgeFreshness(input) {
+  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: eligibility.freshness,
+    reason: eligibility.reason
   };
 }
 function createOkfKnowledgeVerificationSnapshot(input) {
-  const hasVerification = input.candidate.bodySections.verification.length > 0 || input.candidate.verificationNotApplicableReason !== undefined;
-  if (!hasVerification)
+  if (!isDirectKnowledgeSupport(input.candidate.supportRef))
     return null;
   const verifiedAt = normalizeIso(input.verifiedAt);
   if (verifiedAt === null)
@@ -9424,20 +9886,6 @@ function createOkfKnowledgeVerificationSnapshot(input) {
     repository: null
   };
 }
-function normalizeNow(value) {
-  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, now) {
-  const normalized = normalizeIso(value);
-  return normalized !== null && Date.parse(normalized) <= now.getTime();
-}
 function normalizeIso(value) {
   const time2 = Date.parse(value);
   return Number.isFinite(time2) ? new Date(time2).toISOString() : null;
@@ -9813,6 +10261,7 @@ function normalizePlanCandidate(value, path) {
     scores: normalizeScores(input.scores, `${path}.scores`),
     decisionReason: sanitizeOkfText(readRequiredString(input.decisionReason, `${path}.decisionReason`)),
     evidenceRefs: readStringArray(input.evidenceRefs, `${path}.evidenceRefs`).map(sanitizeOkfText),
+    supportRef: input.supportRef === undefined ? undefined : normalizeKnowledgeSupportRef(input.supportRef, `${path}.supportRef`),
     reviewState: parseOkfReviewState(readRequiredString(input.reviewState, `${path}.reviewState`)),
     verificationNotApplicableReason: typeof input.verificationNotApplicableReason === "string" ? sanitizeOkfText(input.verificationNotApplicableReason) : undefined,
     evalSetRefs: input.evalSetRefs === undefined ? undefined : readStringArray(input.evalSetRefs, `${path}.evalSetRefs`).map(sanitizeOkfText),
@@ -9872,6 +10321,7 @@ function validateCandidateContract(candidate, path, evalSetIds, add, options) {
   validateStringArrayValue(candidate.pathScopes, `${path}.pathScopes`, add);
   validateStringArrayValue(candidate.relatedConceptLinks, `${path}.relatedConceptLinks`, add);
   validateStringArrayValue(candidate.evidenceRefs, `${path}.evidenceRefs`, add);
+  validateKnowledgeSupportRefValue(candidate.supportRef, `${path}.supportRef`, add);
   validateOverlayUpdatesValue(candidate.overlayUpdates, `${path}.overlayUpdates`, add);
   validateScoresValue(candidate.scores, `${path}.scores`, add);
   validatePrivacyCheckValue(candidate.privacyCheck, `${path}.privacyCheck`, add);
@@ -10086,6 +10536,24 @@ function normalizeBasis(value) {
     throw new Error("Candidate basis is invalid.");
   return value;
 }
+function normalizeKnowledgeSupportRef(value, path) {
+  const input = assertRecordValue(value, path);
+  const kind = readRequiredString(input.kind, `${path}.kind`);
+  if (kind !== "user-declaration" && kind !== "repo-policy" && kind !== "state-observation" && kind !== "verified-outcome" && kind !== "semantic-inference") {
+    throw new Error(`${path}.kind is invalid.`);
+  }
+  const observedAt = readRequiredString(input.observedAt, `${path}.observedAt`);
+  if (!Number.isFinite(Date.parse(observedAt)))
+    throw new Error(`${path}.observedAt is invalid.`);
+  const subjectFingerprint = input.subjectFingerprint === null ? null : sanitizeOkfText(readRequiredString(input.subjectFingerprint, `${path}.subjectFingerprint`));
+  return {
+    id: sanitizeOkfText(readRequiredString(input.id, `${path}.id`)),
+    kind,
+    sourceRefId: sanitizeOkfText(readRequiredString(input.sourceRefId, `${path}.sourceRefId`)),
+    subjectFingerprint,
+    observedAt: new Date(observedAt).toISOString()
+  };
+}
 function normalizeEvalSetDecision(value) {
   const normalized = value === "no-write" ? "no_write" : value;
   if (normalized !== "create" && normalized !== "needs-human" && normalized !== "no_write" && normalized !== "skip") {
@@ -10208,6 +10676,28 @@ function validateStringArrayValue(value, path, add) {
       add(`${path}[${index}]`, "array.string", "Array items must be non-empty strings.");
   });
 }
+function validateKnowledgeSupportRefValue(value, path, add) {
+  if (value === undefined)
+    return;
+  if (!isRecord7(value)) {
+    add(path, "supportRef.object", "Candidate supportRef must be an object.");
+    return;
+  }
+  if (!isNonEmptyString2(value.id))
+    add(`${path}.id`, "supportRef.id", "supportRef id is required.");
+  if (value.kind !== "user-declaration" && value.kind !== "repo-policy" && value.kind !== "state-observation" && value.kind !== "verified-outcome" && value.kind !== "semantic-inference") {
+    add(`${path}.kind`, "supportRef.kind", "supportRef kind is invalid.");
+  }
+  if (!isNonEmptyString2(value.sourceRefId)) {
+    add(`${path}.sourceRefId`, "supportRef.sourceRefId", "supportRef sourceRefId is required.");
+  }
+  if (value.subjectFingerprint !== null && !isNonEmptyString2(value.subjectFingerprint)) {
+    add(`${path}.subjectFingerprint`, "supportRef.subjectFingerprint", "supportRef subjectFingerprint must be null or a non-empty string.");
+  }
+  if (!isNonEmptyString2(value.observedAt) || !Number.isFinite(Date.parse(value.observedAt))) {
+    add(`${path}.observedAt`, "supportRef.observedAt", "supportRef observedAt must be an ISO timestamp.");
+  }
+}
 function validateOverlayUpdatesValue(value, path, add) {
   if (!Array.isArray(value)) {
     add(path, "overlayUpdates.array", "Overlay updates must be an array.");
@@ -10411,7 +10901,7 @@ function decideOkfKnowledgeCandidate(candidate, context) {
   const localActiveTarget = sanitized.targetStore === "okf" || sanitized.kind === "evos-case";
   const hasScopeTags = sanitized.repoTags.length > 0 && sanitized.roleTags.length > 0;
   const highRiskRequiresHuman = hasHighRiskHumanReviewSignal(candidate) || hasHighRiskHumanReviewSignal(sanitized);
-  const autoAcceptEligible = !highRiskRequiresHuman && !isLegacyTemplateKnowledge(sanitized) && !hasEphemeralKnowledgeIdentity(sanitized) && hasReusableSemanticShape(sanitized) && conflict === null && localActiveTarget && sanitized.targetStore === "okf" && sanitized.basis === "direct" && sanitized.metadataOnlyEvidence && hasVerification && hasScopeTags && scores.evidenceStrength >= 4 && scores.reuseValue >= 3 && scores.actionability >= 3 && scores.stability >= 3 && scores.privacyRisk <= 2 && scores.duplicationRisk <= 2;
+  const autoAcceptEligible = !highRiskRequiresHuman && !isLegacyTemplateKnowledge(sanitized) && !hasEphemeralKnowledgeIdentity(sanitized) && hasReusableSemanticShape(sanitized) && conflict === null && localActiveTarget && sanitized.targetStore === "okf" && sanitized.basis === "direct" && isDirectKnowledgeSupport(sanitized.supportRef) && sanitized.metadataOnlyEvidence && hasVerification && hasScopeTags && scores.evidenceStrength >= 4 && scores.reuseValue >= 3 && scores.actionability >= 3 && scores.stability >= 3 && scores.privacyRisk <= 2 && scores.duplicationRisk <= 2;
   if (autoAcceptEligible) {
     return {
       ...sanitized,
@@ -10738,7 +11228,7 @@ async function preflightOkfConceptTargets(okfDir, candidates) {
       targets.set(targetPath, { action: "write", candidateId: candidate.id });
       continue;
     }
-    const existing = parseOkfConceptFile(okfDir, targetPath, await readFile10(targetPath, "utf8"));
+    const existing = parseOkfConceptFile(okfDir, targetPath, await readFile11(targetPath, "utf8"));
     if (existing === null) {
       throw new Error(`OKF concept target is occupied by an unrecognized file: ${candidate.targetPath}`);
     }
@@ -10789,7 +11279,7 @@ async function writeFailedOkfKnowledgePlanArtifact(input) {
 }
 async function readFailedOkfKnowledgePlanArtifact(input) {
   const path = resolveFailedPlanPath(input.homeDir, input.projectKey, input.runId);
-  const value = JSON.parse(await readFile10(path, "utf8"));
+  const value = JSON.parse(await readFile11(path, "utf8"));
   if (isRecord7(value) && value.kind === "okf-knowledge-failed-plan") {
     const artifact = value;
     validateFailedPlanArtifact(artifact);
@@ -10975,7 +11465,7 @@ async function listOkfKnowledgeConcepts(input) {
   for (const file of files) {
     if (RESERVED_OKF_FILENAMES.has(file.name))
       continue;
-    const content = await readFile10(file.path, "utf8");
+    const content = await readFile11(file.path, "utf8");
     const parsed = parseOkfConceptFile(okfDir, file.path, content);
     if (parsed !== null)
       concepts.push(parsed);
@@ -11014,7 +11504,7 @@ async function queryOkfKnowledge(input) {
   for (const file of files) {
     if (RESERVED_OKF_FILENAMES.has(file.name))
       continue;
-    const content = await readFile10(file.path, "utf8");
+    const content = await readFile11(file.path, "utf8");
     const sourceLink = toOkfLink(okfDir, file.path);
     if (isUnsafeOkfQueryContent(content)) {
       warnings.push(`Omitted unsafe OKF knowledge item: ${sourceLink}. Run evodev knowledge lint.`);
@@ -11291,8 +11781,8 @@ function mergeAcceptedEvosCasesIntoKnowledgeQuery(result, cases, warnings = [],
         score: structuredScore + lexical.score,
         title: evosCase.title,
         summary: evosCase.expectedFutureBehavior || evosCase.result.summary || evosCase.title,
-        freshness: "verified",
-        runtimeExcerpt: sanitizeOkfText(evosCase.expectedFutureBehavior || evosCase.result.summary || evosCase.title).slice(0, 1200),
+        freshness: "unknown",
+        runtimeExcerpt: null,
         matchReasons: lexical.reasons.length === 0 ? structuredReasons : [...structuredReasons, ...lexical.reasons]
       }
     ];
@@ -11305,8 +11795,12 @@ function mergeAcceptedEvosCasesIntoKnowledgeQuery(result, cases, warnings = [],
   };
 }
 async function createScopedKnowledgeContextPack(input) {
-  const result = await queryScopedOkfKnowledgeContext(input);
-  if (result.items.length === 0)
+  const result = await queryScopedOkfKnowledgeContext({
+    ...input,
+    limit: input.inlineOnly === true ? Math.max(input.limit ?? 3, 50) : input.limit
+  });
+  const selectedItems = input.inlineOnly === true ? result.items.filter((item) => item.runtimeExcerpt !== null).slice(0, input.limit ?? 3) : result.items;
+  if (selectedItems.length === 0)
     return null;
   const scope = {
     ...result.projectKey === undefined ? {} : { projectKey: result.projectKey },
@@ -11314,7 +11808,7 @@ async function createScopedKnowledgeContextPack(input) {
     ...result.workflowId === undefined ? {} : { workflowId: result.workflowId },
     paths: result.paths
   };
-  const items = result.items.map((item) => ({
+  const items = selectedItems.map((item) => ({
     id: item.id,
     sourceType: item.sourceType,
     sourceLink: item.sourceLink,
@@ -11331,10 +11825,11 @@ async function createScopedKnowledgeContextPack(input) {
   }));
   const okfIndexRevision = createKnowledgeContextRevision(items);
   const queryText = normalizeKnowledgeQueryText(result.queryText);
+  const queryHash = queryText === undefined ? undefined : sha256Short2(queryText);
   const packSeed = stableJsonStringify2({
     okfIndexRevision,
     scope,
-    queryText: queryText ?? null,
+    queryHash: queryHash ?? null,
     items: items.map((item) => ({
       id: item.id,
       sourceType: item.sourceType,
@@ -11352,7 +11847,7 @@ async function createScopedKnowledgeContextPack(input) {
     id: `ctxpack-${sha256Short2(packSeed)}`,
     okfIndexRevision,
     scope,
-    ...queryText === undefined ? {} : { queryText },
+    ...queryHash === undefined ? {} : { queryHash },
     items,
     warnings: result.warnings.length === 0 ? [] : [
       "Some scoped knowledge items were omitted because they failed safety validation; run evodev knowledge lint."
@@ -11367,7 +11862,6 @@ function formatScopedKnowledgePromptBlock(pack) {
     `Project: ${pack.scope.projectKey ?? "all"}`,
     `Role: ${pack.scope.roleId ?? "any"}`,
     `Workflow: ${pack.scope.workflowId ?? "any"}`,
-    ...pack.queryText === undefined ? [] : [`Query: ${sanitizeOkfText(pack.queryText)}`],
     `Paths: ${pack.scope.paths.length === 0 ? "all" : pack.scope.paths.join(", ")}`,
     "Raw content stored: false",
     "Freshness is determined by EvoDev lifecycle and verification metadata; do not infer validity from timestamps.",
@@ -11405,9 +11899,11 @@ async function writeContextInjectionReceipt(input) {
     okfIndexRevision: input.pack.okfIndexRevision,
     scope: input.pack.scope,
     itemIds: input.pack.items.map((item) => item.id),
+    queryHash: input.pack.queryHash ?? null,
     injectedAt: input.injectedAt ?? new Date().toISOString(),
     hookEventId: input.hookEventId ?? null,
     trigger: input.trigger,
+    outcome: null,
     rawContentStored: false
   };
   const path = resolveContextInjectionReceiptPath({
@@ -11418,6 +11914,42 @@ async function writeContextInjectionReceipt(input) {
   await writeJson3(path, receipt, { overwrite: true });
   return { path, receipt };
 }
+async function recordContextInjectionOutcome(input) {
+  const stateDir = resolveEvoDevPaths(input.homeDir).stateDir;
+  const directory = join13(stateDir, "context-injections", sanitizeReceiptPathSegment(input.sessionKey));
+  let names;
+  try {
+    names = await readdir8(directory);
+  } catch {
+    return [];
+  }
+  const paths2 = [];
+  for (const name of names.filter((item) => item.endsWith(".json")).sort()) {
+    const path = join13(directory, name);
+    let receipt;
+    try {
+      receipt = JSON.parse(await readFile11(path, "utf8"));
+    } catch {
+      continue;
+    }
+    if (receipt.version !== 1 || receipt.rawContentStored !== false || receipt.outcome !== null && receipt.outcome !== undefined) {
+      continue;
+    }
+    const updated = {
+      ...receipt,
+      outcome: {
+        status: "verified",
+        eventId: sanitizeReceiptPathSegment(input.eventId),
+        observedAt: normalizeTimestamp(input.observedAt),
+        summaryHash: sha256Short2(input.summary),
+        rawContentStored: false
+      }
+    };
+    await writeJson3(path, updated, { overwrite: true });
+    paths2.push(path);
+  }
+  return paths2;
+}
 async function markOkfKnowledgeConceptStale(input) {
   const target = await readMutableOkfConcept(input.homeDir, input.conceptId);
   const lifecycle = {
@@ -11514,7 +12046,7 @@ async function readMutableOkfConcept(homeDir, conceptId) {
   for (const file of files) {
     if (RESERVED_OKF_FILENAMES.has(file.name))
       continue;
-    const content = await readFile10(file.path, "utf8");
+    const content = await readFile11(file.path, "utf8");
     const concept = parseOkfConceptFile(paths2.okfDir, file.path, content);
     if (concept === null)
       continue;
@@ -11626,7 +12158,7 @@ async function lintOkfKnowledge(input) {
   const knownConceptIds = new Set(files.filter((file) => !RESERVED_OKF_FILENAMES.has(file.name)).map((file) => toOkfRelativePath(paths2.okfDir, file.path).replace(/\.md$/, "")));
   for (const file of files) {
     const rel = displayOkfPath(paths2.okfDir, file.path);
-    const content = await readFile10(file.path, "utf8");
+    const content = await readFile11(file.path, "utf8");
     if (file.name === "index.md") {
       if (file.path !== join13(paths2.okfDir, "index.md") && hasFrontmatter(content)) {
         errors2.push(`Non-root index.md must not have frontmatter: ${rel}`);
@@ -11972,6 +12504,9 @@ function explainAutomaticNoWriteDecision(candidate, scores, hasVerification, has
     reasons.push("target is not user-local OKF");
   if (candidate.basis !== "direct")
     reasons.push("basis is inferred");
+  if (!isDirectKnowledgeSupport(candidate.supportRef)) {
+    reasons.push("structured direct support is missing");
+  }
   if (!candidate.metadataOnlyEvidence)
     reasons.push("evidence is not metadata-only");
   if (!hasVerification)
@@ -12115,7 +12650,7 @@ async function ensureOverlayConcept(input) {
   const exists = await pathExists3(input.overlayPath);
   const linkLine = `- [${input.candidate.title}](${input.link}) - ${input.candidate.description}`;
   if (exists) {
-    const current = await readFile10(input.overlayPath, "utf8");
+    const current = await readFile11(input.overlayPath, "utf8");
     if (current.includes(input.link))
       return;
     await writeFile7(input.overlayPath, `${current.trimEnd()}
@@ -12222,6 +12757,7 @@ function renderOkfConcept(candidate, plan, existing) {
     `  stableKey: ${yamlString(candidate.stableKey)}`,
     `  reviewState: ${yamlString(reviewState)}`,
     renderLifecycleYaml("  ", lifecycle),
+    renderKnowledgeSupportRefYaml("  ", candidate.supportRef ?? null),
     renderVerificationSnapshotYaml("  ", verificationSnapshot),
     "  source:",
     `    kind: ${yamlString("trace-distillation")}`,
@@ -12339,7 +12875,7 @@ async function regenerateOkfDirectoryIndexes(okfDir) {
         continue;
       }
       const filePath = join13(directory, entry.name);
-      const concept = parseOkfConceptFile(okfDir, filePath, await readFile10(filePath, "utf8"));
+      const concept = parseOkfConceptFile(okfDir, filePath, await readFile11(filePath, "utf8"));
       if (concept !== null && !isActiveOkfConcept(concept))
         continue;
       const title = concept?.title ?? titleFromSlug(entry.name.replace(/\.md$/, ""));
@@ -12395,7 +12931,7 @@ async function appendOkfLog(okfDir, entry) {
 async function prependLogEntry(logPath, entry) {
   await mkdir8(dirname9(logPath), { recursive: true });
   const date = todayIsoDate();
-  const existing = await pathExists3(logPath) ? await readFile10(logPath, "utf8") : `# Directory Update Log
+  const existing = await pathExists3(logPath) ? await readFile11(logPath, "utf8") : `# Directory Update Log
 `;
   const line = `* ${entry}`;
   if (existing.includes(`## ${date}`)) {
@@ -12445,6 +12981,7 @@ function parseOkfConceptFile(okfDir, filePath, content) {
     lifecycle: lifecycleParsed.lifecycle,
     lifecyclePersisted: lifecycleParsed.persisted,
     verificationSnapshot: parseOkfVerificationSnapshot(frontmatter),
+    supportRef: parseOkfKnowledgeSupportRef(frontmatter),
     title,
     description,
     tags,
@@ -12455,6 +12992,22 @@ function parseOkfConceptFile(okfDir, filePath, content) {
     body: parsed.body
   };
 }
+function parseOkfKnowledgeSupportRef(frontmatter) {
+  const block = extractNestedYamlBlock(frontmatter, "evodev", "supportRef");
+  if (block === null)
+    return null;
+  try {
+    return normalizeKnowledgeSupportRef({
+      id: readIndentedYamlScalar(block, "id"),
+      kind: readIndentedYamlScalar(block, "kind"),
+      sourceRefId: readIndentedYamlScalar(block, "sourceRefId"),
+      subjectFingerprint: readNullableLifecycleString(readIndentedYamlScalar(block, "subjectFingerprint")),
+      observedAt: readIndentedYamlScalar(block, "observedAt")
+    }, "evodev.supportRef");
+  } catch {
+    return null;
+  }
+}
 function parseOkfVerificationSnapshot(frontmatter) {
   const block = extractNestedYamlBlock(frontmatter, "evodev", "verificationSnapshot");
   if (block === null)
@@ -13028,6 +13581,19 @@ function renderVerificationSnapshotYaml(indent, snapshot) {
   ].join(`
 `);
 }
+function renderKnowledgeSupportRefYaml(indent, supportRef) {
+  if (supportRef === null)
+    return `${indent}supportRef: null`;
+  return [
+    `${indent}supportRef:`,
+    `${indent}  id: ${yamlString(supportRef.id)}`,
+    `${indent}  kind: ${yamlString(supportRef.kind)}`,
+    `${indent}  sourceRefId: ${yamlString(supportRef.sourceRefId)}`,
+    `${indent}  subjectFingerprint: ${yamlNullableString(supportRef.subjectFingerprint)}`,
+    `${indent}  observedAt: ${yamlString(supportRef.observedAt)}`
+  ].join(`
+`);
+}
 function lifecycleStatusFromReviewState(reviewState) {
   if (reviewState === "stale")
     return "stale";
@@ -13193,7 +13759,7 @@ async function createLegacyGeneratedKnowledgeCleanupPlan(homeDir, generatedAt) {
   for (const file of await listMarkdownFiles(conceptRoot)) {
     if (RESERVED_OKF_FILENAMES.has(file.name))
       continue;
-    const content = await readFile10(file.path, "utf8");
+    const content = await readFile11(file.path, "utf8");
     if (!isLegacyGeneratedOkfConcept(file.name, content))
       continue;
     concepts.push(createLegacyCleanupArtifact({
@@ -13206,7 +13772,7 @@ async function createLegacyGeneratedKnowledgeCleanupPlan(homeDir, generatedAt) {
   }
   const evosCases = [];
   for (const file of await listJsonFiles2(evoDevPaths.evosCasesDir)) {
-    const content = await readFile10(file.path, "utf8");
+    const content = await readFile11(file.path, "utf8");
     if (!isLegacyGeneratedEvosCase(content))
       continue;
     evosCases.push(createLegacyCleanupArtifact({
@@ -13227,7 +13793,7 @@ async function createLegacyGeneratedKnowledgeCleanupPlan(homeDir, generatedAt) {
     for (const file of await listMarkdownFiles(join13(okfPaths.okfDir, root))) {
       if (RESERVED_OKF_FILENAMES.has(file.name))
         continue;
-      const content = await readFile10(file.path, "utf8");
+      const content = await readFile11(file.path, "utf8");
       const cleanedContent = removeLegacyOverlayLinks(content, conceptLinks);
       if (cleanedContent === content)
         continue;
@@ -13551,7 +14117,7 @@ function parseAgentProfile(value) {
   return { ...profile, permissions };
 }
 async function readAgentProfile(path) {
-  return parseAgentProfile(JSON.parse(await readFile11(path, "utf8")));
+  return parseAgentProfile(JSON.parse(await readFile12(path, "utf8")));
 }
 function loadAgentContextDryRun(profile) {
   const parsed = parseAgentProfile(profile);
@@ -13776,7 +14342,7 @@ function expectRelativePath(value, path) {
   return text2;
 }
 // packages/core/src/assets/scanner.ts
-import { readFile as readFile12, readdir as readdir9, stat as stat6 } from "node:fs/promises";
+import { readFile as readFile13, readdir as readdir9, stat as stat6 } from "node:fs/promises";
 import { join as join14, relative as relative5 } from "node:path";
 async function scanAssets(paths2) {
   const [skills, agents] = await Promise.all([
@@ -13833,7 +14399,7 @@ async function readScannedAsset(rootDir, manifestPath, parseManifest) {
 async function readManifestJson(manifestPath) {
   let raw;
   try {
-    raw = await readFile12(manifestPath, "utf8");
+    raw = await readFile13(manifestPath, "utf8");
   } catch (error) {
     throw new EvoDevAssetError(`Cannot read manifest (${describeFileError(error)})`, manifestPath);
   }
@@ -13902,7 +14468,7 @@ __export(exports_code_agent_traces, {
   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 { mkdir as mkdir9, readFile as readFile14, 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";
 var CODE_AGENT_TRACE_TARGETS = ["claude", "codex"];
 var CODE_AGENT_TRACE_REF_SOURCES = [
@@ -13922,7 +14488,7 @@ function resolveCodeAgentTraceRefPaths(homeDir) {
   };
 }
 function createCodeAgentTraceRef(input) {
-  const sessionKey = sanitizePersistentIdentifier2(input.sessionKey, "session");
+  const sessionKey2 = sanitizePersistentIdentifier2(input.sessionKey, "session");
   const nativeSessionId = input.nativeSessionId ?? null;
   const nativeSessionIdHash = input.nativeSessionIdHash === undefined ? hashOptionalIdentifier2(nativeSessionId) : sanitizeHashMetadata(input.nativeSessionIdHash);
   const cwdHash = input.cwdHash === undefined ? hashOptionalIdentifier2(input.cwd ?? null) : sanitizeHashMetadata(input.cwdHash);
@@ -13933,9 +14499,9 @@ function createCodeAgentTraceRef(input) {
   });
   return {
     version: 1,
-    id: `trace-ref-${input.target}-${sessionKey}`,
+    id: `trace-ref-${input.target}-${sessionKey2}`,
     target: input.target,
-    sessionKey,
+    sessionKey: sessionKey2,
     nativeSessionIdHash,
     projectKey: input.projectKey === undefined || input.projectKey === null ? null : sanitizePersistentIdentifier2(input.projectKey, "project"),
     runId: input.runId === undefined || input.runId === null ? null : sanitizePersistentIdentifier2(input.runId, "run"),
@@ -14003,7 +14569,7 @@ async function readCodeAgentTraceRef(input) {
     target: targetAndSession.target,
     sessionKey: targetAndSession.sessionKey
   });
-  const ref = sanitizeCodeAgentTraceRefForWrite(parseCodeAgentTraceRef(JSON.parse(await readFile13(path, "utf8"))));
+  const ref = sanitizeCodeAgentTraceRefForWrite(parseCodeAgentTraceRef(JSON.parse(await readFile14(path, "utf8"))));
   if (ref.id !== input.id)
     throw new Error(`Code Agent trace ref id mismatch: ${input.id}`);
   return { ref, path };
@@ -14018,7 +14584,7 @@ async function listCodeAgentTraceRefs(input) {
       if (!entry.isFile() || !entry.name.endsWith(".json"))
         continue;
       const path = join15(dir, entry.name);
-      const ref = sanitizeCodeAgentTraceRefForWrite(parseCodeAgentTraceRef(JSON.parse(await readFile13(path, "utf8"))));
+      const ref = sanitizeCodeAgentTraceRefForWrite(parseCodeAgentTraceRef(JSON.parse(await readFile14(path, "utf8"))));
       if (input.projectKey !== undefined && ref.projectKey !== input.projectKey)
         continue;
       if (input.runId !== undefined && ref.runId !== input.runId)
@@ -14379,7 +14945,7 @@ function expectNonNegativeInteger(value, path) {
   return value;
 }
 // packages/core/src/config/store.ts
-import { mkdir as mkdir10, readFile as readFile14, writeFile as writeFile9 } from "node:fs/promises";
+import { mkdir as mkdir10, readFile as readFile15, writeFile as writeFile9 } from "node:fs/promises";
 import { dirname as dirname11 } from "node:path";
 function createCoreConfigStore(homeDir) {
   const paths2 = resolveEvoDevPaths(homeDir);
@@ -14513,7 +15079,7 @@ async function ensureKnowledgeBaseFiles(paths2) {
 async function readJsonFile2(filePath, parse2) {
   let raw;
   try {
-    raw = await readFile14(filePath, "utf8");
+    raw = await readFile15(filePath, "utf8");
   } catch (error) {
     throw new EvoDevConfigError(`Cannot read config file (${describeFileError2(error)})`, filePath);
   }
@@ -14544,7 +15110,7 @@ async function readJsonFileOrDefault(filePath, parse2, fallback) {
 }
 async function writeIfMissing(filePath, value) {
   try {
-    await readFile14(filePath, "utf8");
+    await readFile15(filePath, "utf8");
   } catch (error) {
     if (isNodeError2(error) && error.code === "ENOENT") {
       await writeJsonFile3(filePath, value);
@@ -14556,7 +15122,7 @@ async function writeIfMissing(filePath, value) {
 async function writeIndexIfMissingOrMigrate(filePath, kind, defaults) {
   let raw;
   try {
-    raw = await readFile14(filePath, "utf8");
+    raw = await readFile15(filePath, "utf8");
   } catch (error) {
     if (isNodeError2(error) && error.code === "ENOENT") {
       await writeJsonFile3(filePath, defaults);
@@ -14579,7 +15145,7 @@ async function writeIndexIfMissingOrMigrate(filePath, kind, defaults) {
 }
 async function writeTextIfMissing2(filePath, value) {
   try {
-    await readFile14(filePath, "utf8");
+    await readFile15(filePath, "utf8");
   } catch (error) {
     if (isNodeError2(error) && error.code === "ENOENT") {
       await mkdir10(dirname11(filePath), { recursive: true });
@@ -14608,7 +15174,7 @@ function isRecord10(value) {
 }
 // packages/core/src/daemon/index.ts
 import { randomBytes } from "node:crypto";
-import { mkdir as mkdir13, readFile as readFile18, readdir as readdir13, rm as rm6, stat as stat10, writeFile as writeFile11 } from "node:fs/promises";
+import { mkdir as mkdir13, readFile as readFile19, readdir as readdir13, rm as rm6, stat as stat10, writeFile as writeFile11 } from "node:fs/promises";
 import { createServer } from "node:http";
 import { dirname as dirname14, join as join20 } from "node:path";
 
@@ -14761,7 +15327,7 @@ __export(exports_processor, {
 });
 
 // packages/core/src/evolution/evidence/analysis.ts
-import { readFile as readFile15, readdir as readdir11 } from "node:fs/promises";
+import { readFile as readFile16, readdir as readdir11 } from "node:fs/promises";
 import { basename as basename4, join as join16 } from "node:path";
 async function analyzeEvolutionRun(input) {
   const projectKey = resolveEvolutionProjectKey(input);
@@ -14877,7 +15443,7 @@ async function analyzeEvolutionRun(input) {
   };
 }
 async function readExecutionEvidenceEvents(input) {
-  const raw = await readFile15(input.path, "utf8");
+  const raw = await readFile16(input.path, "utf8");
   const lines = raw.split(`
 `);
   const events = [];
@@ -14947,7 +15513,7 @@ function createEvidenceEventFromExecutionEvent(input) {
   };
 }
 async function readTraceEvidenceEvents(input) {
-  const raw = await readFile15(input.path, "utf8");
+  const raw = await readFile16(input.path, "utf8");
   const lines = raw.split(`
 `);
   const events = [];
@@ -15514,7 +16080,7 @@ function createProvenance(evidenceWindow, createdAt, sourceRefs) {
 }
 // packages/core/src/evolution/processor/process.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { mkdir as mkdir11, open as open2, readFile as readFile16, rm as rm5, stat as stat8 } from "node:fs/promises";
+import { mkdir as mkdir11, open as open2, readFile as readFile17, rm as rm5, stat as stat8 } from "node:fs/promises";
 import { dirname as dirname12, join as join18 } from "node:path";
 var PROCESS_LOCK_STALE_MS2 = 5 * 60 * 1000;
 var PROCESS_LOCK_HEARTBEAT_MS = 30 * 1000;
@@ -15940,7 +16506,7 @@ async function assertEvolutionProcessLockOwned(lock) {
 }
 async function evolutionProcessLockIsOwned(lock) {
   try {
-    const value = JSON.parse(await readFile16(lock.path, "utf8"));
+    const value = JSON.parse(await readFile17(lock.path, "utf8"));
     return value.ownerId === lock.ownerId;
   } catch {
     return false;
@@ -16003,7 +16569,7 @@ function isTransientEvolutionError(error) {
   return /(?:timed?\s*out|timeout|rate[\s-]*limit|too many requests|\b429\b|network|econn(?:reset|refused|aborted)|eai_again|etimedout|socket|temporar|service unavailable|\b50[0234]\b|fetch failed)/u.test(message);
 }
 // packages/core/src/observability/index.ts
-import { mkdir as mkdir12, readFile as readFile17, readdir as readdir12, stat as stat9, writeFile as writeFile10 } from "node:fs/promises";
+import { mkdir as mkdir12, readFile as readFile18, readdir as readdir12, stat as stat9, writeFile as writeFile10 } from "node:fs/promises";
 import { dirname as dirname13, join as join19 } from "node:path";
 var EVENT_TYPE_TO_DIR = {
   "verification.completed": "verification",
@@ -16084,7 +16650,7 @@ async function listObservabilityEvents(homeDir, type) {
     const path = resolveObservabilityStorePaths(homeDir, eventType).eventsPath;
     if (!await pathExists5(path))
       continue;
-    const lines = (await readFile17(path, "utf8")).split(`
+    const lines = (await readFile18(path, "utf8")).split(`
 `).filter(Boolean);
     for (const line of lines) {
       const event = JSON.parse(line);
@@ -16261,7 +16827,7 @@ async function readDaemonLock(homeDir) {
   const paths2 = resolveDaemonPaths(homeDir);
   if (!await pathExists6(paths2.lockPath))
     return null;
-  const lock = JSON.parse(await readFile18(paths2.lockPath, "utf8"));
+  const lock = JSON.parse(await readFile19(paths2.lockPath, "utf8"));
   if (lock.version !== 1 || lock.component !== "evodev-daemon")
     throw new Error("Invalid daemon lock.");
   return lock;
@@ -16270,7 +16836,7 @@ async function readDaemonToken(homeDir) {
   const paths2 = resolveDaemonPaths(homeDir);
   if (!await pathExists6(paths2.tokenPath))
     return null;
-  return (await readFile18(paths2.tokenPath, "utf8")).trim();
+  return (await readFile19(paths2.tokenPath, "utf8")).trim();
 }
 async function cleanupDaemonState(homeDir, token) {
   const paths2 = resolveDaemonPaths(homeDir);
@@ -16476,7 +17042,7 @@ async function collectLearningCandidateSummaries(homeDir, warnings) {
     warnings.push("Learning candidate store not found; returning empty candidates.");
     return [];
   }
-  const lines = (await readFile18(path, "utf8")).split(`
+  const lines = (await readFile19(path, "utf8")).split(`
 `).filter(Boolean);
   return lines.map((line) => {
     const candidate = JSON.parse(line);
@@ -16783,7 +17349,7 @@ async function readDaemonEvolutionProcessError(homeDir) {
   const path = resolveDaemonEvolutionProcessErrorPath(homeDir);
   if (!await pathExists6(path))
     return null;
-  const value = JSON.parse(await readFile18(path, "utf8"));
+  const value = JSON.parse(await readFile19(path, "utf8"));
   return typeof value.summary === "string" && value.summary.length > 0 ? value.summary : null;
 }
 function describeError3(error) {
@@ -17231,7 +17797,7 @@ function assertDescendant(rootDir, candidate) {
 }
 // packages/core/src/evolution/imports/storage.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { chmod as chmod2, link as link2, lstat as lstat3, mkdir as mkdir14, open as open3, readFile as readFile19, rename as rename4, rm as rm7 } from "node:fs/promises";
+import { chmod as chmod2, link as link2, lstat as lstat3, mkdir as mkdir14, open as open3, readFile as readFile20, rename as rename4, rm as rm7 } from "node:fs/promises";
 import { dirname as dirname15, join as join22 } from "node:path";
 var PRIVATE_DIRECTORY_MODE = 448;
 var PRIVATE_FILE_MODE = 384;
@@ -17411,7 +17977,7 @@ async function writeTrajectoryImportManifest(paths2, manifest) {
 }
 async function readTrajectoryImportIndex(path) {
   await assertRegularStateFile(path);
-  const content = await readFile19(path, "utf8");
+  const content = await readFile20(path, "utf8");
   const lines = content.endsWith(`
 `) ? content.slice(0, -1).split(`
 `) : content.split(`
@@ -17524,7 +18090,7 @@ async function heartbeatTrajectoryImportSourceLock(lock) {
 }
 async function trajectoryImportSourceLockIsOwned(lock) {
   try {
-    const value = JSON.parse(await readFile19(lock.ownerPath, "utf8"));
+    const value = JSON.parse(await readFile20(lock.ownerPath, "utf8"));
     return value.ownerToken === lock.ownerToken;
   } catch {
     return false;
@@ -17608,7 +18174,7 @@ async function restoreQuarantinedLock(quarantinePath, targetPath) {
 }
 async function removeOwnedControlFile(path, ownerToken) {
   try {
-    const value = JSON.parse(await readFile19(path, "utf8"));
+    const value = JSON.parse(await readFile20(path, "utf8"));
     if (value.ownerToken === ownerToken)
       await rm7(path, { force: true });
   } catch {}
@@ -17635,7 +18201,7 @@ async function writePrivateImmutableFile(path, content) {
       if (!hasErrorCode(error, "EEXIST"))
         throw error;
       await assertRegularStateFile(path);
-      const existing = await readFile19(path, "utf8");
+      const existing = await readFile20(path, "utf8");
       if (existing !== content) {
         throw new Error("Trajectory import immutable state digest conflict.");
       }
@@ -17690,7 +18256,7 @@ async function createPrivateExclusiveFile(path, content) {
 async function readOptionalJson(path, parser) {
   try {
     await assertRegularStateFile(path);
-    const content = await readFile19(path, "utf8");
+    const content = await readFile20(path, "utf8");
     return parser(JSON.parse(content));
   } catch (error) {
     if (hasErrorCode(error, "ENOENT"))
@@ -18302,8 +18868,8 @@ function createHistoricalSessionEvidenceSegments(input) {
     throw new Error("Historical materialization requires a projectKey.");
   }
   const createdAt = normalizeIsoTimestamp(input.createdAt);
-  const expiresAt = addDays(createdAt, input.plan.policy.retentionDays);
-  const sessionKey = `historical-${input.plan.preview.sourceKey}`;
+  const expiresAt = addDays3(createdAt, input.plan.policy.retentionDays);
+  const sessionKey2 = `historical-${input.plan.preview.sourceKey}`;
   const target = sourceTarget(input.plan.preview.source);
   return input.plan.preparedSegments.map((prepared) => ({
     schemaVersion: 1,
@@ -18312,7 +18878,7 @@ function createHistoricalSessionEvidenceSegments(input) {
     projectKey,
     runId: null,
     roleId: input.plan.preview.scope.roleId,
-    sessionKey,
+    sessionKey: sessionKey2,
     target,
     createdAt,
     reason: "historical-import",
@@ -18710,7 +19276,7 @@ function normalizeIsoTimestamp(value) {
   }
   return new Date(value).toISOString();
 }
-function addDays(value, days) {
+function addDays3(value, days) {
   return new Date(Date.parse(value) + days * 24 * 60 * 60 * 1000).toISOString();
 }
 // packages/core/src/evolution/imports/apply.ts
@@ -18757,13 +19323,13 @@ async function applyTrajectoryImport(input) {
       plan: input.plan,
       createdAt: staged.receipt.createdAt
     });
-    const sessionKey = `historical-${input.plan.preview.sourceKey}`;
+    const sessionKey2 = `historical-${input.plan.preview.sourceKey}`;
     const sessionPaths = resolveSessionMemoryPaths({
       homeDir: input.homeDir,
       projectKey,
-      sessionKey
+      sessionKey: sessionKey2
     });
-    const expectedTriggerIds = segments.map((segment) => createStableId("segment-trigger", [projectKey, sessionKey, segment.id]));
+    const expectedTriggerIds = segments.map((segment) => createStableId("segment-trigger", [projectKey, sessionKey2, segment.id]));
     let progress = await resolveMaterializationProgress({
       path: paths2.materializationPath,
       previewId: input.plan.preview.id,
@@ -18796,7 +19362,7 @@ async function applyTrajectoryImport(input) {
         homeDir: input.homeDir,
         paths: sessionPaths,
         projectKey,
-        sessionKey,
+        sessionKey: sessionKey2,
         target: segments[0]?.target ?? "unknown",
         roleId: input.plan.preview.scope.roleId,
         policy: input.plan.policy,
@@ -18809,7 +19375,7 @@ async function applyTrajectoryImport(input) {
       const trigger = await enqueueSegmentEvolutionTrigger({
         homeDir: input.homeDir,
         projectKey,
-        sessionKey,
+        sessionKey: sessionKey2,
         runId: null,
         roleId: input.plan.preview.scope.roleId,
         segmentId: segment.id,
@@ -18834,7 +19400,7 @@ async function applyTrajectoryImport(input) {
     await verifyMaterializedSegments({
       homeDir: input.homeDir,
       projectKey,
-      sessionKey,
+      sessionKey: sessionKey2,
       segmentIds: progress.expectedSegmentIds
     });
     if (progress.completedSegmentIds.length !== progress.expectedSegmentIds.length || progress.completedTriggerIds.length !== progress.expectedTriggerIds.length) {
@@ -18907,17 +19473,17 @@ async function readCompletedApplyResult(input, manifest) {
   if (progress.completedSegmentIds.length !== progress.expectedSegmentIds.length || progress.completedTriggerIds.length !== progress.expectedTriggerIds.length) {
     throw new Error("Completed trajectory import has incomplete materialization progress.");
   }
-  const sessionKey = `historical-${manifest.sourceKey}`;
+  const sessionKey2 = `historical-${manifest.sourceKey}`;
   await verifyMaterializedSegments({
     homeDir: input.homeDir,
     projectKey,
-    sessionKey,
+    sessionKey: sessionKey2,
     segmentIds: progress.expectedSegmentIds
   });
   const triggerIds = new Set((await listSegmentEvolutionTriggers({
     homeDir: input.homeDir,
     projectKey
-  })).filter((trigger) => trigger.sessionKey === sessionKey && progress.expectedSegmentIds.includes(trigger.segmentId)).map((trigger) => trigger.id));
+  })).filter((trigger) => trigger.sessionKey === sessionKey2 && progress.expectedSegmentIds.includes(trigger.segmentId)).map((trigger) => trigger.id));
   if (progress.expectedTriggerIds.some((id) => !triggerIds.has(id))) {
     throw new Error("Completed trajectory import is missing a materialized trigger.");
   }
@@ -19322,7 +19888,7 @@ __export(exports_review, {
   validateLearningCandidate: () => validateLearningCandidate,
   validateLearningReviewDecisionRecord: () => validateLearningReviewDecisionRecord
 });
-import { mkdir as mkdir15, readFile as readFile20, stat as stat11, writeFile as writeFile12 } from "node:fs/promises";
+import { mkdir as mkdir15, readFile as readFile21, stat as stat11, writeFile as writeFile12 } from "node:fs/promises";
 import { dirname as dirname16, join as join23 } from "node:path";
 var LEARNING_CANDIDATE_KINDS = [
   "lesson",
@@ -19735,7 +20301,7 @@ function requiredFields(candidate) {
   ];
 }
 async function parseJsonOrJsonlFile(path, parseItem) {
-  const raw = await readFile20(path, "utf8");
+  const raw = await readFile21(path, "utf8");
   if (raw.trim() === "")
     return [];
   if (path.endsWith(".jsonl")) {
@@ -19816,7 +20382,7 @@ function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 // packages/core/src/pack/index.ts
-import { readFile as readFile21, readdir as readdir14, stat as stat12 } from "node:fs/promises";
+import { readFile as readFile22, readdir as readdir14, stat as stat12 } from "node:fs/promises";
 import { isAbsolute as isAbsolute8, join as join24, relative as relative8, sep as sep2 } from "node:path";
 
 // packages/core/src/protected-zones/index.ts
@@ -19967,7 +20533,7 @@ async function validatePack(packPath) {
   let assets = [];
   let scannedPaths = [];
   try {
-    manifest = parsePackManifest(JSON.parse(await readFile21(manifestPath, "utf8")));
+    manifest = parsePackManifest(JSON.parse(await readFile22(manifestPath, "utf8")));
   } catch (error) {
     findings.push({
       severity: "error",
@@ -20498,7 +21064,7 @@ function formatError(error) {
   return error instanceof Error ? error.message : String(error);
 }
 // packages/core/src/plugins/capabilities.ts
-import { mkdir as mkdir16, readFile as readFile22, writeFile as writeFile13 } from "node:fs/promises";
+import { mkdir as mkdir16, readFile as readFile23, writeFile as writeFile13 } from "node:fs/promises";
 import { dirname as dirname17, join as join25 } from "node:path";
 function createUnknownNegotiatedCapabilities(pluginId) {
   return {
@@ -20621,7 +21187,7 @@ async function writeCodexCapabilityVerificationArtifact(homeDir, artifact) {
 }
 async function readCodexCapabilityVerificationArtifact(homeDir) {
   try {
-    const artifact = JSON.parse(await readFile22(resolveCodexCapabilityArtifactPath(homeDir), "utf8"));
+    const artifact = JSON.parse(await readFile23(resolveCodexCapabilityArtifactPath(homeDir), "utf8"));
     validateCodexCapabilityVerificationArtifact(artifact);
     return artifact;
   } catch (error) {
@@ -21248,7 +21814,7 @@ function describeError4(error) {
   return error instanceof Error ? error.message : String(error);
 }
 // packages/core/src/workflow/index.ts
-import { readFile as readFile23, readdir as readdir15 } from "node:fs/promises";
+import { readFile as readFile24, readdir as readdir15 } from "node:fs/promises";
 import { join as join27 } from "node:path";
 async function scanWorkflowManifests(workflowsDir) {
   const manifests = [];
@@ -21257,7 +21823,7 @@ async function scanWorkflowManifests(workflowsDir) {
     if (!entry.isDirectory())
       continue;
     const manifestPath = join27(workflowsDir, entry.name, "WORKFLOW.json");
-    manifests.push(parseWorkflowManifest(JSON.parse(await readFile23(manifestPath, "utf8"))));
+    manifests.push(parseWorkflowManifest(JSON.parse(await readFile24(manifestPath, "utf8"))));
   }
   return manifests.sort((left, right) => left.id.localeCompare(right.id));
 }
@@ -21466,6 +22032,7 @@ export {
   hasContextInjectionReceipt,
   initializeCoreConfig,
   inspectHistoricalSessionEvidenceRetention,
+  inspectSessionEvidenceRetention,
   isActiveTeamAgentStatus,
   isCapabilityUsable,
   isEvolutionImprovementEvalRecommended,
@@ -21504,6 +22071,7 @@ export {
   mergeReviewFindings,
   mergeSessionMemorySensitivity,
   mergeSettings,
+  migrateLegacySessionEvidenceRetention,
   negotiatePluginCapabilities,
   normalizeHookEvent,
   normalizePackPermissions,
@@ -21533,6 +22101,7 @@ export {
   previewOkfKnowledgeChangeDecision,
   processEvolutionTriggers,
   purgeExpiredHistoricalSessionEvidence,
+  purgeExpiredSessionEvidence,
   quarantineLegacyGeneratedKnowledge,
   queryOkfKnowledge,
   queryScopedOkfKnowledgeContext,
@@ -21569,6 +22138,7 @@ export {
   rebuildOkfKnowledgeIndexes,
   reconcileTeamRun,
   recordCodeAgentTraceRefFromHook,
+  recordContextInjectionOutcome,
   recordDiscoveredProject,
   recordTeamAgentNativeSession,
   redactSessionMemoryCredentialText,
@@ -21578,6 +22148,7 @@ export {
   renderMainTeamOverlayContext,
   renderRoleAgentDefinitionContext,
   replaceOkfKnowledgeChangeCandidate,
+  resetSessionRawEvents,
   resolveCodeAgentTraceRefPaths,
   resolveCodexCapabilityArtifactPath,
   resolveContextInjectionReceiptPath,
@@ -21591,6 +22162,7 @@ export {
   resolveLearningDecisionPath,
   resolveObservabilityStorePaths,
   resolveOkfKnowledgePaths,
+  resolveOkfKnowledgeRuntimeEligibility,
   resolvePathProjectLogKey,
   resolveProjectLogIdentity,
   resolveProjectLogKey,
@@ -21609,6 +22181,7 @@ export {
   resumeFailedOkfKnowledgePlan,
   resumeTeamRun,
   revokeOkfKnowledgeConcept,
+  rewriteSessionRawEvents,
   runDaemonForeground,
   runPluginConformance,
   runSync,