@lmzhen/dsh-evolution-merge 0.30.9 → 0.30.11

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) {
@@ -799,7 +799,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";
@@ -1531,7 +1542,7 @@ function mergeUsage() {
 }
 //#endregion
 //#region lib/types/read-commands.js
-async function handleReadOnlyMergeCommand(command, io, home) {
+async function handleReadOnlyMergeCommand(command, io, home, cards) {
 	const withNote = (text, note) => note === void 0 ? text : "note: " + note + "\n" + text;
 	if (command.verb === "status") {
 		const loaded = await loadMergeState(io, home);
@@ -1544,7 +1555,8 @@ async function handleReadOnlyMergeCommand(command, io, home) {
 	if (command.verb === "pending") {
 		const loaded = await loadMergeState(io, home);
 		const rows = command.expired === true ? loaded.state.rows.filter((row) => row.expired !== void 0) : loaded.state.rows;
-		return withNote(command.expired === true ? formatStatus(rows) : formatQueue(rows, "pending"), loaded.note);
+		const live = cards === void 0 ? rows : rows.filter((row) => cards.some((card) => card.name === row.a) && cards.some((card) => card.name === row.b));
+		return withNote(command.expired === true ? formatStatus(live) : formatQueue(live, "pending"), loaded.note);
 	}
 	if (command.verb === "candidates") {
 		const loaded = await loadMergeState(io, home);
@@ -2215,6 +2227,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();
@@ -2288,79 +2350,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 {
-		ok: false,
-		message: taken.message
-	};
-	const row = taken.row;
-	const decision = row.decision;
-	if (decision === void 0) 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: "pending row has no decision"
+		message: "target already claimed by another approve: " + target
 	};
-	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
@@ -3224,6 +3296,9 @@ async function commitStagedRun(io, home, runId, port, options) {
 	};
 	try {
 		await writeCommitReceipt(io, home, receipt);
+		try {
+			await io.remove(snapshotPath(home, runId));
+		} catch {}
 		return {
 			ok: true,
 			plan: assembled.plan,
@@ -3705,6 +3780,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
@@ -3771,7 +3850,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));
@@ -4114,7 +4193,8 @@ function createMergeRuntime(deps) {
 				text: "merge approve 完成：merged " + String(result.report.totals.merged)
 			};
 		}
-		const text = await handleReadOnlyMergeCommand(command, deps.io, deps.home);
+		const cards = command.verb === "pending" ? await deps.cards(new AbortController().signal) : void 0;
+		const text = await handleReadOnlyMergeCommand(command, deps.io, deps.home, cards);
 		if (text !== null) return {
 			ok: true,
 			text
@@ -4708,6 +4788,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-execute.js

@@ -2,7 +2,7 @@ import { assembleStagedCommit } from "./commit-assembly.js";
 import { writeCommitReceipt } from "./commit-receipt.js";
 import { pairKey } from "./contracts.js";
 import { writeJournal } from "./domain/commit-journal-store.js";
-import { writeCommitSnapshot } from "./commit-snapshot.js";
+import { snapshotPath, writeCommitSnapshot } from "./commit-snapshot.js";
 export async function commitStagedRun(io, home, runId, port, options) {
     const assembled = await assembleStagedCommit(io, home, runId, port, { origin: options.origin, summary: options.summary });
     if (!assembled.ok)
@@ -46,6 +46,10 @@ export async function commitStagedRun(io, home, runId, port, options) {
     };
     try {
         await writeCommitReceipt(io, home, receipt);
+        try {
+            await io.remove(snapshotPath(home, runId));
+        }
+        catch { /* committed journal is the record */ }
         return { ok: true, plan: assembled.plan, result, receipt };
     }
     catch (error) {

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/read-commands.d.ts

@@ -4,6 +4,8 @@
  */
 import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
 import type { MergeCliCommand } from './commands.ts';
-export declare function handleReadOnlyMergeCommand(command: MergeCliCommand, io: EvolutionIoLike, home: string): Promise<string | null>;
+export declare function handleReadOnlyMergeCommand(command: MergeCliCommand, io: EvolutionIoLike, home: string, cards?: readonly {
+    readonly name: string;
+}[]): Promise<string | null>;
 export declare function mergeCommandHelp(): string;
 //# sourceMappingURL=read-commands.d.ts.map

package/lib/types/read-commands.js

@@ -1,7 +1,7 @@
 import { loadMergeState } from "./state.js";
 import { formatQueue, formatStatus } from "./status.js";
 import { mergeUsage } from "./commands.js";
-export async function handleReadOnlyMergeCommand(command, io, home) {
+export async function handleReadOnlyMergeCommand(command, io, home, cards) {
     const withNote = (text, note) => note === undefined ? text : 'note: ' + note + '\n' + text;
     if (command.verb === 'status') {
         const loaded = await loadMergeState(io, home);
@@ -14,7 +14,8 @@ export async function handleReadOnlyMergeCommand(command, io, home) {
     if (command.verb === 'pending') {
         const loaded = await loadMergeState(io, home);
         const rows = command.expired === true ? loaded.state.rows.filter(row => row.expired !== undefined) : loaded.state.rows;
-        return withNote(command.expired === true ? formatStatus(rows) : formatQueue(rows, 'pending'), loaded.note);
+        const live = cards === undefined ? rows : rows.filter(row => cards.some(card => card.name === row.a) && cards.some(card => card.name === row.b));
+        return withNote(command.expired === true ? formatStatus(live) : formatQueue(live, 'pending'), loaded.note);
     }
     if (command.verb === 'candidates') {
         const loaded = await loadMergeState(io, home);

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));
@@ -314,7 +319,8 @@ export function createMergeRuntime(deps) {
                     return { ok: false, text: 'merge approve started without a report' };
                 return { ok: true, text: 'merge approve 完成：merged ' + String(result.report.totals.merged) };
             }
-            const text = await handleReadOnlyMergeCommand(command, deps.io, deps.home);
+            const cards = command.verb === 'pending' ? await deps.cards(new AbortController().signal) : undefined;
+            const text = await handleReadOnlyMergeCommand(command, deps.io, deps.home, cards);
             if (text !== null)
                 return { ok: true, text };
             return readOnly.execute(command);

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.9",
+  "version": "0.30.11",
   "publishConfig": {
     "access": "public"
   },
@@ -27,8 +27,8 @@
   "license": "MIT",
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.5",
-    "@lmzhen/dsh-evolution-core": "^0.30.9",
-    "@lmzhen/dsh-evolution-merge-engine": "^0.30.9"
+    "@lmzhen/dsh-evolution-core": "^0.30.11",
+    "@lmzhen/dsh-evolution-merge-engine": "^0.30.11"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.5"