@lmzhen/dsh-evolution-replay 0.3.66 → 0.3.68

package/lib/index.js

@@ -1,5 +1,6 @@
 import z from "@deepseek-ai/schemastery";
-import { clampedNumber } from "@lmzhen/dsh-evolution-core";
+import { clampedNumber, evolutionHome, evolutionIoAdapter } from "@lmzhen/dsh-evolution-core";
+import { loadActivity } from "@lmzhen/dsh-evolution-activity";
 //#region lib/types/index.js
 /**
 * Replay/A-B evaluation for evolution plans.
@@ -8,9 +9,16 @@ import { clampedNumber } from "@lmzhen/dsh-evolution-core";
 * driver records every `evolution/plan-applied` process event (payload v2,
 * with sessionId) into an in-memory leaderboard and exposes `/evolution
 * replay` (via the `/evolution` command family) for comparison, so a human can
-* A/B review policy/prompt changes against real plan outcomes. Durability
-* across restarts is the evolution-activity store's job; this leaderboard is
-* deliberately in-memory.
+* A/B review policy/prompt changes against real plan outcomes.
+*
+* V24-13 (v24): the in-memory leaderboard is BACKFILLED at mount from the
+* `evolution-activity` sidecar (`$DSH_HOME/evolution/activity.json`) — the
+* header previously claimed "durability across restarts is the
+* evolution-activity store's job" while nothing ever read the sidecar, so a
+* restart emptied `/evolution replay` and the persisted history sat unread.
+* Records are fed in sidecar order (oldest first); the driver's `maxPlans`
+* window keeps the newest. Best-effort: a missing/unreadable sidecar starts
+* the leaderboard empty, exactly as before.
 * @module @lmzhen/dsh-evolution-replay
 */
 const DEFAULT_WEIGHTS = {
@@ -80,9 +88,26 @@ function comparePlans(plans, weights = DEFAULT_WEIGHTS) {
 		report: scored.map(({ plan, score }) => `${plan.policyId}: ${score.toFixed(1)} (${plan.acceptedOps} accepted, ${plan.rejectedOps} rejected${(plan.executionFailures ?? 0) > 0 ? `, ${plan.executionFailures} failed${plan.executionError !== void 0 ? `: ${plan.executionError}` : ""}` : ""})`).join("\n")
 	};
 }
