@lmzhen/dsh-evolution-commands 0.18.0 → 0.19.0

package/README.md

@@ -17,6 +17,7 @@ The full `/evolution` subcommand table is single-sourced in the family README's
 ## Known limitations
 
 - No known durable consumer gaps at this time. Runtime contracts are covered by package and boundary tests.
+- **`/evolution maintain` runs in the BACKGROUND (0.19.0).** The command answers with a run id and the scan keeps working: read it with `/evolution maintain report <id>` (a run that produced nothing answers "no result" instead of an empty plan) or `/evolution maintain status [<id>]` (in flight plus the recent terminal states). The run's lifetime belongs to this plugin through `evolution-core`'s run registry, **not** to the request that started it: the desktop shell ends a request at ~305 s (measured four times) while the same scan completes in 949.7 s on the web plane, and `maintainTimeoutMs` (default 600000) bounds the run itself. **Cancelling the request no longer stops the scan** — use `/evolution maintain cancel <id>`, or unmount the row. The plan is written once at settle to `<evolutionHome>/reports/maintain-<runId>.{json,md}`, under the same per-home reports window the curator's reports use.
 - **① variant form: the `/evolution …` command face is visible in every session** (accepted, not fixed). Commands are registered in scope layers, and the family registers once on the host plane, so a session on a platform original preset still lists the management-only subcommands even though no automatic family behaviour reaches it. The difference and its reasoning are single-sourced in `INSTALL.md` ("Known difference").
 
 **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

@@ -2,7 +2,7 @@ import { createRequire } from "node:module";
 import z from "@deepseek-ai/schemastery";
 import { effectiveSessionPolicy } from "@lmzhen/dsh-evolution-approval";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
