@lmzhen/dsh-evolution-feedback 0.1.0-rc.70 → 0.1.0-rc.72

package/lib/index.js

@@ -1,5 +1,5 @@
 import z from "@deepseek-ai/schemastery";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { createHash } from "node:crypto";
 import { homedir } from "node:os";
 //#region ../evolution-core/src/io.ts
@@ -41,6 +41,17 @@ function evolutionIoAdapter(provider) {
 		}
 	};
 }
+/** Active-log split point (rc.71): when the active log reaches this many events
+* the older half is rotated into an archive; the active stays bounded so a
+* single append stays O(active) instead of O(total-history). Tunable default —
+* callers may override per append (the tests use small values). */
+const EVENT_LOG_ROTATE_AT = 4e3;
+/** Archive file prefix: `events-<lastArchivedSeq>.json`. The active file is
+* `events.json` and never matches this glob. */
+const EVENT_ARCHIVE_PREFIX = "events-";
+/** Archive naming is strictly numeric: a user file such as `events-backup.json`
+* under the same directory is neither read into the timeline nor pruned. */
+const EVENT_ARCHIVE_RE = /^events-(\d+)\.json$/;
 function eventsFile(home) {
 	return join(home, "evolution", "events.json");
 }
@@ -68,39 +79,108 @@ function parseEvolutionEvents(raw) {
 	}
 }
 /**
+* List the numeric archives under the log's directory, sorted ascending by
+* their last-archived seq. Single glob predicate for the timeline, the
+* retention pass and the feedback migration check (rc.72 H-3).
+*/
+async function listEventArchives(io, path) {
+	const dir = dirname(path);
+	return (await io.list(dir)).filter((name) => EVENT_ARCHIVE_RE.test(name)).sort((a, b) => {
+		return Number.parseInt(a.slice(7, a.length - 5), 10) - Number.parseInt(b.slice(7, b.length - 5), 10);
+	});
+}
+/**
 * Append one event under the write lock (rc.68): `seq` = current max + 1
 * computed inside the transact, so two processes appending concurrently never
 * collide. A malformed log is refused (bytes preserved) and the append fails.
 * Returns the assigned seq.
+*
+* Rotation (rc.71, 007 design): when the active log reaches `rotateAt`, the
+* older half is copied into an archive inside the SAME transact (the archive
+* path has its own lock, so no recursion) and the active is replaced with the
+* newer half + the new event. seqs stay globally monotonic; a crash between
+* archive write and active write leaves both copies, which the timeline merge
+* dedupes by seq. An archive-write failure aborts the append (active keeps the
+* full old content — no loss) and the caller's best-effort handling applies.
+*
+* rc.72 G-1: when the ACTIVE is missing/whitespace but archives exist (a
+* deleted active, or B-2 self-heal), seq derivation consults the archive names
+* — the active restarts AFTER the highest archived seq, never at 1, so a new
+* event can never shadow an archived one in the seq-deduped timeline.
 */
