@lmzhen/dsh-evolution-curator 0.3.62 → 0.3.64

package/lib/index.js

@@ -11,6 +11,13 @@ import { CURATOR_DRY_RUN_BANNER, CURATOR_PROMPT, DEFAULT_ARCHIVE_AFTER_DAYS, DEF
 */
 /** Quality-warned skills may turn stale after this many idle days (package-private tunable, P2-8). */
 const DEFAULT_QUALITY_WARN_STALE_AFTER_DAYS = 7;
+/** B-10 (v18): the optional LLM nomination pass gets its own timeout so a
+* hung/unresponsive provider cannot hold the control-plane mutex forever
+* (`run()` never returns; `restore()`/`consolidate()` queue behind it).
+* 120s matches the review subagent default; the 32-bit ceiling is Node's
+* timer-delay limit (`AbortSignal.timeout` throws above it). */
+const DEFAULT_CURATOR_REVIEW_TIMEOUT_MS = 12e4;
+const MAX_TIMER_DELAY_MS = 4294967295;
 /**
 * Block LLM-nominated consolidations that would touch a gate-protected name:
 * exclude / referenced / suppressed skills must never merge (neither as the
@@ -41,6 +48,7 @@ var EvolutionCurator = class extends Service {
 		autoStart: z.boolean().default(true),
 		bootGraceSeconds: z.number().min(0).default(DEFAULT_CURATOR_BOOT_GRACE_SECONDS),
 		curatorReviewMaxTokens: z.number().min(1).default(DEFAULT_CURATOR_REVIEW_MAX_TOKENS),
+		curatorReviewTimeoutMs: z.number().min(1).max(MAX_TIMER_DELAY_MS).default(DEFAULT_CURATOR_REVIEW_TIMEOUT_MS),
 		healthSoftBodyChars: z.number().min(1).default(DEFAULT_HEALTH_THRESHOLDS.softBodyChars),
 		healthStampDensityPerKb: z.number().min(1).default(DEFAULT_HEALTH_THRESHOLDS.stampDensityPerKb),
 		healthChurnMinPatches: z.number().min(1).default(DEFAULT_HEALTH_THRESHOLDS.churnMinPatches)
@@ -62,13 +70,23 @@ var EvolutionCurator = class extends Service {
 	referencedSkillNames;
 	bootGraceSeconds;
 	curatorReviewMaxTokens;
+	curatorReviewTimeoutMs;
 	healthSoftBodyChars;
 	healthStampDensityPerKb;
 	healthChurnMinPatches;
 	lastRun = 0;
 	timer;
+	/** B-8 (v18): set by the fiber disposer; a triggered autoCheck must not
+	* keep mutating the tree after the plugin was disposed. */
+	disposed = false;
+	/** B-8 (v18): read the disposal flag through a method. The only assignment
+	* lives in the disposer closure, which TypeScript's flow analysis cannot
+	* see, so a direct `this.disposed` read narrows to the literal `false` and
+	* the runtime check would be reported as dead code by `no-unnecessary-condition`. */
+	isDisposed() {
+		return this.disposed;
+	}
 	bootCheck;
-	running = false;
 	/** 0.3.18 (E-18): stateless first-run defer fires ONCE per process — the
 	* in-memory clock is seeded and later due runs must proceed, or the
 	* persisted===null defer repeats forever (no state service to persist). */
@@ -83,14 +101,21 @@ var EvolutionCurator = class extends Service {
 		});
 		this.enabled = config.enabled ?? true;
 		const clamped = [];
