@lmzhen/dsh-evolution-feedback 0.3.73 → 0.3.76

package/README.md

@@ -23,3 +23,5 @@ Independent of request-prefix construction. This package does not alter the asse
 
 - Persists through the IO seam; quality propagation into skill usage requires the `skillUsage` service.
 - P1-1 (v15): feedback writes the FEEDBACK-OWNED `feedback_score`/`feedback_warn` usage fields. The lifecycle engine and the scope view read the union `quality_warn || feedback_warn`, so a negative feedback shortens the stale window even though the curator's six-factor run always recomputes `quality_warn` itself.
+
+**Runtime invariant:** No companion is published. The platform auto-assembles nothing and the family mounts no `<pkg>/invariant` cordis row, so a companion here would never execute (v37 S2.1 / I-3).

package/lib/index.js

@@ -97,7 +97,9 @@ var EvolutionFeedback = class EvolutionFeedback {
 					await migrateFeedbackEvents(io, eventsPath, aggregate, this.warn);
 				} catch {}
 			}
-			const { events } = await readEvolutionTimeline(io, eventsPath, archiveNames);
+			const initial = await readEvolutionTimeline(io, eventsPath, archiveNames);
+			const lateArchives = (await listEventArchives(io, eventsPath)).filter((name) => !archiveNames.includes(name));
+			const events = lateArchives.length === 0 ? initial.events : (await readEvolutionTimeline(io, eventsPath, [...archiveNames, ...lateArchives])).events;
 			const cache = parseCache(rawCache, this.warn);
 			const maxSeq = events.reduce((max, event) => Math.max(max, event.seq), 0);
 			const floor = events[0]?.seq ?? 0;
@@ -256,10 +258,19 @@ var EvolutionFeedback = class EvolutionFeedback {
 			const { events } = await readEvolutionTimeline(recordIo, eventsPath);
 			const maxSeq = events.reduce((max, event) => Math.max(max, event.seq), 0);
 			if (maxSeq === 0) return;
+			let rawCache;
+			try {
+				rawCache = await recordIo.readText(path);
+			} catch {
+				return;
+			}
+			const cache = parseCache(rawCache, this.warn);
+			const floor = events[0]?.seq ?? 0;
+			const state = cache && cache.lastSeq >= floor - 1 ? foldWithDelta(cache, events, this.warn) : foldFeedbackState(events, this.warn);
 			const body = JSON.stringify({
 				version: CACHE_VERSION,
 				lastSeq: maxSeq,
-				...foldFeedbackState(events, this.warn)
+				...state
 			}, null, 2);
 			await recordIo.writeText(path, body);
 		} catch {}
@@ -272,27 +283,44 @@ var EvolutionFeedback = class EvolutionFeedback {
 		});
 	}
 };
-/** 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) {
+/** Semantic identity of one event: `seq` and `at` are excluded (a merge
+* shifts seqs, a re-synthesis stamps a different `at`), so type/kind/target/
+* rating/note is everything a fold can see. */
+function sameSemantics(a, b) {
+	return a.type === b.type && a.kind === b.kind && a.target === b.target && a.rating === b.rating && a.note === b.note;
+}
+/** True when `existing` already carries the WHOLE legacy batch (the skip case).
+* P1-8 (v37): counted as a MULTISET, never as a contiguous run — the
+* synthesizer emits "all positives, then all negatives" per target while the
+* real log is in temporal order, so the run-based gate read an already-migrated
+* log as unmigrated and re-appended the whole history (3 events became 6, and
+* every further boot doubled it again). */
+function containsLegacyMultiset(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;
+	const pool = [...existing];
+	for (const event of expected) {
+		const at = pool.findIndex((candidate) => sameSemantics(candidate, event));
+		if (at < 0) return false;
+		pool.splice(at, 1);
+	}
+	return true;
+}
+/** True when the body the migration transact just read may be written over:
+* absent or blank (the append path's own "missing" definition), or a v1 body
+* this reader can actually interpret. `parseEvolutionEvents` maps a corrupt or
+* future-version body to an EMPTY timeline, so without this gate a read failure
+* would be folded as "nothing was ever migrated" and the synthesized log would
+* overwrite bytes the append path refuses to touch. */
+function isReadableEventBody(current) {
+	if (current === null || current.trim() === "") return true;
+	try {
+		const parsed = JSON.parse(current);
+		if (!isRecord(parsed)) return false;
+		if (parsed.version !== void 0 && parsed.version !== EVENT_LOG_VERSION) return false;
+		return Array.isArray(parsed.events);
+	} catch {
+		return false;
 	}
-	return false;
 }
 /**
 * Merge a legacy aggregate into the event log (rc.69): the expected synthetic
@@ -311,8 +339,12 @@ async function migrateFeedbackEvents(io, eventsPath, aggregate, warn = () => {})
 		return;
 	}
 	await transactIo(io, eventsPath, (current) => {
+		if (!isReadableEventBody(current)) {
+			warn("evolution-feedback: migration left unreadable event-log bytes untouched (neither migrated nor overwritten)");
+			return Promise.resolve(current);
+		}
 		const existing = parseEvolutionEvents(current);
-		if (containsLegacySequence(existing, expected)) return Promise.resolve(current);
+		if (containsLegacyMultiset(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,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-feedback",
   "description": "Feedback-to-quality scoring for self-evolution (community build)",
-  "version": "0.3.73",
+  "version": "0.3.76",
   "publishConfig": {
     "access": "public"
   },
@@ -18,10 +18,6 @@
       "types": "./lib/types/index.d.ts",
       "default": "./lib/index.js"
     },
-    "./invariant": {
-      "types": "./lib/types/invariant.d.ts",
-      "default": "./lib/invariant.js"
-    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -31,18 +27,16 @@
   "license": "MIT",
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.1",
-    "@lmzhen/dsh-evolution-core": "^0.3.73"
+    "@lmzhen/dsh-evolution-core": "^0.3.76"
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-invariants": "^0.1.5-rc.2",
     "@deepseek-ai/cordis": "^4.0.1",
-    "@lmzhen/dsh-evolution-io": "^0.3.73",
-    "@lmzhen/dsh-skill-usage": "^0.3.73"
+    "@lmzhen/dsh-evolution-io": "^0.3.76",
+    "@lmzhen/dsh-skill-usage": "^0.3.76"
   },
   "devDependencies": {
-    "@deepseek-ai/dsh-invariants": "^0.1.5-rc.2",
-    "@lmzhen/dsh-evolution-io": "^0.3.73",
-    "@lmzhen/dsh-evolution-io-node": "^0.3.73",
-    "@lmzhen/dsh-skill-usage": "^0.3.73"
+    "@lmzhen/dsh-evolution-io": "^0.3.76",
+    "@lmzhen/dsh-evolution-io-node": "^0.3.76",
+    "@lmzhen/dsh-skill-usage": "^0.3.76"
   }
 }

package/lib/invariant.js

@@ -1,8 +0,0 @@
-//#region lib/types/invariant.js
-const PACKAGE_NAME = "@lmzhen/dsh-evolution-feedback";
-const name = "evolution-feedback-invariant";
-const inject = ["invariants"];
-const install = () => {};
-const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
-//#endregion
-export { apply, inject, name };

package/lib/types/invariant.d.ts

@@ -1,5 +0,0 @@
-import type { Context } from '@deepseek-ai/cordis';
-export declare const name = "evolution-feedback-invariant";
-export declare const inject: string[];
-export declare const apply: (ctx: Context) => Promise<() => void>;
-//# sourceMappingURL=invariant.d.ts.map