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

package/lib/index.js

@@ -49,6 +49,9 @@ 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");
 }
@@ -76,6 +79,17 @@ 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.
@@ -88,6 +102,11 @@ function parseEvolutionEvents(raw) {
 * 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, rotateAt = EVENT_LOG_ROTATE_AT) {
 	let assigned = 0;
@@ -98,7 +117,8 @@ async function appendEvolutionEvent(io, path, event, rotateAt = EVENT_LOG_ROTATE
 			return current;
 		}
 		const nextEvents = await rotateIfDue(io, path, parseEvolutionEvents(current), rotateAt);
-		const maxSeq = nextEvents.reduce((max, entry) => Math.max(max, entry.seq), 0);
+		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,
@@ -118,14 +138,16 @@ async function appendEvolutionEvent(io, path, event, rotateAt = EVENT_LOG_ROTATE
 * `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.
+* 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 (events.length < rotateAt) return events;
+	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);
-	const anchor = tail[0]?.seq ?? events[events.length - 1]?.seq ?? 0;
+	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,
@@ -137,21 +159,28 @@ async function rotateIfDue(io, path, events, rotateAt) {
 /**
 * 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`. Best-effort per
-* removal; exported for the retention test.
+* 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 io.list(dir)).filter((name) => name.startsWith("events-") && name.endsWith(".json"));
-	const archiveSeq = (name) => Number.parseInt(name.slice(7, name.length - 5), 10) || 0;
-	names.sort((a, b) => archiveSeq(a) - archiveSeq(b));
+	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
@@ -177,14 +206,14 @@ 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 ARCHIVE is skipped (never bricks the boot) and still flagged.
+* 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);
-	const names = (await io.list(dir)).filter((name) => name.startsWith("events-") && name.endsWith(".json")).sort();
 	let malformed = false;
 	const bySeq = /* @__PURE__ */ new Map();
-	for (const name of names) {
+	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);
@@ -441,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: {},
@@ -468,7 +503,7 @@ var EvolutionFeedback = class {
 		if (!path || !eventsPath) return;
 		await this.mutate(async () => {
 			const rawEvents = await io.readText(eventsPath);
-			const archiveNames = (await io.list(dirname(eventsPath))).filter((name) => name.startsWith("events-") && name.endsWith(".json"));
+			const archiveNames = await listEventArchives(io, eventsPath);
 			if ((rawEvents === null || rawEvents.trim() === "") && archiveNames.length === 0) {
 				const aggregate = parseAggregate(await io.readText(path));
 				if (aggregate) try {
@@ -478,7 +513,9 @@ var EvolutionFeedback = class {
 			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,
@@ -513,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) {}
 		});
 	}
@@ -540,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 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 {}
+			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.71",
+  "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.71",
-    "@lmzhen/dsh-skill-usage": "^0.1.0-rc.71"
+    "@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.71",
-    "@lmzhen/dsh-evolution-io-node": "^0.1.0-rc.71",
-    "@lmzhen/dsh-skill-usage": "^0.1.0-rc.71"
+    "@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"
   }
 }