@lmzhen/dsh-evolution-feedback 0.3.81 → 0.3.83

package/README.md

@@ -1,4 +1,4 @@
-# @deepseek-ai/dsh-evolution-feedback
+# @lmzhen/dsh-evolution-feedback
 
 Feedback-to-quality scoring for self-evolution
 
@@ -8,7 +8,7 @@ Feedback-to-quality scoring for self-evolution
 
 #### What the model sees
 
-`@deepseek-ai/dsh-evolution-feedback` registers no direct prompt or tool schema itself. Model-visible effects are owned by the packages that consume this service.
+`@lmzhen/dsh-evolution-feedback` registers no direct prompt or tool schema itself. Model-visible effects are owned by the packages that consume this service.
 
 #### Token effect
 

package/lib/index.js

@@ -30,6 +30,17 @@ const CACHE_VERSION = 2;
 * 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;
+/** C-events-dispatch-1 (v43 audit): the timeline read flags a DROPPED band — an
+* unreadable archive (EISDIR/EACCES) or a body this v1 reader cannot interpret
+* (damaged, or a future version). The boot cache stores the fold BASELINE
+* (`lastSeq`), and `foldWithDelta` only folds `seq > lastSeq`, so folding a
+* truncated read back into it would seal the dropped band against every later
+* boot — the loss becomes unrecoverable without deleting the cache by hand.
+* Both cache writers withhold the refresh when that flag is set (the cache is
+* disposable by contract, so the last COMPLETE fold simply stays) and say so
+* through this ONE message, deduped to a single warn per process (V5-32) because
+* `refold()` re-runs `restore()` before every quality push. */
+const TRUNCATED_TIMELINE_WARN = "evolution-feedback: the evolution event timeline is TRUNCATED - at least one segment (an unreadable archive, or a body this v1 reader cannot interpret, e.g. a future version) was dropped, so the folded counts are incomplete; the boot cache was NOT updated (a truncated lastSeq would seal the missing band against every later boot)";
 var EvolutionFeedback = class EvolutionFeedback {
 	state = {
 		skills: {},
@@ -46,6 +57,21 @@ var EvolutionFeedback = class EvolutionFeedback {
 	* unpersisted note there, and reverting to it resurrects a value the log
 	* never held). Seeded from the fold truth, updated on successful appends. */
 	durableNote = /* @__PURE__ */ new Map();
+	/** PLAN S1.4 (2026-09-16): targets with a feedback append still IN FLIGHT,
+	* split by table, as a COUNT per target. record() increments before queueing
+	* the append and the append task decrements when it settles (landed or rolled
+	* back, finally), dropping the entry only at ZERO — the count covers exactly
+	* the optimistic window rc.66 meant to protect, including two appends for the
+	* same target in flight at once (review C-P2-1: a per-target boolean marker
+	* was cleared by the first settle, so a merge between the two appends folded
+	* the second append's increment away). restore() lets memory win ONLY for these targets — a settled
+	* target folds from the log truth, so another process's feedback for the
+	* same target (audit P1-3) is never overwritten by this process's stale
+	* record. */
+	pendingAppends = {
+		skills: /* @__PURE__ */ new Map(),
+		sessions: /* @__PURE__ */ new Map()
+	};
 	/** P2-32 (v11): process-level bound — every feedbacked session would
 	* otherwise keep one entry for the whole process lifetime (a name + note
 	* string per session); cap this map and drop the earliest-INSERTED entry on
@@ -74,6 +100,29 @@ var EvolutionFeedback = class EvolutionFeedback {
 	attachIo(io) {
 		this.io = io;
 	}
+	/** PLAN S4.6 (2026-09-16): whether a durable backend is attached — the
+	* plugin's quality push (`apply`) consults this before writing the
+	* feedback pair into the skill-usage sidecar. Same no-io posture as
+	* `record`/`refold`: without `ctx.evolutionIo` (when mounted) nothing may
+	* turn the optimistic in-memory aggregate into a durable side effect. */
+	get durable() {
+		return this.io !== void 0 && !!this.eventsPath;
+	}
+	/** V5-32 posture applied to the read side (C-events-dispatch-1, v43): an
+	* event a repeated read keeps reporting must not warn on each read —
+	* `refold()` calls `restore()` before every quality push. Shares the bounded
+	* `warnedMessages` set (and its FIFO eviction) with the append-failure warn.
+	* @param message - the warn text; identical text warns once per process.
+	*/
+	warnOnce(message) {
+		if (this.warnedMessages.has(message)) return;
+		if (this.warnedMessages.size >= this.WARNED_CAP) {
+			const oldest = this.warnedMessages.values().next().value;
+			if (oldest !== void 0) this.warnedMessages.delete(oldest);
+		}
+		this.warnedMessages.add(message);
+		this.warn(message);
+	}
 	/** Durable-note map key (V4-41): a target shares one record per mode. */
 	noteKey(mode, target) {
 		return `${mode}\u0000${target}`;
@@ -99,20 +148,31 @@ var EvolutionFeedback = class EvolutionFeedback {
 			}
 			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 later = lateArchives.length === 0 ? null : await readEvolutionTimeline(io, eventsPath, [...archiveNames, ...lateArchives]);
+			const events = later?.events ?? initial.events;
+			const truncated = initial.malformed || later?.malformed === true;
 			const cache = parseCache(rawCache, 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, this.warn) : foldFeedbackState(events, this.warn);
+			const pickPending = (mode) => {
+				const picked = {};
+				for (const [target, inFlight] of this.pendingAppends[mode]) {
+					if (inFlight <= 0) continue;
+					const record = this.state[mode][target];
+					if (record) picked[target] = record;
+				}
+				return picked;
+			};
 			this.state = {
 				skills: {
 					...truth.skills,
-					...this.state.skills
+					...pickPending("skills")
 				},
 				sessions: {
 					...truth.sessions,
-					...this.state.sessions
+					...pickPending("sessions")
 				}
 			};
 			const skillEntries = Object.entries(truth.skills);
@@ -129,7 +189,8 @@ var EvolutionFeedback = class EvolutionFeedback {
 				if (oldest === void 0) break;
 				this.durableNote.delete(oldest);
 			}
-			if (maxSeq > 0 && (!cache || cache.lastSeq < maxSeq)) try {
+			if (truncated) this.warnOnce(TRUNCATED_TIMELINE_WARN);
+			else if (maxSeq > 0 && (!cache || cache.lastSeq < maxSeq)) try {
 				await io.writeText(path, JSON.stringify({
 					version: CACHE_VERSION,
 					lastSeq: maxSeq,
@@ -175,6 +236,8 @@ var EvolutionFeedback = class EvolutionFeedback {
 		const recordIo = this.io;
 		const eventsPath = this.eventsPath;
 		if (!recordIo || !eventsPath) return;
+		const pending = this.pendingAppends[mode];
+		pending.set(target, (pending.get(target) ?? 0) + 1);
 		this.mutate(async () => {
 			try {
 				const seq = await appendEvolutionEvent(recordIo, eventsPath, {
@@ -215,6 +278,10 @@ var EvolutionFeedback = class EvolutionFeedback {
 					this.warn(message);
 				}
 				if (rollback) this.onRollback?.(target, kind);
+			} finally {
+				const remaining = (pending.get(target) ?? 1) - 1;
+				if (remaining > 0) pending.set(target, remaining);
+				else pending.delete(target);
 			}
 		});
 	}
@@ -255,7 +322,11 @@ var EvolutionFeedback = class EvolutionFeedback {
 		const recordIo = this.io;
 		if (!path || !eventsPath || !recordIo) return;
 		try {
-			const { events } = await readEvolutionTimeline(recordIo, eventsPath);
+			const { events, malformed } = await readEvolutionTimeline(recordIo, eventsPath);
+			if (malformed) {
+				this.warnOnce(TRUNCATED_TIMELINE_WARN);
+				return;
+			}
 			const maxSeq = events.reduce((max, event) => Math.max(max, event.seq), 0);
 			if (maxSeq === 0) return;
 			let rawCache;
@@ -584,6 +655,7 @@ function apply(ctx, rawConfig = {}) {
 		const skillUsage = skillCtx.skillUsage;
 		const pushQuality = (target, kind) => {
 			if (kind !== "skill") return;
+			if (!feedback.durable) return;
 			feedback.refold().then(() => {
 				const score = feedback.score(target, "skill");
 				const warn = score < qualityWarnThreshold;

package/lib/types/index.d.ts

@@ -50,6 +50,18 @@ export declare class EvolutionFeedback {
      * unpersisted note there, and reverting to it resurrects a value the log
      * never held). Seeded from the fold truth, updated on successful appends. */
     private readonly durableNote;
+    /** PLAN S1.4 (2026-09-16): targets with a feedback append still IN FLIGHT,
+     * split by table, as a COUNT per target. record() increments before queueing
+     * the append and the append task decrements when it settles (landed or rolled
+     * back, finally), dropping the entry only at ZERO — the count covers exactly
+     * the optimistic window rc.66 meant to protect, including two appends for the
+     * same target in flight at once (review C-P2-1: a per-target boolean marker
+     * was cleared by the first settle, so a merge between the two appends folded
+     * the second append's increment away). restore() lets memory win ONLY for these targets — a settled
+     * target folds from the log truth, so another process's feedback for the
+     * same target (audit P1-3) is never overwritten by this process's stale
+     * record. */
+    private readonly pendingAppends;
     /** P2-32 (v11): process-level bound — every feedbacked session would
      * otherwise keep one entry for the whole process lifetime (a name + note
      * string per session); cap this map and drop the earliest-INSERTED entry on
@@ -71,6 +83,19 @@ export declare class EvolutionFeedback {
     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;
+    /** PLAN S4.6 (2026-09-16): whether a durable backend is attached — the
+     * plugin's quality push (`apply`) consults this before writing the
+     * feedback pair into the skill-usage sidecar. Same no-io posture as
+     * `record`/`refold`: without `ctx.evolutionIo` (when mounted) nothing may
+     * turn the optimistic in-memory aggregate into a durable side effect. */
+    get durable(): boolean;
+    /** V5-32 posture applied to the read side (C-events-dispatch-1, v43): an
+     * event a repeated read keeps reporting must not warn on each read —
+     * `refold()` calls `restore()` before every quality push. Shares the bounded
+     * `warnedMessages` set (and its FIFO eviction) with the append-failure warn.
+     * @param message - the warn text; identical text warns once per process.
+     */
+    private warnOnce;
     /** Durable-note map key (V4-41): a target shares one record per mode. */
     private noteKey;
     private mutate;

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.81",
+  "version": "0.3.83",
   "publishConfig": {
     "access": "public"
   },
@@ -27,16 +27,16 @@
   "license": "MIT",
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.1",
-    "@lmzhen/dsh-evolution-core": "^0.3.81"
+    "@lmzhen/dsh-evolution-core": "^0.3.83"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@lmzhen/dsh-evolution-io": "^0.3.81",
-    "@lmzhen/dsh-skill-usage": "^0.3.81"
+    "@lmzhen/dsh-evolution-io": "^0.3.83",
+    "@lmzhen/dsh-skill-usage": "^0.3.83"
   },
   "devDependencies": {
-    "@lmzhen/dsh-evolution-io": "^0.3.81",
-    "@lmzhen/dsh-evolution-io-node": "^0.3.81",
-    "@lmzhen/dsh-skill-usage": "^0.3.81"
+    "@lmzhen/dsh-evolution-io": "^0.3.83",
+    "@lmzhen/dsh-evolution-io-node": "^0.3.83",
+    "@lmzhen/dsh-skill-usage": "^0.3.83"
   }
 }