@lmzhen/dsh-evolution-merge 0.30.10 → 0.30.12

package/lib/index.js

@@ -3,7 +3,7 @@ import z from "@deepseek-ai/schemastery";
 import { pairKeyOf, screen, selectCandidates, toEngineCandidate } from "@lmzhen/dsh-evolution-merge-engine";
 import { DEFAULT_SKILL_LIMITS, authorityFrom, contentHash, createSubagentChannel, evolutionHome, evolutionIoAdapter, executeUnitUndo, isPresent, newRunRegistry, newSkillLibrary, parseFrontmatter, planUnitUndoAcross, policyStageLimits, probeAbsent, probeList, probePresent, probeText, probeUnknown, scanContentThreats, skillsRoot, supportRefs, transactIo, validateFrontmatter, validateSupportPath } from "@lmzhen/dsh-evolution-core";
 import { HOST_ROUTES, json, methodNotAllowed, registerHostRoutes } from "@lmzhen/dsh-evolution-core/http-routes";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 //#region lib/types/adapters/select.js
 /** Host selector correction: engine selector does not route judge errors to candidates. */
 function selectWithErrors(report) {
@@ -345,10 +345,17 @@ async function mutateMergeState(io, home, now, fn) {
 	});
 	return result;
 }
-async function upsertRow(io, home, now, row, expect = "any") {
+async function upsertRow(io, home, now, row, expect = "any", cas) {
 	return await mutateMergeState(io, home, now, (rows) => {
 		const index = rows.findIndex((item) => item.pairKey === row.pairKey);
 		const current = index < 0 ? void 0 : rows[index];
+		if (cas !== void 0 && (cas === null && current !== void 0 || cas !== null && current?.updatedAt !== cas)) return {
+			rows,
+			result: {
+				ok: false,
+				current: current ?? row
+			}
+		};
 		if (current !== void 0 && expect !== "any" && (expect === "absent" || queueOf(current.state) !== expect)) return {
 			rows,
 			result: {
@@ -799,7 +806,18 @@ async function recoverCommitJournals(io, home, now, skillRoot, restoreSource, is
 			});
 			continue;
 		}
-		const snapshot = await readCommitSnapshot(io, home, journal.runId);
+		let snapshot;
+		try {
+			snapshot = await readCommitSnapshot(io, home, journal.runId);
+		} catch (error) {
+			reports.push({
+				runId: journal.runId,
+				phase: journal.phase,
+				action: "snapshot-read-failed: " + (error instanceof Error ? error.message : String(error)),
+				ok: false
+			});
+			continue;
+		}
 		let action = "report-only";
 		let ok = true;
 		if (recovery === "retry-commit") action = "no-host-write";
@@ -1779,16 +1797,16 @@ async function runScan(options) {
 			});
 			if (!created.ok || created.row === null) throw new Error(created.ok ? "candidate row missing" : created.message);
 			row = created.row;
-			const placed = await upsertRow(options.io, options.home, options.now, row, "verify");
-			if (!placed.ok && placed.current.state === "skipped") {
-				const restored = transition(placed.current, {
+			const before = (await loadMergeState(options.io, options.home)).state.rows.find((item) => item.pairKey === row.pairKey);
+			const placed = await upsertRow(options.io, options.home, options.now, row, "verify", before?.updatedAt ?? null);
+			if (!placed.ok && before?.state === "skipped") {
+				const restored = transition(before, {
 					type: "restore",
 					at: at(options.now)
 				});
 				if (!restored.ok || restored.row === null) throw new Error("cannot restore skipped pair");
+				if (!(await upsertRow(options.io, options.home, options.now, restored.row, "any", before.updatedAt)).ok) throw new Error("pair changed while restoring skipped row");
 				row = restored.row;
-				const retried = await upsertRow(options.io, options.home, options.now, row, "verify");
-				if (!retried.ok) throw new Error("pair already in " + retried.current.state);
 			} else if (!placed.ok) throw new Error("pair already in " + placed.current.state);
 		} catch (error) {
 			totals.failed += 1;
@@ -2216,6 +2234,56 @@ async function rejectPending(io, home, now, id) {
 	return await act(io, home, now, id, "reject");
 }
 //#endregion
+//#region lib/types/domain/claim.js
+function acquireClaim(current, now, leaseMs, token) {
+	if (current !== void 0 && current.expiresAt > now) return void 0;
+	return {
+		id: "claim",
+		token,
+		expiresAt: now + Math.max(1, leaseMs)
+	};
+}
+function releaseClaim(current, token) {
+	return current?.token === token ? void 0 : current;
+}
+//#endregion
+//#region lib/types/target-claim.js
+/** Durable target claim: one approve writer per merge target at a time. */
+const LEASE_MS = 5 * 6e4;
+function claimPath(home, target) {
+	return join(home, "merge", "claims", contentHash(target) + ".json");
+}
+async function readClaim(io, home, target) {
+	const path = claimPath(home, target);
+	if (!await io.exists(path)) return void 0;
+	const raw = await io.readText(path);
+	if (raw === null) return void 0;
+	const parsed = JSON.parse(raw);
+	if (typeof parsed.token !== "string" || typeof parsed.expiresAt !== "number") throw new Error("corrupt target claim: " + target);
+	return {
+		id: "claim",
+		token: parsed.token,
+		expiresAt: parsed.expiresAt
+	};
+}
+async function acquireTargetClaim(io, home, target, now) {
+	const current = await readClaim(io, home, target);
+	const token = randomUUID();
+	const claim = acquireClaim(current, now, LEASE_MS, token);
+	if (claim === void 0) return null;
+	await io.writeText(claimPath(home, target), JSON.stringify(claim) + "\n");
+	return {
+		token,
+		async release() {
+			const next = releaseClaim(await readClaim(io, home, target), token);
+			if (next === void 0) try {
+				await io.remove(claimPath(home, target));
+			} catch {}
+			else await io.writeText(claimPath(home, target), JSON.stringify(next) + "\n");
+		}
+	};
+}
+//#endregion
 //#region lib/types/round2-outcome.js
 async function recordRound2Outcome(io, home, now, row, outcome) {
 	const at = new Date(now()).toISOString();
@@ -2289,79 +2357,89 @@ async function recordRound2Outcome(io, home, now, row, outcome) {
 //#endregion
 //#region lib/types/approve-command.js
 async function runApproveCommand(options) {
-	const taken = await approvePending(options.io, options.home, options.now, options.rowId);
-	if (!taken.ok) return {
+	const target = (await loadMergeState(options.io, options.home)).state.rows.find((item) => item.id === options.rowId)?.decision?.target;
+	const claim = target === void 0 ? null : await acquireTargetClaim(options.io, options.home, target, options.now());
+	if (target !== void 0 && claim === null) return {
 		ok: false,
-		message: taken.message
+		message: "target already claimed by another approve: " + target
 	};
-	const row = taken.row;
-	const decision = row.decision;
-	if (decision === void 0) return {
-		ok: false,
-		message: "pending row has no decision"
-	};
-	return await withMergeRun({
-		io: options.io,
-		home: options.home,
-		registry: options.registry,
-		command: "approve",
-		approval: {
-			platformWrite: options.platformWrite,
-			mergeApproval: true
-		},
-		now: options.now,
-		async body(ctx) {
-			const stage = (name) => ctx.stage(name, {
-				done: 0,
-				total: 1
-			});
-			await stage("author");
-			let outcome;
-			try {
-				outcome = await options.ports.round2(row, decision, ctx.signal, ctx.runId);
-			} catch (error) {
-				outcome = {
-					kind: "failed",
-					failure: {
-						stage: "author",
-						code: "merge-failed",
-						message: error instanceof Error ? error.message : String(error),
-						retryable: true,
-						retryFrom: "agent2"
-					}
+	try {
+		const taken = await approvePending(options.io, options.home, options.now, options.rowId);
+		if (!taken.ok) return {
+			ok: false,
+			message: taken.message
+		};
+		const row = taken.row;
+		const decision = row.decision;
+		if (decision === void 0) return {
+			ok: false,
+			message: "pending row has no decision"
+		};
+		return await withMergeRun({
+			io: options.io,
+			home: options.home,
+			registry: options.registry,
+			command: "approve",
+			approval: {
+				platformWrite: options.platformWrite,
+				mergeApproval: true
+			},
+			now: options.now,
+			async body(ctx) {
+				const stage = (name) => ctx.stage(name, {
+					done: 0,
+					total: 1
+				});
+				await stage("author");
+				let outcome;
+				try {
+					outcome = await options.ports.round2(row, decision, ctx.signal, ctx.runId);
+				} catch (error) {
+					outcome = {
+						kind: "failed",
+						failure: {
+							stage: "author",
+							code: "merge-failed",
+							message: error instanceof Error ? error.message : String(error),
+							retryable: true,
+							retryFrom: "agent2"
+						}
+					};
+				}
+				const base = {
+					scope: {
+						candidatePairs: 1,
+						queueBefore: {
+							verify: 0,
+							pending: 0,
+							fuse: 1,
+							skipped: 0
+						}
+					},
+					notes: []
 				};
-			}
-			const base = {
-				scope: {
-					candidatePairs: 1,
-					queueBefore: {
-						verify: 0,
+				const record = await recordRound2Outcome(options.io, options.home, options.now, row, outcome);
+				return {
+					...base,
+					stopReason: record.merged ? "completed" : "failed",
+					pairs: [record.pair],
+					totals: record.merged ? {
+						merged: 1,
+						kept: 0,
 						pending: 0,
-						fuse: 1,
-						skipped: 0
+						failed: 0
+					} : {
+						merged: 0,
+						kept: 0,
+						pending: 0,
+						failed: 1
 					}
-				},
-				notes: []
-			};
-			const record = await recordRound2Outcome(options.io, options.home, options.now, row, outcome);
-			return {
-				...base,
-				stopReason: record.merged ? "completed" : "failed",
-				pairs: [record.pair],
-				totals: record.merged ? {
-					merged: 1,
-					kept: 0,
-					pending: 0,
-					failed: 0
-				} : {
-					merged: 0,
-					kept: 0,
-					pending: 0,
-					failed: 1
-				}
-			};
-		}
-	});
+				};
+			}
+		});
+	} finally {
+		await claim?.release();
+	}
 }
 //#endregion
 //#region lib/types/resume-command.js
@@ -3709,6 +3787,10 @@ function createMergeRuntime(deps) {
 				ok: false,
 				text: "merge pair 不接受受保护/保护状态未知技能: " + command.a + " / " + command.b
 			};
+			if (deps.isBlocked?.(command.a) === true || deps.isBlocked?.(command.b) === true) return {
+				ok: false,
+				text: "merge pair 不接受被范围门拦下的技能: " + command.a + " / " + command.b
+			};
 			const pair = [{
 				a: command.a,
 				b: command.b
@@ -3775,7 +3857,7 @@ function createMergeRuntime(deps) {
 		if (command.verb === "scan") {
 			const signal = new AbortController().signal;
 			const cards = await deps.cards(signal);
-			const managed = new Set(cards.filter((card) => card.managed === true && card.protectedBy == null).map((card) => card.name));
+			const managed = new Set(cards.filter((card) => card.managed === true && card.protectedBy == null && deps.isBlocked?.(card.name) !== true).map((card) => card.name));
 			const loadedState = await loadMergeState(deps.io, deps.home);
 			const skipped = skippedPairKeys(loadedState.state.rows, deps.params.mergeSkippedTtlDays, deps.now());
 			const held = new Set(loadedState.state.rows.filter((row) => row.queue === "pending" || row.queue === "fuse" || row.queue === "verify" && !canRetry(row)).map((row) => row.pairKey));
@@ -4713,6 +4795,9 @@ function apply(ctx, rawConfig = {}) {
 			parent: void 0,
 			allow: ["merge_stage"],
 			timeoutMinutes: params.mergeRunTimeoutMinutes,
+			isBlocked: (name) => {
+				return ctx.get("evolutionCurator")?.gates?.isBlocked?.(name) === true;
+			},
 			async cards(signal) {
 				const listed = await skills.list({ withContent: true });
 				if (signal.aborted) return [];

package/lib/types/approve-command.js

@@ -1,42 +1,55 @@
 import { approvePending } from "./pending-actions.js";
+import { loadMergeState } from "./state.js";
+import { acquireTargetClaim } from "./target-claim.js";
 import { withMergeRun } from "./run-shell.js";
 import { recordRound2Outcome } from "./round2-outcome.js";
 export async function runApproveCommand(options) {
-    const taken = await approvePending(options.io, options.home, options.now, options.rowId);
-    if (!taken.ok)
-        return { ok: false, message: taken.message };
-    const row = taken.row;
-    const decision = row.decision;
-    if (decision === undefined)
-        return { ok: false, message: 'pending row has no decision' };
-    return await withMergeRun({
-        io: options.io,
-        home: options.home,
-        registry: options.registry,
-        command: 'approve',
-        approval: { platformWrite: options.platformWrite, mergeApproval: true },
-        now: options.now,
-        async body(ctx) {
-            const stage = (name) => ctx.stage(name, { done: 0, total: 1 });
-            await stage('author');
-            let outcome;
-            try {
-                outcome = await options.ports.round2(row, decision, ctx.signal, ctx.runId);
-            }
-            catch (error) {
-                outcome = { kind: 'failed', failure: { stage: 'author', code: 'merge-failed', message: error instanceof Error ? error.message : String(error), retryable: true, retryFrom: 'agent2' } };
-            }
-            const base = { scope: { candidatePairs: 1, queueBefore: { verify: 0, pending: 0, fuse: 1, skipped: 0 } }, notes: [] };
-            const record = await recordRound2Outcome(options.io, options.home, options.now, row, outcome);
-            return {
-                ...base,
-                stopReason: record.merged ? 'completed' : 'failed',
-                pairs: [record.pair],
-                totals: record.merged
-                    ? { merged: 1, kept: 0, pending: 0, failed: 0 }
-                    : { merged: 0, kept: 0, pending: 0, failed: 1 },
-            };
-        },
-    });
+    const loaded = await loadMergeState(options.io, options.home);
+    const before = loaded.state.rows.find(item => item.id === options.rowId);
+    const target = before?.decision?.target;
+    const claim = target === undefined ? null : await acquireTargetClaim(options.io, options.home, target, options.now());
+    if (target !== undefined && claim === null)
+        return { ok: false, message: 'target already claimed by another approve: ' + target };
+    try {
+        const taken = await approvePending(options.io, options.home, options.now, options.rowId);
+        if (!taken.ok)
+            return { ok: false, message: taken.message };
+        const row = taken.row;
+        const decision = row.decision;
+        if (decision === undefined)
+            return { ok: false, message: 'pending row has no decision' };
+        return await withMergeRun({
+            io: options.io,
+            home: options.home,
+            registry: options.registry,
+            command: 'approve',
+            approval: { platformWrite: options.platformWrite, mergeApproval: true },
+            now: options.now,
+            async body(ctx) {
+                const stage = (name) => ctx.stage(name, { done: 0, total: 1 });
+                await stage('author');
+                let outcome;
+                try {
+                    outcome = await options.ports.round2(row, decision, ctx.signal, ctx.runId);
+                }
+                catch (error) {
+                    outcome = { kind: 'failed', failure: { stage: 'author', code: 'merge-failed', message: error instanceof Error ? error.message : String(error), retryable: true, retryFrom: 'agent2' } };
+                }
+                const base = { scope: { candidatePairs: 1, queueBefore: { verify: 0, pending: 0, fuse: 1, skipped: 0 } }, notes: [] };
+                const record = await recordRound2Outcome(options.io, options.home, options.now, row, outcome);
+                return {
+                    ...base,
+                    stopReason: record.merged ? 'completed' : 'failed',
+                    pairs: [record.pair],
+                    totals: record.merged
+                        ? { merged: 1, kept: 0, pending: 0, failed: 0 }
+                        : { merged: 0, kept: 0, pending: 0, failed: 1 },
+                };
+            },
+        });
+    }
+    finally {
+        await claim?.release();
+    }
 }
 //# sourceMappingURL=approve-command.js.map

package/lib/types/commit-recovery.js

@@ -42,7 +42,14 @@ export async function recoverCommitJournals(io, home, now, skillRoot, restoreSou
             reports.push({ runId: journal.runId, phase: journal.phase, action: 'receipt-committed', ok: true });
             continue;
         }
-        const snapshot = await readCommitSnapshot(io, home, journal.runId);
+        let snapshot;
+        try {
+            snapshot = await readCommitSnapshot(io, home, journal.runId);
+        }
+        catch (error) {
+            reports.push({ runId: journal.runId, phase: journal.phase, action: 'snapshot-read-failed: ' + (error instanceof Error ? error.message : String(error)), ok: false });
+            continue;
+        }
         let action = 'report-only';
         let ok = true;
         if (recovery === 'retry-commit') {

package/lib/types/index.js

@@ -218,6 +218,10 @@ export function apply(ctx, rawConfig = {}) {
         const runtime = createMergeRuntime({
             io, home, registry: runs, skills, now: () => Date.now(), params, platformWrite: true,
             channel, parent: undefined, allow: ['merge_stage'], timeoutMinutes: params.mergeRunTimeoutMinutes,
+            isBlocked: (name) => {
+                const curator = ctx.get('evolutionCurator');
+                return curator?.gates?.isBlocked?.(name) === true;
+            },
             async cards(signal) {
                 const listed = await skills.list({ withContent: true });
                 if (signal.aborted)

package/lib/types/runtime.d.ts

@@ -31,6 +31,8 @@ export interface MergeRuntimeDeps {
     /** Start scan/pair in the background and return the run id immediately. */
     readonly detached?: boolean;
     readonly cards: (signal: AbortSignal) => Promise<readonly SkillCard[]>;
+    /** Curator gate set: excluded/referenced/suppressed/protected builtins. */
+    readonly isBlocked?: (name: string) => boolean;
     /** Run-scoped engine screening. */
     readonly screeningForRun: (cards: readonly SkillCard[], runId: string, signal: AbortSignal) => Promise<readonly MergeCandidate[]>;
     readonly stage?: MergeStageBindingPort;

package/lib/types/runtime.js

@@ -59,6 +59,9 @@ export function createMergeRuntime(deps) {
                     || cardA.protectionUnknown === true || cardB.protectionUnknown === true) {
                     return { ok: false, text: 'merge pair 不接受受保护/保护状态未知技能: ' + command.a + ' / ' + command.b };
                 }
+                if (deps.isBlocked?.(command.a) === true || deps.isBlocked?.(command.b) === true) {
+                    return { ok: false, text: 'merge pair 不接受被范围门拦下的技能: ' + command.a + ' / ' + command.b };
+                }
                 const pair = [{ a: command.a, b: command.b }];
                 const existing = (await loadMergeState(deps.io, deps.home)).state.rows.find(row => row.pairKey === pairKey(command.a, command.b));
                 if (existing?.state === 'skipped') {
@@ -101,7 +104,9 @@ export function createMergeRuntime(deps) {
             if (command.verb === 'scan') {
                 const signal = new AbortController().signal;
                 const cards = await deps.cards(signal);
-                const managed = new Set(cards.filter(card => card.managed === true && card.protectedBy == null).map(card => card.name));
+                const managed = new Set(cards
+                    .filter(card => card.managed === true && card.protectedBy == null && deps.isBlocked?.(card.name) !== true)
+                    .map(card => card.name));
                 const loadedState = await loadMergeState(deps.io, deps.home);
                 const skipped = skippedPairKeys(loadedState.state.rows, deps.params.mergeSkippedTtlDays, deps.now());
                 const held = new Set(loadedState.state.rows.filter(row => row.queue === 'pending' || row.queue === 'fuse' || (row.queue === 'verify' && !canRetry(row))).map(row => row.pairKey));

package/lib/types/scan-run.js

@@ -65,15 +65,16 @@ export async function runScan(options) {
             if (!created.ok || created.row === null)
                 throw new Error(created.ok ? 'candidate row missing' : created.message);
             row = created.row;
-            const placed = await upsertRow(options.io, options.home, options.now, row, 'verify');
-            if (!placed.ok && placed.current.state === 'skipped') {
-                const restored = transition(placed.current, { type: 'restore', at: at(options.now) });
+            const before = (await loadMergeState(options.io, options.home)).state.rows.find(item => item.pairKey === row.pairKey);
+            const placed = await upsertRow(options.io, options.home, options.now, row, 'verify', before?.updatedAt ?? null);
+            if (!placed.ok && before?.state === 'skipped') {
+                const restored = transition(before, { type: 'restore', at: at(options.now) });
                 if (!restored.ok || restored.row === null)
                     throw new Error('cannot restore skipped pair');
+                const persisted = await upsertRow(options.io, options.home, options.now, restored.row, 'any', before.updatedAt);
+                if (!persisted.ok)
+                    throw new Error('pair changed while restoring skipped row');
                 row = restored.row;
-                const retried = await upsertRow(options.io, options.home, options.now, row, 'verify');
-                if (!retried.ok)
-                    throw new Error('pair already in ' + retried.current.state);
             }
             else if (!placed.ok) {
                 throw new Error('pair already in ' + placed.current.state);

package/lib/types/state.d.ts

@@ -29,7 +29,7 @@ export type UpsertResult = {
     readonly ok: false;
     readonly current: MergeRow;
 };
-export declare function upsertRow(io: EvolutionIoLike, home: string, now: () => number, row: MergeRow, expect?: UpsertExpect): Promise<UpsertResult>;
+export declare function upsertRow(io: EvolutionIoLike, home: string, now: () => number, row: MergeRow, expect?: UpsertExpect, cas?: string | null): Promise<UpsertResult>;
 export declare function moveRow(io: EvolutionIoLike, home: string, now: () => number, id: string, patch: MoveRowPatch): Promise<MergeRow | undefined>;
 export declare function dropRow(io: EvolutionIoLike, home: string, now: () => number, id: string): Promise<boolean>;
 export declare function rowsOf(io: EvolutionIoLike, home: string, queue?: MergeQueue): Promise<readonly MergeRow[]>;

package/lib/types/state.js

@@ -55,10 +55,13 @@ export async function mutateMergeState(io, home, now, fn) {
     void now;
     return result;
 }
-export async function upsertRow(io, home, now, row, expect = 'any') {
+export async function upsertRow(io, home, now, row, expect = 'any', cas) {
     return await mutateMergeState(io, home, now, (rows) => {
         const index = rows.findIndex(item => item.pairKey === row.pairKey);
         const current = index < 0 ? undefined : rows[index];
+        if (cas !== undefined && ((cas === null && current !== undefined) || (cas !== null && current?.updatedAt !== cas))) {
+            return { rows, result: { ok: false, current: current ?? row } };
+        }
         if (current !== undefined && expect !== 'any' && (expect === 'absent' || queueOf(current.state) !== expect)) {
             return { rows, result: { ok: false, current } };
         }

package/lib/types/target-claim.d.ts

@@ -0,0 +1,7 @@
+import { type EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
+export interface TargetClaim {
+    readonly token: string;
+    release(): Promise<void>;
+}
+export declare function acquireTargetClaim(io: EvolutionIoLike, home: string, target: string, now: number): Promise<TargetClaim | null>;
+//# sourceMappingURL=target-claim.d.ts.map

package/lib/types/target-claim.js

@@ -0,0 +1,46 @@
+/** Durable target claim: one approve writer per merge target at a time. */
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { contentHash } from '@lmzhen/dsh-evolution-core';
+import { acquireClaim, releaseClaim } from "./domain/claim.js";
+const LEASE_MS = 5 * 60_000;
+function claimPath(home, target) {
+    return join(home, 'merge', 'claims', contentHash(target) + '.json');
+}
+async function readClaim(io, home, target) {
+    const path = claimPath(home, target);
+    if (!(await io.exists(path)))
+        return undefined;
+    const raw = await io.readText(path);
+    if (raw === null)
+        return undefined;
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.token !== 'string' || typeof parsed.expiresAt !== 'number')
+        throw new Error('corrupt target claim: ' + target);
+    return { id: 'claim', token: parsed.token, expiresAt: parsed.expiresAt };
+}
+export async function acquireTargetClaim(io, home, target, now) {
+    const current = await readClaim(io, home, target);
+    const token = randomUUID();
+    const claim = acquireClaim(current, now, LEASE_MS, token);
+    if (claim === undefined)
+        return null;
+    await io.writeText(claimPath(home, target), JSON.stringify(claim) + '\n');
+    return {
+        token,
+        async release() {
+            const latest = await readClaim(io, home, target);
+            const next = releaseClaim(latest, token);
+            if (next === undefined) {
+                try {
+                    await io.remove(claimPath(home, target));
+                }
+                catch { /* already gone */ }
+            }
+            else {
+                await io.writeText(claimPath(home, target), JSON.stringify(next) + '\n');
+            }
+        },
+    };
+}
+//# sourceMappingURL=target-claim.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-merge",
   "description": "Skill auto-merge domain: screening, two-round authoring, queues and commit orchestration (community build)",
-  "version": "0.30.10",
+  "version": "0.30.12",
   "publishConfig": {
     "access": "public"
   },
@@ -27,8 +27,8 @@
   "license": "MIT",
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.5",
-    "@lmzhen/dsh-evolution-core": "^0.30.10",
-    "@lmzhen/dsh-evolution-merge-engine": "^0.30.10"
+    "@lmzhen/dsh-evolution-core": "^0.30.12",
+    "@lmzhen/dsh-evolution-merge-engine": "^0.30.12"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.5"