-async function appendEvolutionEvent(io, path, event) {
+async function appendEvolutionEvent(io, path, event, rotateAt = EVENT_LOG_ROTATE_AT) {
 	let assigned = 0;
-	await transactIo(io, path, (current) => {
+	await transactIo(io, path, async (current) => {
 		if (current !== null && current.trim() !== "") try {
 			JSON.parse(current);
 		} catch {
-			return Promise.resolve(current);
+			return current;
 		}
-		const events = parseEvolutionEvents(current);
-		const maxSeq = events.reduce((max, entry) => Math.max(max, entry.seq), 0);
+		const nextEvents = await rotateIfDue(io, path, parseEvolutionEvents(current), rotateAt);
+		let maxSeq = nextEvents.reduce((max, entry) => Math.max(max, entry.seq), 0);
+		if (maxSeq === 0) for (const name of await listEventArchives(io, path)) maxSeq = Math.max(maxSeq, Number.parseInt(name.slice(7, name.length - 5), 10));
 		const record = {
 			...event,
 			seq: maxSeq + 1,
 			at: (/* @__PURE__ */ new Date()).toISOString()
 		};
 		assigned = record.seq;
-		return Promise.resolve(JSON.stringify({
+		return JSON.stringify({
 			version: 1,
-			events: [...events, record]
-		}, null, 2));
+			events: [...nextEvents, record]
+		}, null, 2);
 	});
 	if (assigned === 0) throw new Error(`evolution event log is malformed and was not touched: ${path}`);
 	return assigned;
 }
+/**
+* Split the active log at its midpoint when due: the older half is written to
+* `events-<lastArchivedSeq>.json` (await — a failed archive write aborts the
+* append so the active is never truncated without its copy), old archives are
+* pruned, and the newer half is returned as the next active body. No-op when
+* under the threshold; `rotateAt < 2` is a guarded no-op (rc.72 G-1: a
+* one-event rotate would archive everything and restart seqs at 1).
+*/
+async function rotateIfDue(io, path, events, rotateAt) {
+	if (rotateAt < 2 || events.length < rotateAt) return events;
+	const mid = Math.ceil(events.length / 2);
+	const head = events.slice(0, mid);
+	const tail = events.slice(mid);
+	if (tail.length === 0) return events;
+	const anchor = tail[0]?.seq ?? 0;
+	const archivePath = join(dirname(path), `${EVENT_ARCHIVE_PREFIX}${anchor - 1}.json`);
+	await io.writeText(archivePath, JSON.stringify({
+		version: 1,
+		events: head
+	}, null, 2));
+	await retainEventArchives(io, path);
+	return tail;
+}
+/**
+* Prune old event archives (rc.71): keep the newest `EVENT_LOG_RETAIN_ARCHIVES`.
+* The name's numeric part is the last archived seq, so ordering is NUMERIC —
+* lexicographic would rank `events-10` before `events-2`. Only strictly
+* numeric names participate (rc.72 G-2: user files are never deleted).
+* Best-effort per removal; exported for the retention test.
+*/
+async function retainEventArchives(io, path) {
+	const dir = dirname(path);
+	const names = await listEventArchives(io, path);
+	const excess = names.slice(0, Math.max(0, names.length - 10));
+	for (const name of excess) await io.remove(join(dir, name)).catch(() => {});
+}
 /** Read the event log; a missing/whitespace-only file reads as empty,
 * corrupt content is flagged (and refused on append). */
 async function readEvolutionEvents(io, path) {
-	const raw = await io.readText(path);
+	let raw;
+	try {
+		raw = await io.readText(path);
+	} catch {
+		return {
+			events: [],
+			malformed: true
+		};
+	}
 	if (raw === null || raw.trim() === "") return {
 		events: [],
 		malformed: false
@@ -122,6 +202,30 @@ async function readEvolutionEvents(io, path) {
 		};
 	}
 }
+/**
+* Read the full timeline (rc.71): active log + all archives, merged by seq
+* (active copy wins, duplicates only arise from the rotation crash window),
+* sorted ascending. Per-file malformed flag as in `readEvolutionEvents`; a
+* malformed (or unreadable) ARCHIVE is skipped — it never bricks the boot and
+* it is still flagged.
+*/
+async function readEvolutionTimeline(io, path) {
+	const dir = dirname(path);
+	let malformed = false;
+	const bySeq = /* @__PURE__ */ new Map();
+	for (const name of await listEventArchives(io, path)) {
+		const read = await readEvolutionEvents(io, join(dir, name));
+		if (read.malformed) malformed = true;
+		for (const event of read.events) bySeq.set(event.seq, event);
+	}
+	const active = await readEvolutionEvents(io, path);
+	if (active.malformed) malformed = true;
+	for (const event of active.events) bySeq.set(event.seq, event);
+	return {
+		events: [...bySeq.values()].sort((a, b) => a.seq - b.seq),
+		malformed
+	};
+}
 //#endregion
 //#region ../evolution-core/src/prompts.ts
 /**
@@ -366,6 +470,12 @@ new RegExp(String.raw`ignore\s+${FILLER}(?:previous|above|prior|all)\s+${FILLER}
 * @module @lmzhen/dsh-evolution-feedback
 */
 const CACHE_VERSION = 2;
+/** Cache snapshot cadence (rc.72 G-3): every N-th appended event refreshes the
+* boot cache, so `cache.lastSeq` always stays inside the retention window —
+* a hard crash between snapshots loses at most N events, all of which still
+* live in the ACTIVE log (bounded by `EVENT_LOG_ROTATE_AT`), so the next fold
+* is complete. Package-private tunable, not a config surface. */
+const CACHE_SNAP_EVERY = 1024;
 var EvolutionFeedback = class {
 	state = {
 		skills: {},
@@ -393,16 +503,19 @@ var EvolutionFeedback = class {
 		if (!path || !eventsPath) return;
 		await this.mutate(async () => {
 			const rawEvents = await io.readText(eventsPath);
-			if (rawEvents === null || rawEvents.trim() === "") {
+			const archiveNames = await listEventArchives(io, eventsPath);
+			if ((rawEvents === null || rawEvents.trim() === "") && archiveNames.length === 0) {
 				const aggregate = parseAggregate(await io.readText(path));
 				if (aggregate) try {
 					await migrateFeedbackEvents(io, eventsPath, aggregate);
 				} catch {}
 			}
-			const { events } = await readEvolutionEvents(io, eventsPath);
+			const { events } = await readEvolutionTimeline(io, eventsPath);
 			const cache = parseCache(await io.readText(path));
 			const maxSeq = events.reduce((max, event) => Math.max(max, event.seq), 0);
-			const truth = cache ? foldWithDelta(cache, events) : foldFeedbackState(events);
+			const floor = events[0]?.seq ?? 0;
+			const usableCache = cache && cache.lastSeq >= floor - 1 ? cache : null;
+			const truth = usableCache ? foldWithDelta(usableCache, events) : foldFeedbackState(events);
 			this.state = {
 				skills: {
 					...truth.skills,
@@ -437,13 +550,13 @@ var EvolutionFeedback = class {
 		if (!recordIo || !eventsPath) return;
 		this.mutate(async () => {
 			try {
-				await appendEvolutionEvent(recordIo, eventsPath, {
+				if (await appendEvolutionEvent(recordIo, eventsPath, {
 					type: "feedback",
 					target,
 					kind,
 					rating,
 					note
-				});
+				}) % CACHE_SNAP_EVERY === 0) await this.writeCacheNow();
 			} catch (error) {}
 		});
 	}
@@ -464,23 +577,28 @@ var EvolutionFeedback = class {
 	waitIdle() {
 		return this.chain;
 	}
-	/** Rebuild the boot cache from the log truth (rc.68); best-effort. */
-	persistCache() {
+	/** Snapshot the boot cache from the log truth (rc.68/rc.72); best-effort. */
+	async writeCacheNow() {
 		const path = this.path;
 		const eventsPath = this.eventsPath;
 		const recordIo = this.io;
-		if (!path || !eventsPath || !recordIo) return Promise.resolve();
+		if (!path || !eventsPath || !recordIo) return;
+		try {
+			const { events } = await readEvolutionTimeline(recordIo, eventsPath);
+			const maxSeq = events.reduce((max, event) => Math.max(max, event.seq), 0);
+			if (maxSeq === 0) return;
+			await recordIo.writeText(path, JSON.stringify({
+				version: CACHE_VERSION,
+				lastSeq: maxSeq,
+				...foldFeedbackState(events)
+			}, null, 2));
+		} catch {}
+	}
+	/** Rebuild the boot cache from the log truth (rc.68); best-effort, queued
+	* on the record chain so it runs after the pending appends. */
+	persistCache() {
 		return this.mutate(async () => {
-			try {
-				const { events } = await readEvolutionEvents(recordIo, eventsPath);
-				const maxSeq = events.reduce((max, event) => Math.max(max, event.seq), 0);
-				if (maxSeq === 0) return;
-				await recordIo.writeText(path, JSON.stringify({
-					version: CACHE_VERSION,
-					lastSeq: maxSeq,
-					...foldFeedbackState(events)
-				}, null, 2));
-			} catch {}
+			await this.writeCacheNow();
 		});
 	}
 };

package/lib/types/index.d.ts

@@ -44,7 +44,10 @@ export declare class EvolutionFeedback {
     snapshot(): FeedbackState;
     /** Await the pending record-task chain (unload safety; rc.66). */
     waitIdle(): Promise<unknown>;
-    /** Rebuild the boot cache from the log truth (rc.68); best-effort. */
+    /** Snapshot the boot cache from the log truth (rc.68/rc.72); best-effort. */
+    private writeCacheNow;
+    /** Rebuild the boot cache from the log truth (rc.68); best-effort, queued
+     * on the record chain so it runs after the pending appends. */
     persistCache(): Promise<void>;
 }
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-feedback",
   "description": "Feedback-to-quality scoring for self-evolution (community build)",
-  "version": "0.1.0-rc.70",
+  "version": "0.1.0-rc.72",
   "publishConfig": {
     "access": "public"
   },
@@ -37,13 +37,13 @@
   "peerDependencies": {
     "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2",
     "@deepseek-ai/cordis": "^4.0.1",
-    "@lmzhen/dsh-evolution-io": "^0.1.0-rc.70",
-    "@lmzhen/dsh-skill-usage": "^0.1.0-rc.70"
+    "@lmzhen/dsh-evolution-io": "^0.1.0-rc.72",
+    "@lmzhen/dsh-skill-usage": "^0.1.0-rc.72"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2",
-    "@lmzhen/dsh-evolution-io": "^0.1.0-rc.70",
-    "@lmzhen/dsh-evolution-io-node": "^0.1.0-rc.70",
-    "@lmzhen/dsh-skill-usage": "^0.1.0-rc.70"
+    "@lmzhen/dsh-evolution-io": "^0.1.0-rc.72",
+    "@lmzhen/dsh-evolution-io-node": "^0.1.0-rc.72",
+    "@lmzhen/dsh-skill-usage": "^0.1.0-rc.72"
   }
 }