-var EvolutionReplayDriver = class {
+var EvolutionReplayDriver = class EvolutionReplayDriver {
 	plans = [];
 	maxPlans;
+	/** V25-01 (v25): backfill-once latch — see {@link EvolutionReplayDriver.backfill}. */
+	backfilled = false;
+	/** V26-05 (v25): plan ids recorded live BEFORE the backfill settled. A
+	* plan-applied landing inside the one-shot `loadActivity` read window is
+	* recorded live AND persisted into the sidecar the backfill is reading —
+	* `backfill()` drops those ids so the event is not counted twice.
+	*
+	* V27 INS-05: the set is BOUNDED. `backfill()` is the only place that cleared
+	* it, so a sidecar load that never succeeded (the inject callback's catch
+	* warns and does not retry until the io dependency is replaced) let every
+	* live plan id accumulate for the process lifetime. Past
+	* PRE_BACKFILL_ID_CAP the oldest ids are dropped: the dedupe window is then
+	* finite, and a dropped duplicate can at worst repeat an entry inside the
+	* `maxPlans` window instead of growing memory without bound. */
+	preBackfillIds = /* @__PURE__ */ new Set();
+	/** Upper bound on {@link EvolutionReplayDriver.preBackfillIds} (V27 INS-05). */
+	static PRE_BACKFILL_ID_CAP = 4096;
 	weights;
 	constructor(config = {}, warn = () => {}) {
 		const maxPlans = clampedNumber(config.maxPlans ?? 50, 50, { min: 1 });
@@ -96,6 +121,14 @@ var EvolutionReplayDriver = class {
 		}
 	}
 	record(plan) {
+		if (!this.backfilled) {
+			this.preBackfillIds.add(plan.planId);
+			while (this.preBackfillIds.size > EvolutionReplayDriver.PRE_BACKFILL_ID_CAP) {
+				const oldest = this.preBackfillIds.keys().next().value;
+				if (oldest === void 0) break;
+				this.preBackfillIds.delete(oldest);
+			}
+		}
 		const count = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
 		const countOr = (value, fallback) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
 		const memoryApplied = count(plan.memoryApplied);
@@ -114,6 +147,22 @@ var EvolutionReplayDriver = class {
 		if (this.plans.length > this.maxPlans) this.plans.shift();
 	}
 	/**
+	* V25-01 (v25): backfill the leaderboard from the activity sidecar, ONCE
+	* per driver instance. The inject callback that loads the sidecar re-runs
+	* whenever the `evolutionIo` dependency is replaced (cordis derived-fiber
+	* reload — plugin restart / HMR) while THIS driver survives at the apply
+	* scope, so the dedupe guard must live here, not in the callback: without
+	* it, every io reload doubled the leaderboard entries.
+	* @param items - activity records in sidecar order (oldest first).
+	*/
+	backfill(items) {
+		if (this.backfilled) return;
+		this.backfilled = true;
+		const fresh = items.filter((item) => !this.preBackfillIds.has(item.planId));
+		this.preBackfillIds.clear();
+		for (const item of fresh) this.record(item);
+	}
+	/**
 	* F-11: test-support API — no production consumer reads the raw
 	* plan list (the leaderboard path goes through `compare()`); tests use this
 	* as a read/inspection window. Kept by declaration (same posture as the
@@ -137,6 +186,15 @@ function apply(ctx, rawConfig = {}) {
 	ctx.on("evolution/plan-applied", (event) => {
 		driver.record(event);
 	});
+	ctx.inject(["evolutionIo"], (ioCtx) => {
+		const ioRegistry = ioCtx.evolutionIo;
+		const io = evolutionIoAdapter(() => ioRegistry.provider());
+		loadActivity(evolutionHome(), io).then((items) => {
+			driver.backfill(items);
+		}).catch((error) => {
+			ioCtx.logger.warn(`evolution-replay: activity sidecar backfill skipped (${error instanceof Error ? error.message : String(error)})`);
+		});
+	});
 }
 //#endregion
 export { Config, DEFAULT_WEIGHTS, EvolutionReplayDriver, apply, clampReplayWeights, comparePlans, name };

package/lib/types/index.d.ts

@@ -5,9 +5,16 @@
  * driver records every `evolution/plan-applied` process event (payload v2,
  * with sessionId) into an in-memory leaderboard and exposes `/evolution
  * replay` (via the `/evolution` command family) for comparison, so a human can
- * A/B review policy/prompt changes against real plan outcomes. Durability
- * across restarts is the evolution-activity store's job; this leaderboard is
- * deliberately in-memory.
+ * A/B review policy/prompt changes against real plan outcomes.
+ *
+ * V24-13 (v24): the in-memory leaderboard is BACKFILLED at mount from the
+ * `evolution-activity` sidecar (`$DSH_HOME/evolution/activity.json`) — the
+ * header previously claimed "durability across restarts is the
+ * evolution-activity store's job" while nothing ever read the sidecar, so a
+ * restart emptied `/evolution replay` and the persisted history sat unread.
+ * Records are fed in sidecar order (oldest first); the driver's `maxPlans`
+ * window keeps the newest. Best-effort: a missing/unreadable sidecar starts
+ * the leaderboard empty, exactly as before.
  * @module @lmzhen/dsh-evolution-replay
  */
 import type { Context } from '@deepseek-ai/cordis';
@@ -61,9 +68,36 @@ declare module '@deepseek-ai/cordis' {
 export declare class EvolutionReplayDriver {
     private readonly plans;
     private readonly maxPlans;
+    /** V25-01 (v25): backfill-once latch — see {@link EvolutionReplayDriver.backfill}. */
+    private backfilled;
+    /** V26-05 (v25): plan ids recorded live BEFORE the backfill settled. A
+     * plan-applied landing inside the one-shot `loadActivity` read window is
+     * recorded live AND persisted into the sidecar the backfill is reading —
+     * `backfill()` drops those ids so the event is not counted twice.
+     *
+     * V27 INS-05: the set is BOUNDED. `backfill()` is the only place that cleared
+     * it, so a sidecar load that never succeeded (the inject callback's catch
+     * warns and does not retry until the io dependency is replaced) let every
+     * live plan id accumulate for the process lifetime. Past
+     * PRE_BACKFILL_ID_CAP the oldest ids are dropped: the dedupe window is then
+     * finite, and a dropped duplicate can at worst repeat an entry inside the
+     * `maxPlans` window instead of growing memory without bound. */
+    private readonly preBackfillIds;
+    /** Upper bound on {@link EvolutionReplayDriver.preBackfillIds} (V27 INS-05). */
+    private static readonly PRE_BACKFILL_ID_CAP;
     private readonly weights;
     constructor(config?: Config, warn?: (message: string) => void);
     record(plan: EvolutionPlanAppliedEvent): void;
+    /**
+     * V25-01 (v25): backfill the leaderboard from the activity sidecar, ONCE
+     * per driver instance. The inject callback that loads the sidecar re-runs
+     * whenever the `evolutionIo` dependency is replaced (cordis derived-fiber
+     * reload — plugin restart / HMR) while THIS driver survives at the apply
+     * scope, so the dedupe guard must live here, not in the callback: without
+     * it, every io reload doubled the leaderboard entries.
+     * @param items - activity records in sidecar order (oldest first).
+     */
+    backfill(items: ReadonlyArray<import('@lmzhen/dsh-evolution-activity').EvolutionActivityRecord>): void;
     /**
      * F-11: test-support API — no production consumer reads the raw
      * plan list (the leaderboard path goes through `compare()`); tests use this

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-replay",
   "description": "Replay/A-B evaluation primitives for evolution plans (community build)",
-  "version": "0.3.66",
+  "version": "0.3.68",
   "publishConfig": {
     "access": "public"
   },
@@ -31,7 +31,8 @@
   "license": "MIT",
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.1",
-    "@lmzhen/dsh-evolution-core": "^0.3.66"
+    "@lmzhen/dsh-evolution-activity": "^0.3.68",
+    "@lmzhen/dsh-evolution-core": "^0.3.68"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
@@ -39,6 +40,7 @@
   },
   "devDependencies": {
     "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2",
-    "@lmzhen/dsh-evolution-core": "^0.3.66"
+    "@lmzhen/dsh-evolution-activity": "^0.3.68",
+    "@lmzhen/dsh-evolution-core": "^0.3.68"
   }
 }