-import { DEFAULT_SKILL_LIMITS, MAX_TIMER_DELAY_MS, PARAM_EXPOSURE, PARAM_GROUP_LABELS, absentHostServices, appendEvolutionEvent, applyNamespaceMigration, assertSkillsRootAliasRetired, buildLearnPrompt, canonicalWriteId, clampedNumber, classifyNamespaceMigration, composePresetEntry, elapsedSince, errorText, eventsFile, evolutionRoot, isDeprecatedParamId, isMissingPath, mergePresetRow, newSkillLibrary, paramSettingsId, partitionVersions, planNamespaceMigration, policyStageLimits, presetPatchText, presetRowBlock, presetRowBody, presetRowId, resolveBasePresetPatch, resolveParamId, resolveRootConfig, scopedProbeReport } from "@lmzhen/dsh-evolution-core";
+import { DEFAULT_SKILL_LIMITS, MAX_TIMER_DELAY_MS, PARAM_EXPOSURE, PARAM_GROUP_LABELS, absentHostServices, appendEvolutionEvent, applyNamespaceMigration, assertSkillsRootAliasRetired, buildLearnPrompt, canonicalWriteId, clampedNumber, classifyNamespaceMigration, composePresetEntry, elapsedSince, errorText, eventsFile, evolutionHome, evolutionRoot, isDeprecatedParamId, isMissingPath, isPresent, isUnknown, mergePresetRow, newRunRegistry, newSkillLibrary, paramSettingsId, partitionVersions, planNamespaceMigration, policyStageLimits, presetPatchText, presetRowBlock, presetRowBody, presetRowId, probeText, reportsSweepLockTarget, resolveBasePresetPatch, resolveParamId, resolveRootConfig, scopedProbeReport, sweepReports, transactIo } from "@lmzhen/dsh-evolution-core";
 import { buildEnrichment, buildMaintainFacts, enrichmentSnapshotOptions, runMaintain, snapshotFromLibrary } from "@lmzhen/dsh-evolution-maintenance";
 import { copyFileSync, existsSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -1332,7 +1332,19 @@ const COMMAND_ENTRIES = [
 	},
 	{
 		usage: "maintain [--timeout=<ms> | --facts]",
-		summary: "运行一次维护扫描（--facts 为 0 token 预览）"
+		summary: "起一次维护扫描并立即回 run id（后台跑；--facts 为 0 token 预览）"
+	},
+	{
+		usage: "maintain status [<id>]",
+		summary: "看维护扫描：在飞的那次（含已跑多久）或某个 run 的终态"
+	},
+	{
+		usage: "maintain report <id>",
+		summary: "读某个 run 的结果正文（没有结果就明说，不装成空结果）"
+	},
+	{
+		usage: "maintain cancel <id>",
+		summary: "停掉在飞的那次维护扫描"
 	},
 	{
 		usage: "migrate",
@@ -1386,13 +1398,119 @@ const Config = z.object({
 	maintainTimeoutMs: z.number().min(1).default(6e5),
 	threatExemptLabels: z.array(z.string()).default([])
 });
+/** How one run reads in `maintain status` output. */
+function renderRunRecord(record) {
+	const seconds = Math.max(1, Math.round(((record.endedAt ?? Date.now()) - record.startedAt) / 1e3));
+	const parts = [`${record.id}  ${record.state}  ${seconds}s`];
+	if (record.failure !== void 0) parts.push(`— ${record.failure}`);
+	if (record.resultRef !== void 0) parts.push(`→ ${record.resultRef}`);
+	return parts.join(" ");
+}
+/**
+* Write one run's result to its ONE home: `<evolutionHome>/reports/maintain-<id>.json`
+* plus the `.md` digest, then sweep that window.
+*
+* A write failure does not fail the run — because the run has no result then, and
+* `maintain report <id>` says exactly that instead of pretending otherwise.
+* @param io - the evolution io seam.
+* @param record - the run's outcome, as persisted.
+* @param warn - warn channel for retention notes.
+* @returns the report path, or `undefined` when nothing could be written.
+*/
+/**
+* Re-read the run index before answering a command (review P1-1).
+*
+* One DSH_HOME is shared by both planes, so a scan the OTHER process started is
+* only visible after a refresh — without it the in-flight guard, the cooldown and
+* `status <id>` would all describe this process's memory alone. A read FAILURE is
+* not "no runs": the caller decides what to say.
+* @param registry - this row's registry.
+* @returns whether the history could be read, and the note to surface when there is one.
+*/
+async function syncRuns(registry) {
+	try {
+		return await registry.load();
+	} catch (error) {
+		return {
+			ok: false,
+			note: `the run index could not be read (${error instanceof Error ? error.message : String(error)})`
+		};
+	}
+}
+async function writeMaintainReport(io, record, warn, evolutionHomePath) {
+	const dir = join(evolutionHomePath, "reports");
+	const path = join(dir, `maintain-${record.runId}.json`);
+	let written = true;
+	try {
+		await io.writeText(path, JSON.stringify(record, null, 2));
+		await io.writeText(join(dir, `maintain-${record.runId}.md`), record.text.trim() === "" ? `Maintenance run ${record.runId}: ${record.failure ?? "no plan"}\n` : record.text);
+	} catch (error) {
+		written = false;
+		warn(`evolution-commands: could not write the report for run ${record.runId} (${error instanceof Error ? error.message : String(error)}) — that run will answer "no result"`);
+	}
+	await transactIo(io, reportsSweepLockTarget(), async () => {
+		await sweepReports({
+			io,
+			dir,
+			buckets: [{
+				prefix: "maintain-",
+				keep: 20
+			}],
+			owner: "evolution-commands",
+			warn
+		});
+		return null;
+	});
+	return written ? path : void 0;
+}
+/** Three-state read of a run's result: present, missing, or unreadable (never collapsed). */
+async function readRunReport(io, record) {
+	const probed = await probeText(io, record.resultRef ?? join(evolutionHome(), "reports", `maintain-${record.id}.json`));
+	if (isUnknown(probed)) return {
+		kind: "unknown",
+		reason: probed.reason
+	};
+	if (!isPresent(probed)) return { kind: "missing" };
+	try {
+		const parsed = JSON.parse(probed.value);
+		return {
+			kind: "present",
+			text: `${`Maintenance run ${record.id} — ${record.state}${record.failure === void 0 ? "" : ` (${record.failure})`}`}\n${typeof parsed.text === "string" && parsed.text.trim() !== "" ? parsed.text : renderRunRecord(record)}`
+		};
+	} catch (error) {
+		return {
+			kind: "unknown",
+			reason: `the report is not JSON (${error instanceof Error ? error.message : String(error)})`
+		};
+	}
+}
 function apply(ctx, rawConfig = {}) {
 	const config = rawConfig;
 	assertSkillsRootAliasRetired(rawConfig);
 	const skillsRootValue = resolveRootConfig(rawConfig).root;
-	let lastMaintainAt = 0;
-	let lastMaintainRunId = "";
-	let maintainInFlightSince = 0;
+	let runs;
+	ctx.inject(["evolutionIo"], (ioCtx) => {
+		const ioRegistry = ioCtx.get("evolutionIo");
+		if (!ioRegistry) return;
+		const registry = newRunRegistry({
+			io: ioRegistry.provider(),
+			home: evolutionHome(),
+			warn: (message) => {
+				ctx.logger.warn(message);
+			}
+		});
+		runs = registry;
+		registry.load().then((loaded) => {
+			if (!loaded.ok) ctx.logger.warn(`evolution-commands: the run index is not usable — ${loaded.note ?? "unknown reason"}`);
+			else if (loaded.note !== void 0) ctx.logger.warn(`evolution-commands: ${loaded.note}`);
+		}).catch((error) => {
+			ctx.logger.warn(`evolution-commands: could not read the run index (${error instanceof Error ? error.message : String(error)})`);
+		});
+		ioCtx.effect(() => () => {
+			registry.cancelAll();
+			runs = void 0;
+		}, "evolution-commands.run-registry");
+	});
 	ctx.inject(["commands"], (commandCtx) => {
 		const commands = commandCtx.commands;
 		const commandBody = { run: async (invocation) => {
@@ -1670,57 +1788,155 @@ function apply(ctx, rawConfig = {}) {
 			if (maintainArgs) {
 				const runTimeoutMs = maintainArgs[1] ? Number(maintainArgs[1]) : config.maintainTimeoutMs ?? 6e5;
 				if (!Number.isSafeInteger(runTimeoutMs) || runTimeoutMs <= 0 || runTimeoutMs > MAX_TIMER_DELAY_MS) return err(maintainArgs[1] ? `Invalid --timeout value: expected a positive integer number of milliseconds up to ${MAX_TIMER_DELAY_MS} (e.g. /evolution maintain --timeout 600000).` : `The maintainTimeoutMs config is invalid: expected a positive integer number of milliseconds up to ${MAX_TIMER_DELAY_MS}. Fix the evolution-commands row config (maintainTimeoutMs), then retry.`);
-				if (maintainInFlightSince > 0) return err(`Maintenance scan is already running (since ~${Math.max(1, Math.round((Date.now() - maintainInFlightSince) / 1e3))}s ago) — re-submitting now would cancel it. Wait for it to settle; the result appears when it finishes.`);
-				const cooldownMs = clampedNumber(config.maintainCooldownMs, 3e4, { min: 0 });
-				const sinceLast = Date.now() - lastMaintainAt;
-				if (cooldownMs > 0 && sinceLast < cooldownMs) return err(`Maintenance cooldown active (${Math.ceil((cooldownMs - sinceLast) / 1e3)}s)${lastMaintainRunId === "" ? "" : ` — latest scan ${lastMaintainRunId}`}; re-running now would spend another model call.`);
+				const registry = runs;
+				if (!registry) return err("Evolution IO registry not mounted — maintenance scan unavailable.");
+				const synced = await syncRuns(registry);
+				if (!synced.ok) ctx.logger.warn(`evolution-commands: ${synced.note ?? "run index unreadable"} — the in-flight guard cannot see other processes' runs`);
+				else if (synced.note !== void 0) ctx.logger.warn(`evolution-commands: ${synced.note}`);
 				const ioRegistry = ctx.get("evolutionIo");
 				const subagents = ctx.get("subagents");
 				if (!ioRegistry) return err("Evolution IO registry not mounted — maintenance scan unavailable.");
 				if (!subagents) return err("Subagents service not mounted — maintenance scan unavailable.");
-				try {
-					maintainInFlightSince = Date.now();
-					const library = newSkillLibrary({
-						config: { root: skillsRootValue },
-						io: ioRegistry.provider()
-					});
-					const enrichment = await buildEnrichment(ctx, library);
-					const outcome = await runMaintain({
-						library,
-						subagents,
-						parent: invocation.agent,
-						evolutionPolicy: { get: () => ctx.get("evolutionPolicy")?.get() },
-						tools: { get: (name) => ctx.get("tools")?.get(name) },
-						logger: { warn: (message) => {
+				const running = registry.inFlight();
+				if (running) {
+					const elapsed = Math.max(1, Math.round((Date.now() - running.startedAt) / 1e3));
+					return err(`Maintenance run ${running.id} is already running (started ~${elapsed}s ago) — re-submitting now would start a second scan. Status: /evolution maintain status ${running.id}; stop it: /evolution maintain cancel ${running.id}.`);
+				}
+				const cooldownMs = clampedNumber(config.maintainCooldownMs, 3e4, { min: 0 });
+				const lastSettled = registry.lastSettledAt();
+				const sinceLast = lastSettled === void 0 ? Number.POSITIVE_INFINITY : Date.now() - lastSettled;
+				if (cooldownMs > 0 && sinceLast < cooldownMs) {
+					const remaining = Math.ceil((cooldownMs - sinceLast) / 1e3);
+					const latest = registry.runs().find((record) => record.state !== "running");
+					return err(`Maintenance cooldown active (${remaining}s)${latest === void 0 ? "" : ` — latest run ${latest.id}`}; re-running now would spend another model call.`);
+				}
+				const runHome = evolutionHome();
+				const runRoot = evolutionRoot();
+				const handle = registry.begin("maintain");
+				(async () => {
+					try {
+						const library = newSkillLibrary({
+							config: { root: skillsRootValue },
+							io: ioRegistry.provider()
+						});
+						const enrichment = await buildEnrichment(ctx, library);
+						const outcome = await runMaintain({
+							library,
+							subagents,
+							parent: invocation.agent,
+							evolutionPolicy: { get: () => ctx.get("evolutionPolicy")?.get() },
+							tools: { get: (name) => ctx.get("tools")?.get(name) },
+							logger: { warn: (message) => {
+								ctx.logger.warn(message);
+							} },
+							rootExists: skillsRootValue === "" ? void 0 : () => ioRegistry.provider().exists(skillsRootValue),
+							skillRoot: skillsRootValue
+						}, {
+							timeoutMs: runTimeoutMs,
+							signal: handle.signal,
+							runId: handle.id,
+							enrichment: () => enrichment
+						});
+						const endedAt = Date.now();
+						const resultRef = await writeMaintainReport(ioRegistry.provider(), {
+							runId: handle.id,
+							...outcome.ok ? {
+								verdict: outcome.verdict,
+								recommendationCount: outcome.recommendationCount
+							} : {},
+							...outcome.ok ? {} : { failure: handle.signal.aborted ? "cancelled: the scan was stopped before it settled" : outcome.error ?? "Maintenance scan failed." },
+							startedAt: handle.startedAt,
+							endedAt,
+							text: outcome.text ?? ""
+						}, (message) => {
 							ctx.logger.warn(message);
-						} },
-						rootExists: skillsRootValue === "" ? void 0 : () => ioRegistry.provider().exists(skillsRootValue),
-						skillRoot: skillsRootValue
-					}, {
-						timeoutMs: runTimeoutMs,
-						signal: invocation.signal,
-						enrichment: () => enrichment
-					});
-					if (outcome.ok) lastMaintainRunId = outcome.runId ?? "";
-					if (!outcome.ok) return err(outcome.error ?? "Maintenance scan failed.");
-					appendEvolutionEvent(ioRegistry.provider(), eventsFile(evolutionRoot()), {
-						type: "maintain",
-						source: "manual",
-						runId: outcome.runId,
-						verdict: outcome.verdict,
-						recommendations: outcome.recommendationCount
-					}).catch((error) => {
-						ctx.logger.warn(`evolution-commands: failed to record maintain event: ${String(error)}`);
-					});
-					return ok(`Maintenance scan ${outcome.runId}:\n${outcome.text ?? ""}`);
-				} catch (error) {
-					return err(`Maintenance scan failed: ${error instanceof Error ? error.message : String(error)}`);
-				} finally {
-					maintainInFlightSince = 0;
-					lastMaintainAt = Date.now();
+						}, runHome);
+						const state = outcome.ok ? "succeeded" : handle.signal.aborted ? "cancelled" : "failed";
+						await registry.settle(handle.id, {
+							state,
+							...resultRef === void 0 ? {} : { resultRef },
+							...outcome.ok ? {} : { failure: handle.signal.aborted ? "cancelled: the scan was stopped before it settled" : outcome.error ?? "Maintenance scan failed." }
+						});
+						if (outcome.ok) appendEvolutionEvent(ioRegistry.provider(), eventsFile(runRoot), {
+							type: "maintain",
+							source: "manual",
+							runId: handle.id,
+							verdict: outcome.verdict,
+							recommendations: outcome.recommendationCount
+						}).catch((error) => {
+							ctx.logger.warn(`evolution-commands: failed to record maintain event: ${String(error)}`);
+						});
+						else ctx.logger.warn(`evolution-commands: maintenance run ${handle.id} produced no plan (${outcome.error ?? "unknown reason"})`);
+					} catch (error) {
+						const aborted = handle.signal.aborted;
+						const failure = aborted ? "cancelled: the scan was stopped before it settled" : `Maintenance scan failed: ${error instanceof Error ? error.message : String(error)}`;
+						await registry.settle(handle.id, {
+							state: aborted ? "cancelled" : "failed",
+							failure
+						});
+						ctx.logger.warn(`evolution-commands: maintenance run ${handle.id} threw (${failure})`);
+					}
+				})();
+				return ok([
+					`Maintenance run ${handle.id} started — the scan keeps running after this reply.`,
+					`- status: /evolution maintain status ${handle.id}`,
+					`- result: /evolution maintain report ${handle.id}`,
+					`- stop:   /evolution maintain cancel ${handle.id}`
+				].join("\n"));
+			}
+			const maintainStatus = /^maintain\s+status(?:\s+(\S+))?\s*$/.exec(input);
+			if (maintainStatus) {
+				const registry = runs;
+				if (!registry) return err("Evolution IO registry not mounted — run status unavailable.");
+				const synced = await syncRuns(registry);
+				const wanted = maintainStatus[1];
+				if (wanted !== void 0) {
+					const record = registry.find(wanted);
+					if (!record) {
+						if (!synced.ok) return err(`Run ${wanted} is not in this process's history, and the home's run index is not readable (${synced.note ?? "unknown reason"}) — that is NOT proof the run never happened.`);
+						return err(`No run ${wanted} in this home — /evolution maintain status lists the recent ones.`);
+					}
+					return ok(synced.ok ? renderRunRecord(record) : `${renderRunRecord(record)}\n(index not readable: ${synced.note ?? "unknown reason"} — only this process's view is shown)`);
+				}
+				if (!synced.ok) return err(`The run history of this home is not readable (${synced.note ?? "unknown reason"}) — this is NOT "no runs". Fix or remove <evolutionHome>/runs.json to start a clean history.`);
+				const all = registry.runs();
+				if (all.length === 0) return ok("No maintenance run recorded in this home yet — /evolution maintain starts one.");
+				const live = all.filter((record) => record.state === "running");
+				const recent = all.filter((record) => record.state !== "running").slice(0, 5);
+				return ok([live.length === 0 ? "No maintenance run in flight." : `In flight:\n${live.map(renderRunRecord).join("\n")}`, recent.length === 0 ? "" : `Recent:\n${recent.map(renderRunRecord).join("\n")}`].filter((part) => part !== "").join("\n"));
+			}
+			const maintainReport = /^maintain\s+report\s+(\S+)\s*$/.exec(input);
+			if (maintainReport) {
+				const registry = runs;
+				if (!registry) return err("Evolution IO registry not mounted — run results unavailable.");
+				await syncRuns(registry);
+				const wanted = maintainReport[1];
+				if (wanted === void 0) return err("maintain report needs a run id: /evolution maintain report <id>.");
+				const record = registry.find(wanted);
+				if (!record) return err(`No run ${wanted} in this home — /evolution maintain status lists the recent ones.`);
+				const ioRegistry = ctx.get("evolutionIo");
+				if (!ioRegistry) return err("Evolution IO registry not mounted — run results unavailable.");
+				const probed = await readRunReport(ioRegistry.provider(), record);
+				if (probed.kind === "missing") return err(`Run ${record.id} (${record.state}) has NO result: no report was written${record.failure === void 0 ? "" : ` (${record.failure})`}.`);
+				if (probed.kind === "unknown") return err(`Run ${record.id} has a report that could not be read (${probed.reason}) — this is not "no result".`);
+				return ok(probed.text);
+			}
+			const maintainCancel = /^maintain\s+cancel\s+(\S+)\s*$/.exec(input);
+			if (maintainCancel) {
+				const registry = runs;
+				if (!registry) return err("Evolution IO registry not mounted — run cancellation unavailable.");
+				await syncRuns(registry);
+				const wanted = maintainCancel[1];
+				if (wanted === void 0) return err("maintain cancel needs a run id: /evolution maintain cancel <id>.");
+				const record = registry.find(wanted);
+				if (!record) return err(`No run ${wanted} in this home — /evolution maintain status lists the recent ones.`);
+				if (!registry.cancel(record.id)) {
+					if (record.state === "running") return err(`Run ${record.id} is running in ANOTHER process sharing this home — it can only be cancelled there.`);
+					return err(`Run ${record.id} is already ${record.state} — nothing to cancel.`);
 				}
+				return ok(`Maintenance run ${record.id} cancelled — the scan stops at its next checkpoint. /evolution maintain status ${record.id} shows the terminal state.`);
 			}
-			if (/^maintain\b/.test(input)) return err("Unknown maintain arguments: expected bare `maintain`, `maintain --timeout <ms>` or `maintain --timeout=<ms>` (a positive integer). Got: " + input);
+			if (/^maintain\b/.test(input)) return err("Unknown maintain arguments: expected `maintain`, `maintain --timeout <ms>` / `maintain --timeout=<ms>`, `maintain status [<id>]`, `maintain report <id>` or `maintain cancel <id>`. Got: " + input);
 			const presetInstall = /^preset install(?: --base (\S+))?$/.exec(input);
 			if (presetInstall !== null || /^preset\b/.test(input)) {
 				if (presetInstall === null) return err("Unknown preset arguments: expected `preset install` or `preset install --base <name>[,<name>...]` (the names live in the agent package's bases.json). Got: " + input);

package/lib/types/index.d.ts

@@ -24,10 +24,11 @@ export interface Config {
      * of dropping it silently; the plugin never reads it as a root. */
     skillsRoot?: string | undefined;
     /** Cooldown window for scan commands (ms) — misclick/rapid-trigger guard;
-     * secondary calls inside the window return the previous runId instead of
-     * spending another model call. Default 30s (0.3.5). NOTE: the window starts
-     * AFTER a run settles (lastMaintainAt updates post-run) — it does NOT dedupe
-     * in-flight runs, so the old 130s ">= timeout" rationale was a comment bug.
+     * secondary calls inside the window are refused instead of spending another
+     * model call. Default 30s (0.3.5). NOTE: the window starts AFTER a run settles
+     * (0.19.0/S2: the run registry's newest terminal time) — it does NOT dedupe
+     * in-flight runs; that refusal belongs to the registry's in-flight query, not
+     * to this window (the old 130s ">= timeout" rationale was a comment bug).
      * Transient (per-process). */
     maintainCooldownMs?: number | undefined;
     /** Subagent deadline for one maintenance scan (ms). Default 600s (0.3.10):

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-commands",
   "description": "Human commands for the evolution family (/evolution pending|curator|maintain|doctor) (community build)",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "publishConfig": {
     "access": "public"
   },
@@ -27,12 +27,12 @@
   "license": "MIT",
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.4",
-    "@lmzhen/dsh-evolution-approval": "^0.18.0",
-    "@lmzhen/dsh-evolution-core": "^0.18.0",
-    "@lmzhen/dsh-evolution-maintenance": "^0.18.0"
+    "@lmzhen/dsh-evolution-approval": "^0.19.0",
+    "@lmzhen/dsh-evolution-core": "^0.19.0",
+    "@lmzhen/dsh-evolution-maintenance": "^0.19.0"
   },
   "optionalDependencies": {
-    "@lmzhen/dsh-evolution-agent-preset": "^0.18.0"
+    "@lmzhen/dsh-evolution-agent-preset": "^0.19.0"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",