@lmzhen/dsh-evolution-feedback 0.3.16 → 0.3.18

package/lib/index.js

@@ -38,6 +38,10 @@ function evolutionIoAdapter(provider) {
 		isSymlink: (path) => {
 			const io = provider();
 			return io.isSymlink ? io.isSymlink(path) : Promise.resolve(null);
+		},
+		mtime: (path) => {
+			const io = provider();
+			return io.mtime ? io.mtime(path) : Promise.resolve(null);
 		}
 	};
 }
@@ -2870,11 +2874,15 @@ var EvolutionFeedback = class {
 	path;
 	eventsPath;
 	io;
-	constructor(io, home = process.env.DSH_HOME ?? join(homedir(), ".dsh"), pathOverride) {
-		if (io) {
-			this.path = pathOverride ?? join(home, "evolution", "feedback.json");
-			this.eventsPath = eventsFile(home);
-		}
+	warn;
+	constructor(io, home = process.env.DSH_HOME ?? join(homedir(), ".dsh"), pathOverride, warn = () => {}) {
+		this.path = pathOverride ?? join(home, "evolution", "feedback.json");
+		this.eventsPath = eventsFile(home);
+		this.io = io;
+		this.warn = warn;
+	}
+	/** Bind the evolution IO backend after construction (S6.4 deferred binding). */
+	attachIo(io) {
 		this.io = io;
 	}
 	mutate(task) {
@@ -2896,11 +2904,11 @@ var EvolutionFeedback = class {
 				} catch {}
 			}
 			const { events } = await readEvolutionTimeline(io, eventsPath);
-			const cache = parseCache(await io.readText(path));
+			const cache = parseCache(await io.readText(path), this.warn);
 			const maxSeq = events.reduce((max, event) => Math.max(max, event.seq), 0);
 			const floor = events[0]?.seq ?? 0;
 			const usableCache = cache && cache.lastSeq >= floor - 1 ? cache : null;
-			const truth = usableCache ? foldWithDelta(usableCache, events) : foldFeedbackState(events);
+			const truth = usableCache ? foldWithDelta(usableCache, events, this.warn) : foldFeedbackState(events, this.warn);
 			this.state = {
 				skills: {
 					...truth.skills,
@@ -2927,6 +2935,7 @@ var EvolutionFeedback = class {
 			positive: 0,
 			negative: 0
 		};
+		const previousNote = current.lastNote;
 		current[rating] += 1;
 		if (note !== void 0) current.lastNote = note;
 		table[target] = current;
@@ -2942,7 +2951,14 @@ var EvolutionFeedback = class {
 					rating,
 					note
 				}) % CACHE_SNAP_EVERY === 0) await this.writeCacheNow();
-			} catch (error) {}
+			} catch (error) {
+				const rollback = table[target];
+				if (rollback) {
+					rollback[rating] -= 1;
+					if (note !== void 0) if (previousNote === void 0) delete rollback.lastNote;
+					else rollback.lastNote = previousNote;
+				}
+			}
 		});
 	}
 	score(target, kind = "session") {
@@ -2972,11 +2988,12 @@ var EvolutionFeedback = class {
 			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({
+			const body = JSON.stringify({
 				version: CACHE_VERSION,
 				lastSeq: maxSeq,
-				...foldFeedbackState(events)
-			}, null, 2));
+				...foldFeedbackState(events, this.warn)
+			}, null, 2);
+			await recordIo.writeText(path, body);
 		} catch {}
 	}
 	/** Rebuild the boot cache from the log truth (rc.68); best-effort, queued
@@ -3050,48 +3067,87 @@ function parseAggregate(raw) {
 		return null;
 	}
 }
-function parseCache(raw) {
+function parseCache(raw, warn = () => {}) {
 	if (raw === null) return null;
 	try {
 		const parsed = JSON.parse(raw);
-		if (parsed.version !== CACHE_VERSION || typeof parsed.lastSeq !== "number") return null;
+		if (parsed.version !== CACHE_VERSION || typeof parsed.lastSeq !== "number" || !Number.isFinite(parsed.lastSeq)) return null;
 		if (!isRecord(parsed.skills) || !isRecord(parsed.sessions)) return null;
 		return {
 			lastSeq: parsed.lastSeq,
 			state: {
-				skills: parsed.skills,
-				sessions: parsed.sessions
+				skills: sanitizeCacheRecords(parsed.skills, "skill", warn),
+				sessions: sanitizeCacheRecords(parsed.sessions, "session", warn)
 			}
 		};
 	} catch {
 		return null;
 	}
 }
+/** Per-record numeric-domain validation (S6.4): a record whose `positive` or
+* `negative` is not a finite number >= 0, or whose `lastNote` is not a string,
+* would fold as NaN into the usage aggregate — skip it with a warn instead of
+* corrupting the state. A record with no valid count is dropped entirely. */
+function sanitizeCacheRecords(input, kind, warn) {
+	const out = {};
+	for (const [target, value] of Object.entries(input)) {
+		const record = sanitizeFeedbackRecord(value, target, kind, warn);
+		if (record) out[target] = record;
+	}
+	return out;
+}
+function sanitizeFeedbackRecord(value, target, kind, warn) {
+	if (!isRecord(value)) {
+		warn(`evolution-feedback: skipping cache record for ${kind} "${target}": not a record`);
+		return null;
+	}
+	const positive = value.positive;
+	const negative = value.negative;
+	const note = value.lastNote;
+	const validCount = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0;
+	if (!validCount(positive) || !validCount(negative)) {
+		warn(`evolution-feedback: skipping cache record for ${kind} "${target}": positive/negative must be finite numbers >= 0`);
+		return null;
+	}
+	if (note !== void 0 && typeof note !== "string") {
+		warn(`evolution-feedback: skipping cache record for ${kind} "${target}": lastNote must be a string`);
+		return null;
+	}
+	return {
+		positive,
+		negative,
+		...note !== void 0 ? { lastNote: note } : {}
+	};
+}
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /** Fold all feedback events from zero (the truth view). */
-function foldFeedbackState(events) {
+function foldFeedbackState(events, warn = () => {}) {
 	const state = {
 		skills: {},
 		sessions: {}
 	};
-	for (const event of events) applyFeedbackEvent(state, event);
+	for (const event of events) applyFeedbackEvent(state, event, warn);
 	return state;
 }
 /** Fold events after the cache's lastSeq onto the cached aggregates. */
-function foldWithDelta(cache, events) {
+function foldWithDelta(cache, events, warn = () => {}) {
 	const state = {
 		skills: { ...cache.state.skills },
 		sessions: { ...cache.state.sessions }
 	};
-	for (const event of events) if (event.seq > cache.lastSeq) applyFeedbackEvent(state, event);
+	for (const event of events) if (event.seq > cache.lastSeq) applyFeedbackEvent(state, event, warn);
 	return state;
 }
-function applyFeedbackEvent(state, event) {
+function applyFeedbackEvent(state, event, warn = () => {}) {
 	if (event.type !== "feedback") return;
+	if (event.rating !== "positive" && event.rating !== "negative") {
+		warn(`evolution-feedback: skipping feedback event with invalid rating: ${String(event.rating)}`);
+		return;
+	}
 	const target = event.target;
-	if (target === void 0 || event.rating === void 0) return;
+	if (target === void 0) return;
 	const table = event.kind === "skill" ? state.skills : state.sessions;
 	const record = table[target] ?? {
 		positive: 0,
@@ -3101,7 +3157,9 @@ function applyFeedbackEvent(state, event) {
 	if (event.note !== void 0) record.lastNote = event.note;
 	table[target] = record;
 }
-/** Synthesize one event per aggregate count unit, lastNote on the final event (migration). */
+/** Synthesize one event per aggregate count unit, lastNote on the final event
+* (migration). A zero-count record still carrying a lastNote would otherwise
+* drop the note — emit a dedicated note event (S6.4) so it survives. */
 function synthesizeFeedbackEvents(aggregate) {
 	const events = [];
 	const at = (/* @__PURE__ */ new Date()).toISOString();
@@ -3123,14 +3181,22 @@ function synthesizeFeedbackEvents(aggregate) {
 			target,
 			rating: "negative"
 		});
-		if (record.lastNote !== void 0 && events.length >= first) {
+		if (record.lastNote !== void 0) if (events.length >= first) {
 			const last = events.length - 1;
 			const final = events[last];
 			if (final) events[last] = {
 				...final,
 				note: record.lastNote
 			};
-		}
+		} else events.push({
+			seq: events.length + 1,
+			at,
+			type: "feedback",
+			kind,
+			target,
+			rating: "positive",
+			note: record.lastNote
+		});
 	};
 	for (const [target, record] of Object.entries(aggregate.skills)) emitTarget("skill", target, record);
 	for (const [target, record] of Object.entries(aggregate.sessions)) emitTarget("session", target, record);
@@ -3142,27 +3208,35 @@ const Config = z.object({
 	path: z.string().default("")
 });
 function apply(ctx, rawConfig = {}) {
-	const ioRegistry = ctx.get("evolutionIo");
-	const io = ioRegistry ? evolutionIoAdapter(() => ioRegistry.provider()) : void 0;
-	const feedback = new EvolutionFeedback(io, process.env.DSH_HOME ?? join(homedir(), ".dsh"), rawConfig.path || void 0);
-	if (io) feedback.restore(io).catch((error) => {
-		ctx.logger.warn(error);
+	const feedback = new EvolutionFeedback(void 0, process.env.DSH_HOME ?? join(homedir(), ".dsh"), rawConfig.path || void 0, (message) => {
+		ctx.logger.warn(message);
 	});
 	ctx.provide("evolutionFeedback", feedback);
-	const skillUsage = ctx.get("skillUsage");
-	if (skillUsage) {
-		const original = feedback.record.bind(feedback);
+	ctx.inject(["evolutionIo"], (ioCtx) => {
+		const ioRegistry = ioCtx.evolutionIo;
+		const io = evolutionIoAdapter(() => ioRegistry.provider());
+		feedback.attachIo(io);
+		feedback.restore(io).catch((error) => {
+			ioCtx.logger.warn(error);
+		});
+	});
+	const baseRecord = feedback.record.bind(feedback);
+	let qualityWired = false;
+	ctx.inject(["skillUsage"], (skillCtx) => {
+		if (qualityWired) return;
+		qualityWired = true;
+		const skillUsage = skillCtx.skillUsage;
 		feedback.record = (target, rating, note, kind) => {
-			original(target, rating, note, kind ?? "session");
+			baseRecord(target, rating, note, kind ?? "session");
 			if (kind === "skill") {
 				const score = feedback.score(target, "skill");
 				const warn = score < (rawConfig.qualityWarnThreshold ?? -.25);
 				skillUsage.setQuality(target, score, warn).catch((error) => {
-					ctx.logger.warn(error);
+					skillCtx.logger.warn(error);
 				});
 			}
 		};
-	}
+	});
 	ctx.effect(() => () => {
 		return Promise.all([feedback.persistCache(), feedback.waitIdle()]);
 	}, "evolution-feedback.records");

package/lib/types/index.d.ts

@@ -35,8 +35,11 @@ export declare class EvolutionFeedback {
     private chain;
     private readonly path?;
     private readonly eventsPath?;
-    private readonly io;
-    constructor(io?: IoLike, home?: string, pathOverride?: string);
+    private io;
+    private warn;
+    constructor(io?: IoLike, home?: string, pathOverride?: string, warn?: (message: string) => void);
+    /** Bind the evolution IO backend after construction (S6.4 deferred binding). */
+    attachIo(io: IoLike): void;
     private mutate;
     restore(io: IoLike): Promise<void>;
     record(target: string, rating: 'positive' | 'negative', note?: string, kind?: 'skill' | 'session'): 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.3.16",
+  "version": "0.3.18",
   "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.3.16",
-    "@lmzhen/dsh-skill-usage": "^0.3.16"
+    "@lmzhen/dsh-evolution-io": "^0.3.18",
+    "@lmzhen/dsh-skill-usage": "^0.3.18"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2",
-    "@lmzhen/dsh-evolution-io": "^0.3.16",
-    "@lmzhen/dsh-evolution-io-node": "^0.3.16",
-    "@lmzhen/dsh-skill-usage": "^0.3.16"
+    "@lmzhen/dsh-evolution-io": "^0.3.18",
+    "@lmzhen/dsh-evolution-io-node": "^0.3.18",
+    "@lmzhen/dsh-skill-usage": "^0.3.18"
   }
 }