@lmzhen/dsh-evolution-feedback 0.1.0-rc.68 → 0.1.0-rc.69

package/lib/index.js

@@ -47,8 +47,13 @@ function eventsFile(home) {
 function isEventRecord(event) {
 	return typeof event === "object" && event !== null && typeof event.seq === "number";
 }
-function parseEventList(raw) {
-	if (raw === null) return [];
+/**
+* Parse an event log body. A missing file, a whitespace-only file (rc.69:
+* rebuildable, NOT malformed) or a corrupt one reads as empty; corrupt content
+* is still refused on append, never overwritten.
+*/
+function parseEvolutionEvents(raw) {
+	if (raw === null || raw.trim() === "") return [];
 	try {
 		const parsed = JSON.parse(raw);
 		if (!Array.isArray(parsed.events)) return [];
@@ -66,12 +71,12 @@ function parseEventList(raw) {
 async function appendEvolutionEvent(io, path, event) {
 	let assigned = 0;
 	await transactIo(io, path, (current) => {
-		if (current !== null) try {
+		if (current !== null && current.trim() !== "") try {
 			JSON.parse(current);
 		} catch {
 			return Promise.resolve(current);
 		}
-		const events = parseEventList(current);
+		const events = parseEvolutionEvents(current);
 		const maxSeq = events.reduce((max, entry) => Math.max(max, entry.seq), 0);
 		const record = {
 			...event,
@@ -87,10 +92,11 @@ async function appendEvolutionEvent(io, path, event) {
 	if (assigned === 0) throw new Error(`evolution event log is malformed and was not touched: ${path}`);
 	return assigned;
 }
-/** Read the event log; a missing file reads as empty, malformed is flagged. */
+/** 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);
-	if (raw === null) return {
+	if (raw === null || raw.trim() === "") return {
 		events: [],
 		malformed: false
 	};
@@ -381,16 +387,11 @@ var EvolutionFeedback = class {
 		const eventsPath = this.eventsPath;
 		if (!path || !eventsPath) return;
 		await this.mutate(async () => {
-			if (await io.readText(eventsPath) === null) {
+			const rawEvents = await io.readText(eventsPath);
+			if (rawEvents === null || rawEvents.trim() === "") {
 				const aggregate = parseAggregate(await io.readText(path));
 				if (aggregate) try {
-					await transactIo(io, eventsPath, (current) => {
-						if (current !== null) return Promise.resolve(current);
-						return Promise.resolve(JSON.stringify({
-							version: 1,
-							events: synthesizeFeedbackEvents(aggregate)
-						}, null, 2));
-					});
+					await migrateFeedbackEvents(io, eventsPath, aggregate);
 				} catch {}
 			}
 			const { events } = await readEvolutionEvents(io, eventsPath);
@@ -478,6 +479,53 @@ var EvolutionFeedback = class {
 		});
 	}
 };
+/** True when `existing` contains the legacy sequence as a contiguous run on
+* its semantic fields (skip case). `seq` and `at` are excluded: after a merge
+* the legacy events carry shifted seqs, and a re-synthesis stamps a different
+* `at` — the semantic identity is type/kind/target/rating/note. A coincidental
+* semantic match of an already-appended user sequence yields the identical
+* aggregation, so the skip is harmless for counts and notes. */
+function containsLegacySequence(existing, expected) {
+	if (expected.length === 0) return true;
+	for (let start = 0; start <= existing.length - expected.length; start += 1) {
+		let match = true;
+		for (let offset = 0; offset < expected.length; offset += 1) {
+			const a = expected[offset];
+			const b = existing[start + offset];
+			if (!a || !b || a.type !== b.type || a.kind !== b.kind || a.target !== b.target || a.rating !== b.rating || a.note !== b.note) {
+				match = false;
+				break;
+			}
+		}
+		if (match) return true;
+	}
+	return false;
+}
+/**
+* Merge a legacy aggregate into the event log (rc.69): the expected synthetic
+* sequence is APPENDED (seq-shifted) when the log does not already contain it
+* — so a concurrent first writer's events AND the legacy history both
+* survive; when the sequence is already present the migration was completed
+* (by a first writer or by this path) and nothing is re-appended. Idempotent
+* and race-safe (the search runs inside the same transact). Exported for the
+* migration-race regression test.
+*/
+async function migrateFeedbackEvents(io, eventsPath, aggregate) {
+	const expected = synthesizeFeedbackEvents(aggregate);
+	await transactIo(io, eventsPath, (current) => {
+		const existing = parseEvolutionEvents(current);
+		if (containsLegacySequence(existing, expected)) return Promise.resolve(current ?? "");
+		const maxSeq = existing.reduce((max, event) => Math.max(max, event.seq), 0);
+		const merged = [...existing, ...expected.map((event, index) => ({
+			...event,
+			seq: maxSeq + index + 1
+		}))];
+		return Promise.resolve(JSON.stringify({
+			version: 1,
+			events: merged
+		}, null, 2));
+	});
+}
 /** Parse a legacy aggregate (v1) or a v2 cache into a plain aggregate state. */
 function parseAggregate(raw) {
 	if (raw === null) return null;
@@ -612,4 +660,4 @@ function apply(ctx, rawConfig = {}) {
 	}, "evolution-feedback.records");
 }
 //#endregion
-export { Config, EvolutionFeedback, apply, name };
+export { Config, EvolutionFeedback, apply, migrateFeedbackEvents, name };

package/lib/types/index.d.ts

@@ -47,12 +47,23 @@ export declare class EvolutionFeedback {
     /** Rebuild the boot cache from the log truth (rc.68); best-effort. */
     persistCache(): Promise<void>;
 }
+/**
+ * Merge a legacy aggregate into the event log (rc.69): the expected synthetic
+ * sequence is APPENDED (seq-shifted) when the log does not already contain it
+ * — so a concurrent first writer's events AND the legacy history both
+ * survive; when the sequence is already present the migration was completed
+ * (by a first writer or by this path) and nothing is re-appended. Idempotent
+ * and race-safe (the search runs inside the same transact). Exported for the
+ * migration-race regression test.
+ */
+export declare function migrateFeedbackEvents(io: IoLike, eventsPath: string, aggregate: FeedbackState): Promise<void>;
 export declare const name = "evolution-feedback";
 export interface Config {
     /** Score below which curator receives quality_warn for a skill. */
     qualityWarnThreshold?: number;
-    /** Explicit boot-cache file path; empty derives $DSH_HOME/evolution/feedback.json
-     * (the event log is its sibling `events.json`). */
+    /** Explicit boot-cache file path; empty derives $DSH_HOME/evolution/feedback.json.
+     * The event log always stays at $DSH_HOME/evolution/events.json (derived from
+     * home, never from this override). */
     path?: string;
 }
 export declare const Config: z<Config>;

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.68",
+  "version": "0.1.0-rc.69",
   "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.68",
-    "@lmzhen/dsh-skill-usage": "^0.1.0-rc.68"
+    "@lmzhen/dsh-evolution-io": "^0.1.0-rc.69",
+    "@lmzhen/dsh-skill-usage": "^0.1.0-rc.69"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2",
-    "@lmzhen/dsh-evolution-io": "^0.1.0-rc.68",
-    "@lmzhen/dsh-evolution-io-node": "^0.1.0-rc.68",
-    "@lmzhen/dsh-skill-usage": "^0.1.0-rc.68"
+    "@lmzhen/dsh-evolution-io": "^0.1.0-rc.69",
+    "@lmzhen/dsh-evolution-io-node": "^0.1.0-rc.69",
+    "@lmzhen/dsh-skill-usage": "^0.1.0-rc.69"
   }
 }