-		const field = (name, value, fallback, min) => {
-			const result = clampedNumber(value, fallback, { min });
+		const field = (name, value, fallback, min, max) => {
+			const result = clampedNumber(value, fallback, max === void 0 ? { min } : {
+				min,
+				max
+			});
 			if (value !== void 0 && result !== value) clamped.push(name);
 			return result;
 		};
 		this.intervalHours = field("intervalHours", config.intervalHours, DEFAULT_CURATOR_INTERVAL_HOURS, 1);
 		this.staleAfterDays = field("staleAfterDays", config.staleAfterDays, DEFAULT_STALE_AFTER_DAYS, 1);
 		this.archiveAfterDays = field("archiveAfterDays", config.archiveAfterDays, DEFAULT_ARCHIVE_AFTER_DAYS, 1);
+		if (this.archiveAfterDays < this.staleAfterDays) {
+			this.ctx.logger.warn(`evolution-curator: archiveAfterDays (${this.archiveAfterDays}) < staleAfterDays (${this.staleAfterDays}); using staleAfterDays as the archive threshold`);
+			this.archiveAfterDays = this.staleAfterDays;
+		}
 		this.llmReview = config.llmReview ?? false;
 		this.curatorProvider = config.curatorProvider ?? "deepseek-official";
 		this.qualityWarnStaleAfterDays = field("qualityWarnStaleAfterDays", config.qualityWarnStaleAfterDays, DEFAULT_QUALITY_WARN_STALE_AFTER_DAYS, 1);
@@ -100,8 +125,9 @@ var EvolutionCurator = class extends Service {
 		this.manageUnmanaged = config.manageUnmanaged ?? false;
 		this.pruneBuiltins = config.pruneBuiltins ?? false;
 		this.referencedSkillNames = new Set(config.referencedSkillNames ?? []);
-		this.bootGraceSeconds = field("bootGraceSeconds", config.bootGraceSeconds, DEFAULT_CURATOR_BOOT_GRACE_SECONDS, 0);
+		this.bootGraceSeconds = field("bootGraceSeconds", config.bootGraceSeconds, DEFAULT_CURATOR_BOOT_GRACE_SECONDS, 0, 3600);
 		this.curatorReviewMaxTokens = field("curatorReviewMaxTokens", config.curatorReviewMaxTokens, DEFAULT_CURATOR_REVIEW_MAX_TOKENS, 1);
+		this.curatorReviewTimeoutMs = field("curatorReviewTimeoutMs", config.curatorReviewTimeoutMs, DEFAULT_CURATOR_REVIEW_TIMEOUT_MS, 1, MAX_TIMER_DELAY_MS);
 		this.healthSoftBodyChars = field("healthSoftBodyChars", config.healthSoftBodyChars, DEFAULT_HEALTH_THRESHOLDS.softBodyChars, 1);
 		this.healthStampDensityPerKb = field("healthStampDensityPerKb", config.healthStampDensityPerKb, DEFAULT_HEALTH_THRESHOLDS.stampDensityPerKb, 1);
 		this.healthChurnMinPatches = field("healthChurnMinPatches", config.healthChurnMinPatches, DEFAULT_HEALTH_THRESHOLDS.churnMinPatches, 1);
@@ -109,6 +135,7 @@ var EvolutionCurator = class extends Service {
 		this.lastRun = Date.now();
 		this.ctx.effect(() => {
 			return () => {
+				this.disposed = true;
 				this.stop();
 			};
 		}, "evolution-curator.stop");
@@ -123,7 +150,7 @@ var EvolutionCurator = class extends Service {
 		};
 	}
 	start() {
-		if (!this.enabled || this.timer) return;
+		if (this.isDisposed() || !this.enabled || this.timer) return;
 		this.bootCheck = setTimeout(() => {
 			this.bootCheck = void 0;
 			this.autoCheck();
@@ -181,13 +208,16 @@ var EvolutionCurator = class extends Service {
 	* surfaced once instead of silently meaning "never runs".
 	*/
 	async autoCheck() {
+		if (this.isDisposed()) return;
 		try {
 			const stateService = this.curatorStateService();
 			if (stateService === void 0 && !this.statelessStateWarned) {
 				this.statelessStateWarned = true;
-				this.ctx.logger.warn("evolution-curator: evolution-state is not mounted — the curation interval baseline is this process's lifetime only (default interval 168h), so automatic curation will not fire again until the process has been alive that long. Mount evolution-state (evolution-host/all bundle) for a durable schedule.");
+				this.ctx.logger.warn(`evolution-curator: evolution-state is not mounted — the curation interval baseline is this process's lifetime only (default interval ${DEFAULT_CURATOR_INTERVAL_HOURS}h), so automatic curation will not fire again until the process has been alive that long. Mount evolution-state (evolution-host/all bundle) for a durable schedule.`);
 			}
-			const last = (await stateService?.loadCuratorState())?.lastRunAt ?? this.lastRun;
+			const persisted = await stateService?.loadCuratorState();
+			if (this.isDisposed()) return;
+			const last = persisted?.lastRunAt ?? this.lastRun;
 			if (Date.now() - last >= this.lifecycle().intervalHours * 36e5) await this.run();
 		} catch (error) {
 			const reason = error instanceof Error ? error.message : String(error);
@@ -256,7 +286,8 @@ var EvolutionCurator = class extends Service {
 						summary: "curator review"
 					}
 				})],
-				maxTokens: this.curatorReviewMaxTokens
+				maxTokens: this.curatorReviewMaxTokens,
+				signal: AbortSignal.timeout(this.curatorReviewTimeoutMs)
 			})) assembler.push(chunk);
 			const parsed = parseCuratorNominations(assembler.blocks().filter((block) => block.type === "text").map((block) => block.text).join("\n"));
 			return {
@@ -294,6 +325,14 @@ var EvolutionCurator = class extends Service {
 	* is reversible.
 	*/
 	async restoreSnapshot() {
+		const release = await this.acquireMutex();
+		try {
+			return await this.restoreSnapshotCore();
+		} finally {
+			release();
+		}
+	}
+	async restoreSnapshotCore() {
 		const stateService = this.curatorStateService();
 		const currentState = await stateService?.loadCuratorState();
 		const extras = currentState === null || currentState === void 0 ? [] : [{
@@ -332,18 +371,18 @@ var EvolutionCurator = class extends Service {
 	* skipped with an explicit `already-running` outcome.
 	*/
 	async run(options = {}) {
-		if (this.running) return {
+		if (this.mutexDepth > 0) return {
 			stale: [],
 			archived: [],
 			errors: [],
 			report: this.skippedReport("already-running", (/* @__PURE__ */ new Date()).toISOString()),
 			skipped: "already-running"
 		};
-		this.running = true;
+		const release = await this.acquireMutex();
 		try {
 			return await this.runCore(options);
 		} finally {
-			this.running = false;
+			release();
 			try {
 				await this.retainReports();
 			} catch (error) {
@@ -351,6 +390,36 @@ var EvolutionCurator = class extends Service {
 			}
 		}
 	}
+	/**
+	* P1 (v16): the control-plane mutex — ONE promise chain serializing run(),
+	* restore() and consolidate(). Replaces the v15 draft (`running` flag +
+	* `runSettled` polling), which could (a) spin forever on an
+	* already-resolved promise while a control-plane mutator held the flag
+	* (micro-task starvation: the flag's reset lives behind IO the spun loop
+	* never lets run) and (b) let two queued waiters wake into the same idle
+	* window and mutate concurrently. Here the chain IS the mutex: an entrant
+	* increments `mutexDepth` synchronously (so run()'s skip check sees queued
+	* work), awaits the previous tail, and the returned release resolves the
+	* tail for the next entrant. Double-release is a no-op.
+	*/
+	mutexDepth = 0;
+	mutexTail = Promise.resolve();
+	acquireMutex() {
+		this.mutexDepth += 1;
+		const prev = this.mutexTail;
+		let releaseMutex;
+		this.mutexTail = new Promise((resolve) => {
+			releaseMutex = resolve;
+		});
+		let released = false;
+		const release = () => {
+			if (released) return;
+			released = true;
+			this.mutexDepth -= 1;
+			releaseMutex();
+		};
+		return prev.then(() => release);
+	}
 	async runCore(options = {}) {
 		const { ignoreGates = false, dryRun = false } = options;
 		const startedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -402,6 +471,7 @@ var EvolutionCurator = class extends Service {
 		const root = this.skills.root;
 		const rawUsage = await loadUsage(root, this.io);
 		const usage = dryRun ? new Map([...rawUsage].map(([name, record]) => [name, { ...record }])) : rawUsage;
+		const runStartStates = new Map([...usage].map(([name, record]) => [name, record.state]));
 		const snapshotPath = dryRun ? void 0 : await this.snapshotFull("pre-curator-run");
 		const suppressedNames = new Set(await loadSuppressedNames(root, this.io));
 		const gates = new EvolutionGateSet({
@@ -453,6 +523,7 @@ var EvolutionCurator = class extends Service {
 			root,
 			recommendPool: new Set(recommendPool),
 			stateOwned: new Set([...result.transitions.map((t) => t.name), ...archiveCandidates]),
+			runStartStates,
 			failedFrom: new Map(result.transitions.filter((t) => t.to === "archived").map((t) => [t.name, t.from]))
 		});
 		if (!dryRun) this.lastRun = Date.now();
@@ -485,16 +556,20 @@ var EvolutionCurator = class extends Service {
 		}
 		const llmHint = !this.llmReview && result.markStale.length > 0 ? " (llmReview: off - deterministic archive only; set llmReview: true for the LLM merge channel)" : "";
 		const summary = `${dryRun ? "dry-run" : "auto"}: stale:${result.markStale.length} archived:${archivedSkills.length} consolidated:${gatedNominations.consolidations.length}${llmHint}`;
-		await stateService?.transactCuratorState((current) => {
-			const pausedNow = current?.paused ?? false;
-			return {
-				schemaVersion: 1,
-				lastRunAt: dryRun ? persisted?.lastRunAt ?? this.lastRun : Date.now(),
-				runCount: dryRun ? persisted?.runCount ?? 0 : (current?.runCount ?? 0) + 1,
-				lastSummary: summary,
-				paused: pausedNow
-			};
-		});
+		try {
+			await stateService?.transactCuratorState((current) => {
+				const pausedNow = current?.paused ?? false;
+				return {
+					schemaVersion: 1,
+					lastRunAt: dryRun ? persisted?.lastRunAt ?? this.lastRun : Date.now(),
+					runCount: dryRun ? persisted?.runCount ?? 0 : (current?.runCount ?? 0) + 1,
+					lastSummary: summary,
+					paused: pausedNow
+				};
+			});
+		} catch (error) {
+			this.ctx.logger.warn(`evolution-curator: failed to persist run bookkeeping: ${error instanceof Error ? error.message : String(error)}`);
+		}
 		return {
 			stale: result.markStale,
 			archived: archivedSkills.map((item) => item.name),
@@ -526,6 +601,11 @@ var EvolutionCurator = class extends Service {
 	}
 	/**
 	* F13 six-factor quality scoring, persisted onto the usage records.
+	* P1-1 (v15): these are the CURATOR-owned fields (`quality_score`/
+	* `quality_warn`) — this method must never touch the feedback-owned
+	* `feedback_*` pair (the lifecycle engine reads the union of both warn
+	* flags, so overwriting feedback here is what used to make negative
+	* feedback decision-irrelevant; field ownership on `UsageRecord`).
 	*/
 	async scoreTree(usage, treeNames) {
 		const supportDirs = /* @__PURE__ */ new Map();
@@ -571,6 +651,7 @@ var EvolutionCurator = class extends Service {
 			consolidated: []
 		};
 		const { archiveCandidates, nominations, treeNames, usage, bundledNames, suppressedNames, root, failedFrom } = input;
+		const runStartStates = input.runStartStates;
 		const errors = [];
 		const archivedSkills = [];
 		const executedConsolidations = [];
@@ -684,9 +765,11 @@ var EvolutionCurator = class extends Service {
 			this.ctx.logger.warn("evolution-curator: failed to persist suppressed names; archived built-ins may re-enter the lifecycle");
 		}
 		try {
+			let skipped = [];
 			await mutateUsage(root, this.io, (disk) => {
-				foldCuratorFields(disk, usage, stateOwned);
+				skipped = foldCuratorFields(disk, usage, stateOwned, runStartStates);
 			});
+			if (skipped.length > 0) this.ctx.logger.warn(`evolution-curator: lifecycle fold skipped ${skipped.length} name(s) whose on-disk state moved during the run (a concurrent curator/tool won): ${skipped.join(", ")}`);
 		} catch {
 			this.ctx.logger.warn("evolution-curator: failed to persist usage sidecar");
 		}
@@ -850,7 +933,8 @@ var EvolutionCurator = class extends Service {
 	/** marker info (pinned/bundled/hub-installed) per skill, from the library list. */
 	async protectedNameMap() {
 		const map = /* @__PURE__ */ new Map();
-		for (const summary of await this.skills.list()) if (summary.protectedBy !== null) map.set(summary.name, summary.protectedBy);
+		for (const summary of await this.skills.list()) if (summary.protectionUnknown) map.set(summary.name, "unknown");
+		else if (summary.protectedBy !== null) map.set(summary.name, summary.protectedBy);
 		return map;
 	}
 	/**
@@ -859,6 +943,14 @@ var EvolutionCurator = class extends Service {
 	* records into `archived` state. Snapshot-then-mutate, never a hard delete.
 	*/
 	async consolidate(target, sources) {
+		const release = await this.acquireMutex();
+		try {
+			return await this.consolidateMutate(target, sources);
+		} finally {
+			release();
+		}
+	}
+	async consolidateMutate(target, sources) {
 		const suppressedNames = new Set(await loadSuppressedNames(this.skills.root, this.io));
 		const gates = new EvolutionGateSet({
 			exclude: this.excludeSkillNames,
@@ -873,15 +965,19 @@ var EvolutionCurator = class extends Service {
 		await this.snapshotFull("pre-consolidate");
 		const result = await this.skills.consolidate(target, sources);
 		if (!result.ok) return result;
-		await mutateUsage(this.skills.root, this.io, (disk) => {
-			for (const source of sources) {
-				const record = disk.get(source);
-				if (record) {
-					record.state = "archived";
-					record.archived_at = (/* @__PURE__ */ new Date()).toISOString();
+		try {
+			await mutateUsage(this.skills.root, this.io, (disk) => {
+				for (const source of sources) {
+					const record = disk.get(source);
+					if (record) {
+						record.state = "archived";
+						record.archived_at = (/* @__PURE__ */ new Date()).toISOString();
+					}
 				}
-			}
-		});
+			});
+		} catch (error) {
+			this.ctx.logger.warn(`evolution-curator: failed to persist consolidate usage state: ${error instanceof Error ? error.message : String(error)}`);
+		}
 		return result;
 	}
 	/**
@@ -889,16 +985,28 @@ var EvolutionCurator = class extends Service {
 	* and reset its usage state, keeping the recoverable-archive invariant.
 	*/
 	async restore(name) {
+		const release = await this.acquireMutex();
+		try {
+			return await this.restoreMutate(name);
+		} finally {
+			release();
+		}
+	}
+	async restoreMutate(name) {
 		await this.snapshotFull("pre-restore");
 		const result = await this.skills.restoreFromArchive(name);
 		if (!result.ok) return result;
-		await mutateUsage(this.skills.root, this.io, (disk) => {
-			const record = disk.get(name);
-			if (record) {
-				record.state = "active";
-				record.archived_at = null;
-			}
-		});
+		try {
+			await mutateUsage(this.skills.root, this.io, (disk) => {
+				const record = disk.get(name);
+				if (record) {
+					record.state = "active";
+					record.archived_at = null;
+				}
+			});
+		} catch (error) {
+			this.ctx.logger.warn(`evolution-curator: failed to persist restore usage state: ${error instanceof Error ? error.message : String(error)}`);
+		}
 		if (new Set(await loadSuppressedNames(this.skills.root, this.io)).has(name)) try {
 			await updateSuppressedNames(this.skills.root, this.io, (current) => {
 				current.delete(name);

package/lib/types/index.d.ts

@@ -47,6 +47,8 @@ export interface Config {
     bootGraceSeconds?: number;
     /** Max tokens for the optional LLM nomination pass. */
     curatorReviewMaxTokens?: number;
+    /** Timeout (ms) for the optional LLM nomination pass (B-10, v18). */
+    curatorReviewTimeoutMs?: number;
     /** Structure-health soft body limit (chars) — see DEFAULT_HEALTH_THRESHOLDS (rc.73 A1). */
     healthSoftBodyChars?: number;
     /** Structure-health stamp-density ceiling per KB — see DEFAULT_HEALTH_THRESHOLDS. */
@@ -104,13 +106,21 @@ export declare class EvolutionCurator extends Service {
     private readonly referencedSkillNames;
     private readonly bootGraceSeconds;
     private readonly curatorReviewMaxTokens;
+    private readonly curatorReviewTimeoutMs;
     private readonly healthSoftBodyChars;
     private readonly healthStampDensityPerKb;
     private readonly healthChurnMinPatches;
     private lastRun;
     private timer;
+    /** B-8 (v18): set by the fiber disposer; a triggered autoCheck must not
+     * keep mutating the tree after the plugin was disposed. */
+    private disposed;
+    /** B-8 (v18): read the disposal flag through a method. The only assignment
+     * lives in the disposer closure, which TypeScript's flow analysis cannot
+     * see, so a direct `this.disposed` read narrows to the literal `false` and
+     * the runtime check would be reported as dead code by `no-unnecessary-condition`. */
+    private isDisposed;
     private bootCheck;
-    private running;
     /** 0.3.18 (E-18): stateless first-run defer fires ONCE per process — the
      * in-memory clock is seeded and later due runs must proceed, or the
      * persisted===null defer repeats forever (no state service to persist). */
@@ -179,6 +189,7 @@ export declare class EvolutionCurator extends Service {
             content: string;
         }>;
     }>;
+    private restoreSnapshotCore;
     private skippedReport;
     /**
      * Run one curator pass. `ignoreGates` skips the interval and idle gates so an
@@ -192,6 +203,21 @@ export declare class EvolutionCurator extends Service {
         ignoreGates?: boolean;
         dryRun?: boolean;
     }): Promise<CuratorRunOutcome>;
+    /**
+     * P1 (v16): the control-plane mutex — ONE promise chain serializing run(),
+     * restore() and consolidate(). Replaces the v15 draft (`running` flag +
+     * `runSettled` polling), which could (a) spin forever on an
+     * already-resolved promise while a control-plane mutator held the flag
+     * (micro-task starvation: the flag's reset lives behind IO the spun loop
+     * never lets run) and (b) let two queued waiters wake into the same idle
+     * window and mutate concurrently. Here the chain IS the mutex: an entrant
+     * increments `mutexDepth` synchronously (so run()'s skip check sees queued
+     * work), awaits the previous tail, and the returned release resolves the
+     * tail for the next entrant. Double-release is a no-op.
+     */
+    private mutexDepth;
+    private mutexTail;
+    private acquireMutex;
     private runCore;
     /**
      * Seed baseline records for tree skills the sidecar has not seen yet, so
@@ -202,6 +228,11 @@ export declare class EvolutionCurator extends Service {
     private seedBaseline;
     /**
      * F13 six-factor quality scoring, persisted onto the usage records.
+     * P1-1 (v15): these are the CURATOR-owned fields (`quality_score`/
+     * `quality_warn`) — this method must never touch the feedback-owned
+     * `feedback_*` pair (the lifecycle engine reads the union of both warn
+     * flags, so overwriting feedback here is what used to make negative
+     * feedback decision-irrelevant; field ownership on `UsageRecord`).
      */
     private scoreTree;
     /**
@@ -262,11 +293,13 @@ export declare class EvolutionCurator extends Service {
      * records into `archived` state. Snapshot-then-mutate, never a hard delete.
      */
     consolidate(target: string, sources: string[]): Promise<SkillActionResult>;
+    private consolidateMutate;
     /**
      * Control-plane restore: bring one archived skill back to the active root
      * and reset its usage state, keeping the recoverable-archive invariant.
      */
     restore(name: string): Promise<SkillActionResult>;
+    private restoreMutate;
 }
 export default EvolutionCurator;
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-curator",
   "description": "Deterministic skill lifecycle and recovery (community build)",
-  "version": "0.3.62",
+  "version": "0.3.64",
   "publishConfig": {
     "access": "public"
   },
@@ -31,20 +31,20 @@
   "license": "MIT",
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.1",
-    "@lmzhen/dsh-evolution-core": "^0.3.62"
+    "@lmzhen/dsh-evolution-core": "^0.3.64"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2",
     "@deepseek-ai/dsh-llm": "^0.1.1-rc.2",
-    "@lmzhen/dsh-evolution-io": "^0.3.62",
-    "@lmzhen/dsh-evolution-state": "^0.3.62"
+    "@lmzhen/dsh-evolution-io": "^0.3.64",
+    "@lmzhen/dsh-evolution-state": "^0.3.64"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2",
     "@deepseek-ai/dsh-llm": "^0.1.1-rc.2",
-    "@lmzhen/dsh-evolution-core": "^0.3.62",
-    "@lmzhen/dsh-evolution-io": "^0.3.62",
-    "@lmzhen/dsh-evolution-state": "^0.3.62"
+    "@lmzhen/dsh-evolution-core": "^0.3.64",
+    "@lmzhen/dsh-evolution-io": "^0.3.64",
+    "@lmzhen/dsh-evolution-state": "^0.3.64"
   }
 }