@lmzhen/dsh-evolution-merge 0.41.0 → 0.43.0

package/lib/types/adapters/library.d.ts

@@ -2,7 +2,7 @@
  * Library adapter: the only place the merge domain touches SkillLibrary's commit kernel.
  * The domain stays port-shaped; this file is the composition seam.
  */
-import type { SkillLibrary } from '@lmzhen/dsh-evolution-core';
+import type { SkillLibrary } from '@lmzhen/dsh-evolution-core/skills';
 import type { CommitPort } from '../commit-execute.ts';
 export declare function skillLibraryPort(skills: SkillLibrary): CommitPort;
 //# sourceMappingURL=library.d.ts.map

package/lib/types/adapters/model-runner.d.ts

@@ -3,7 +3,7 @@
  * runner(prompt, cfg) and expects raw model text; the runtime owns provider
  * selection, purpose, transport and timeout.
  */
-import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { createUserMessage } from '@lmzhen/dsh-evolution-core/platform';
 export interface ModelRoute {
     readonly provider: string;
     readonly model: string;

package/lib/types/adapters/model-runner.js

@@ -3,7 +3,7 @@
  * runner(prompt, cfg) and expects raw model text; the runtime owns provider
  * selection, purpose, transport and timeout.
  */
-import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { createUserMessage } from '@lmzhen/dsh-evolution-core/platform';
 import { normalizeProviderKey } from "../domain/provider-key.js";
 export function createEngineRunner(llm, route) {
     return async (prompt, cfg, runSignal) => {

package/lib/types/adapters/undo.d.ts

@@ -1,9 +1,4 @@
-/**
- * SkillLibrary-backed undo sink. Blobs are content-addressed but the library exposes them by
- * version, so the first readBlob call indexes all version bodies once; an undo is rare enough
- * that this is preferable to adding a second hash index.
- */
-import { type SkillLibrary } from '@lmzhen/dsh-evolution-core';
+import { type SkillLibrary } from '@lmzhen/dsh-evolution-core/skills';
 import type { MergeUndoPort } from '../undo-merge.ts';
 export declare function skillLibraryUndoPort(skills: SkillLibrary): MergeUndoPort;
 //# sourceMappingURL=undo.d.ts.map

package/lib/types/authoring-flow.d.ts

@@ -3,7 +3,8 @@
  * rule gate, then commit through the injected CommitPort. The channel adapter and the
  * author tool live outside; this is the seam they share.
  */
-import type { EvolutionIoLike, UnitTransaction } from '@lmzhen/dsh-evolution-core';
+import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
+import type { UnitTransaction } from './unit-protocol.ts';
 import { type RuleFinding } from './rules.ts';
 import { type CommitPort, type CommitStagedResult } from './commit-execute.ts';
 import type { StagedTree } from './rules.ts';

package/lib/types/commit-assembly.d.ts

@@ -7,8 +7,10 @@
  * port is called, so a source/target change is refused with a typed cause rather than a
  * generic commit message.
  */
-import type { CommitMergePlan, WriteOrigin, SkillLimits } from '@lmzhen/dsh-evolution-core';
-import { type RevisionFile } from '@lmzhen/dsh-evolution-core';
+import type { SkillLimits } from '@lmzhen/dsh-evolution-core';
+import type { WriteOrigin } from '@lmzhen/dsh-evolution-core/skills';
+import type { CommitMergePlan } from '@lmzhen/dsh-evolution-core/skills';
+import { type RevisionFile } from '@lmzhen/dsh-evolution-core/skills';
 import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
 import type { RevisionRef } from './contracts.ts';
 export interface CommitAssemblyPort {

package/lib/types/commit-assembly.js

@@ -1,7 +1,8 @@
-import { isPresent, revisionAnchorOf, revisionFingerprint, revisionSupportDigest } from '@lmzhen/dsh-evolution-core';
+import { isPresent } from '@lmzhen/dsh-evolution-core';
 import { readStaging } from "./staging.js";
 import { readStagedTree } from "./staged-tree.js";
 import { buildCommitPlan } from "./commit-plan.js";
+import { revisionAnchorOf, revisionFingerprint, revisionSupportDigest } from '@lmzhen/dsh-evolution-core/skills';
 function sameAnchor(expected, live) {
     if (expected.kind === 'absent')
         return live.kind === 'absent';

package/lib/types/commit-execute.d.ts

@@ -3,10 +3,11 @@
  * receipt. A failed commit returns without a receipt; a landed commit with a failed receipt
  * stays successful and carries a warning.
  */
-import type { CommitMergePlan, CommitMergeResult, EvolutionIoLike, SkillLimits } from '@lmzhen/dsh-evolution-core';
+import type { EvolutionIoLike, SkillLimits } from '@lmzhen/dsh-evolution-core';
+import type { CommitMergePlan, CommitMergeResult } from '@lmzhen/dsh-evolution-core/skills';
 import { type CommitAssemblyPort } from './commit-assembly.ts';
 import { type CommitReceipt } from './commit-receipt.ts';
-import type { UnitTransaction } from '@lmzhen/dsh-evolution-core';
+import type { UnitTransaction } from './unit-protocol.ts';
 export interface CommitPort extends CommitAssemblyPort {
     /** Transitional G2: when set, commit-execute prefers this over commitMerge. */
     unit?: UnitTransaction;

package/lib/types/commit-execute.js

@@ -21,7 +21,7 @@ export async function commitStagedRun(io, home, runId, port, options) {
     let result;
     let evidenceSha256;
     let warning;
-    const transaction = options.unit ?? port.unit ?? legacyUnitAdapter(port, assembled.plan, options, runId);
+    const transaction = options.unit ?? port.unit;
     if (transaction === undefined)
         return { ok: false, message: 'commit port missing: UnitTransaction or commitMerge required', plan: assembled.plan };
     {
@@ -99,28 +99,4 @@ export async function commitStagedRun(io, home, runId, port, options) {
         };
     }
 }
-function legacyUnitAdapter(port, plan, options, runId) {
-    if (port.commitMerge === undefined)
-        return undefined;
-    let evidence;
-    const unitId = 'legacy:' + plan.target + ':' + String(options.now());
-    return {
-        async prepare() { return { ok: true, prepared: { unitId, planDigest: unitId } }; },
-        async commit() {
-            if (port.commitMerge === undefined)
-                return { ok: false, code: 'unit-commit-failed', message: 'commitMerge missing' };
-            const result = await port.commitMerge(plan);
-            if (!result.ok)
-                return { ok: false, code: result.code ?? 'unit-commit-failed', message: result.message };
-            const actualUnitId = result.unitId ?? unitId;
-            evidence = { schemaVersion: 1, unitId: actualUnitId, runId, planDigest: actualUnitId, state: 'complete', target: { before: plan.expectedTargetBody, after: plan.body, supportDigest: '', created: !plan.targetExists }, sources: plan.expectedSourceBodies.map(source => ({ name: source.name, before: source.body, after: null, archived: (result.archived ?? []).includes(source.name), absorbedInto: plan.target })), mutations: result.mutations ?? 0, at: options.now() };
-            return { ok: true, evidence };
-        },
-        async verify() { return evidence ?? null; },
-        async rollback() { return { ok: false, code: 'unit-committed', message: 'legacy commit cannot roll back' }; },
-        async finalize() { return evidence === undefined ? { ok: false, code: 'unit-plan-missing', message: 'legacy unit has no evidence' } : { ok: true, evidence }; },
-        async rollForward() { return evidence === undefined ? { ok: false, code: 'unit-plan-missing', message: 'legacy unit has no evidence' } : { ok: true, evidence }; },
-        async cancel() { return { ok: false, phase: 'none' }; },
-    };
-}
 //# sourceMappingURL=commit-execute.js.map

package/lib/types/commit-plan.d.ts

@@ -5,7 +5,8 @@
  * This module only turns those bytes into a CommitMergePlan; it never reads the live tree and
  * never decides whether a merge is allowed (validateStagedTree does that).
  */
-import type { CommitMergePlan, WriteOrigin, SkillLimits } from '@lmzhen/dsh-evolution-core';
+import type { SkillLimits } from '@lmzhen/dsh-evolution-core';
+import type { CommitMergePlan, WriteOrigin } from '@lmzhen/dsh-evolution-core/skills';
 import type { RevisionRef } from './contracts.ts';
 export type ResolveTargetResult = {
     readonly ok: true;

package/lib/types/commit-recovery.js

@@ -2,7 +2,7 @@
 import { join } from 'node:path';
 import { writeJournal } from "./domain/commit-journal-store.js";
 import { readCommitReceipt } from "./commit-receipt.js";
-import { readUnitEvidence } from '@lmzhen/dsh-evolution-core';
+import { readUnitEvidence } from '@lmzhen/dsh-evolution-core/write';
 export async function recoverCommitJournals(io, home, now, isActive) {
     const dir = join(home, 'merge', 'journals');
     const reports = [];

package/lib/types/doctor.js

@@ -7,7 +7,8 @@ import { readTextOrNull } from "./domain/read-probe.js";
 import { createHash } from 'node:crypto';
 import { stat } from 'node:fs/promises';
 import { join } from 'node:path';
-import { probeList, readTreeLock, readUnitJournal, runsFile } from '@lmzhen/dsh-evolution-core';
+import { probeList, readTreeLock, runsFile } from '@lmzhen/dsh-evolution-core';
+import { readUnitJournal } from '@lmzhen/dsh-evolution-core/write';
 import { migrationJournalPath, migrationReportPath, v2BackupPath } from "./domain/state-bootstrap.js";
 import { readMergeSnapshot } from "./domain/merge-snapshot.js";
 import { validateArtifacts } from "./domain/consistency.js";

package/lib/types/domain/evidence-hash.d.ts

@@ -1,3 +1,3 @@
-import type { UnitEvidenceRecord } from '@lmzhen/dsh-evolution-core';
+import type { UnitEvidenceRecord } from '@lmzhen/dsh-evolution-core/write';
 export declare function evidenceSha256(evidence: UnitEvidenceRecord): string;
 //# sourceMappingURL=evidence-hash.d.ts.map

package/lib/types/index.js

@@ -4,8 +4,9 @@ import { screen as engineScreen } from '@lmzhen/dsh-evolution-merge-engine';
 import { selectWithErrors } from "./adapters/select.js";
 import { createEngineScreening } from "./adapters/engine-screen.js";
 import { createEngineRunner } from "./adapters/model-runner.js";
-import { authorityFrom, createSubagentChannel, evolutionHome, evolutionIoAdapter, newRunRegistry, newSkillLibrary, reportsSweepLockTarget, sweepReports, transactIo } from '@lmzhen/dsh-evolution-core';
+import { authorityFrom, createSubagentChannel, evolutionHome, evolutionIoAdapter, newRunRegistry, reportsSweepLockTarget, sweepReports, transactIo } from '@lmzhen/dsh-evolution-core';
 import { registerOwnerSettings } from '@lmzhen/dsh-evolution-core';
+import { newSkillLibrary } from '@lmzhen/dsh-evolution-core/skills';
 import { registerHostRoutes } from '@lmzhen/dsh-evolution-core/http-routes';
 import { loadMergeState } from "./state.js";
 import { pairLedger, normalizePairLedger } from "./domain/pair-ledger.js";
@@ -13,7 +14,8 @@ import { legacyToV3 } from "./domain/row-v3-bridge.js";
 import { readV4Readiness } from "./domain/schema4.js";
 import { readMergeSnapshot } from "./domain/merge-snapshot.js";
 import { readCommitReceipts } from "./commit-receipt.js";
-import { UnitTransactions, skillLibraryUnitBackend } from '@lmzhen/dsh-evolution-core';
+import { MergeUnitTransactions } from "./unit-protocol.js";
+import { skillLibraryUnitBackend } from "./skill-library-unit-backend.js";
 import { targetClaimUnitPort } from "./unit-claim.js";
 import { resolveLimitsSnapshot } from "./domain/merge-limits.js";
 import { resolveEngineInput } from "./domain/engine-input.js";
@@ -213,7 +215,7 @@ export function apply(ctx, rawConfig = {}) {
                 ctx.logger.warn('merge state is not ready: ' + value.code + ': ' + value.message);
                 return;
             }
-            const unit = new UnitTransactions({ io, home, backend: skillLibraryUnitBackend(skills), claim: targetClaimUnitPort(io, home, () => Date.now()), now: () => Date.now(), isActive: async (runId) => await runs.hasOwner(runId), ...(mutationAuthority?.homeFence === undefined ? {} : { fence: mutationAuthority.homeFence }) });
+            const unit = new MergeUnitTransactions({ io, home, backend: skillLibraryUnitBackend(skills), claim: targetClaimUnitPort(io, home, () => Date.now()), now: () => Date.now(), isActive: async (runId) => await runs.hasOwner(runId), serial: async (task) => await skills.runSerial(task), ...(mutationAuthority?.homeFence === undefined ? {} : { fence: mutationAuthority.homeFence }) });
             const cards = async () => await readSkillCards(skills);
             void (async () => {
                 // NFR-05: load the shared run index BEFORE recovery. Recovery settles through the

package/lib/types/new-child-authoring.d.ts

@@ -2,7 +2,8 @@
  * Round2 with a NEW child (approval after the pending window). The child gets the round2
  * prompt and writes the staging tree; the plugin then runs the same gate/commit path.
  */
-import type { EvolutionIoLike, UnitTransaction } from '@lmzhen/dsh-evolution-core';
+import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
+import type { UnitTransaction } from './unit-protocol.ts';
 import type { MergeDecision, MergeRow } from './contracts.ts';
 import type { SkillCard } from './skill-card.ts';
 import type { ConversationChannelLike } from './channel-port.ts';

package/lib/types/recovery-coordinator.d.ts

@@ -1,4 +1,5 @@
-import type { EvolutionIoLike, UnitTransaction } from '@lmzhen/dsh-evolution-core';
+import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
+import type { UnitTransaction } from './unit-protocol.ts';
 export type RecoveryBranch = 'A' | 'B' | 'C' | 'D';
 export interface RecoveryReport {
     readonly unitId: string;

package/lib/types/recovery-coordinator.js

@@ -1,6 +1,7 @@
 /** Batch 2c unit-journal recovery coordinator. UnitTransaction remains the only skill writer. */
 import { join } from 'node:path';
-import { probeList, readUnitEvidence } from '@lmzhen/dsh-evolution-core';
+import { probeList } from '@lmzhen/dsh-evolution-core';
+import { readUnitEvidence } from '@lmzhen/dsh-evolution-core/write';
 import { evidenceSha256 } from "./domain/evidence-hash.js";
 import { projectRecoveredUnit } from "./recovery-projection.js";
 import { readCommitReceipts } from "./commit-receipt.js";

package/lib/types/recovery-projection.d.ts

@@ -1,5 +1,6 @@
 /** Post-recovery projection: evidence -> report -> row remove -> stage drop -> settle/meta. */
-import type { EvolutionIoLike, UnitEvidenceRecord } from '@lmzhen/dsh-evolution-core';
+import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
+import type { UnitEvidenceRecord } from '@lmzhen/dsh-evolution-core/write';
 export interface ProjectionResult {
     readonly ok: boolean;
     readonly action: string;

package/lib/types/revision.js

@@ -1,4 +1,5 @@
-import { contentHash, revisionFingerprint, revisionSupportDigest } from '@lmzhen/dsh-evolution-core';
+import { contentHash } from '@lmzhen/dsh-evolution-core';
+import { revisionFingerprint, revisionSupportDigest } from '@lmzhen/dsh-evolution-core/skills';
 function fingerprint(card) {
     return revisionFingerprint(card.name, card.body, card.files ?? []);
 }

package/lib/types/rules.js

@@ -4,7 +4,9 @@
  * block = commit must not proceed; warn = report only. The path and reference checks reuse
  * the skill-store's own `validateSupportPath` / `supportRefs`, so there is one whitelist.
  */
-import { DEFAULT_SKILL_LIMITS, parseFrontmatter, scanContentThreats, supportRefs, validateFrontmatter, validateSupportPath, } from '@lmzhen/dsh-evolution-core';
+import { DEFAULT_SKILL_LIMITS, scanContentThreats, supportRefs } from '@lmzhen/dsh-evolution-core';
+import { parseFrontmatter, validateFrontmatter } from '@lmzhen/dsh-evolution-core/skills';
+import { validateSupportPath } from '@lmzhen/dsh-evolution-core/skills';
 const PLACEHOLDER = /\bTODO\b|\bxxx\b|\{\{[^}]*\}\}/i;
 const DESC_WARN_LENGTH = 60;
 export function validateStagedTree(tree, limits = DEFAULT_SKILL_LIMITS) {

package/lib/types/runtime.d.ts

@@ -1,4 +1,6 @@
-import { SkillLibrary, type EvolutionIoLike, type UnitTransaction } from '@lmzhen/dsh-evolution-core';
+import { type EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
+import { SkillLibrary } from '@lmzhen/dsh-evolution-core/skills';
+import type { UnitTransaction } from './unit-protocol.ts';
 import { type MergeCandidate, type MergeDecision, type MergeRow } from './contracts.ts';
 import type { MergeParams } from './params.ts';
 import type { SkillCard } from './skill-card.ts';

package/lib/types/runtime.js

@@ -4,7 +4,10 @@
  * out of apply() and makes the mutating verbs testable with fakes.
  */
 import { createHash } from 'node:crypto';
-import { errorText, isProcessAlive, probeText, SkillLibrary, UnitTransactions, skillLibraryUnitBackend } from '@lmzhen/dsh-evolution-core';
+import { errorText, isProcessAlive, probeText } from '@lmzhen/dsh-evolution-core';
+import { SkillLibrary } from '@lmzhen/dsh-evolution-core/skills';
+import { MergeUnitTransactions } from "./unit-protocol.js";
+import { skillLibraryUnitBackend } from "./skill-library-unit-backend.js";
 import { targetClaimUnitPort } from "./unit-claim.js";
 import { canRetry, pairKey } from "./contracts.js";
 import { skippedPairKeys } from "./skipped.js";
@@ -77,7 +80,7 @@ export function unitFor(deps) {
         return deps.unit;
     if (!(deps.skills instanceof SkillLibrary))
         return undefined;
-    return new UnitTransactions({ io: deps.io, home: deps.home, backend: skillLibraryUnitBackend(deps.skills), claim: targetClaimUnitPort(deps.io, deps.home, deps.now), now: deps.now });
+    return new MergeUnitTransactions({ io: deps.io, home: deps.home, backend: skillLibraryUnitBackend(deps.skills), claim: targetClaimUnitPort(deps.io, deps.home, deps.now), now: deps.now, serial: async (task) => await deps.skills.runSerial(task) });
 }
 export function createMergeRuntime(deps) {
     const ledger = () => pairLedger(deps.io, deps.home, deps.fence);

package/lib/types/scan-ports.d.ts

@@ -5,7 +5,8 @@
  * Approval on: round1 disposes the child immediately; the row waits in pending and the later
  * approve run must open a new child (not handled by this factory).
  */
-import type { EvolutionIoLike, UnitTransaction } from '@lmzhen/dsh-evolution-core';
+import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
+import type { UnitTransaction } from './unit-protocol.ts';
 import type { MergeDecision, MergeRow } from './contracts.ts';
 import type { SkillCard } from './skill-card.ts';
 import { type ConversationChannelLike } from './channel-port.ts';

package/lib/types/skill-library-unit-backend.d.ts

@@ -0,0 +1,5 @@
+/** G2 adapter: core UnitBackend over the existing SkillLibrary. */
+import type { SkillLibrary } from '@lmzhen/dsh-evolution-core/skills';
+import type { UnitBackend } from './unit-protocol.ts';
+export declare function skillLibraryUnitBackend(skills: SkillLibrary): UnitBackend;
+//# sourceMappingURL=skill-library-unit-backend.d.ts.map

package/lib/types/skill-library-unit-backend.js

@@ -0,0 +1,56 @@
+export function skillLibraryUnitBackend(skills) {
+    return {
+        async readSkill(name) { return await skills.read(name); },
+        async readSupportFile(name, path) {
+            const probe = skills.readSupportFile;
+            return typeof probe === 'function' ? await probe.call(skills, name, path) : null;
+        },
+        async commit(plan, onPhase, signal, assertFence, options) {
+            const result = await skills.commitMerge({
+                ...(plan.runId === undefined ? {} : { runId: plan.runId }),
+                ...(plan.unitId === undefined ? {} : { unitId: plan.unitId }),
+                target: plan.target,
+                nested: true,
+                targetExists: plan.targetExists,
+                sources: plan.sources,
+                body: plan.body,
+                supportFiles: plan.supportFiles,
+                expectedTargetBody: plan.expectedTargetBody,
+                expectedSourceBodies: plan.expectedSourceBodies,
+                origin: plan.origin,
+                summary: plan.summary,
+                ...(plan.skillLimits === undefined ? {} : { limits: plan.skillLimits }),
+                ...(plan.targetRevision === undefined ? {} : { targetRevision: plan.targetRevision }),
+                ...(plan.sourceRevisions === undefined ? {} : { sourceRevisions: plan.sourceRevisions }),
+                ...(plan.supportDigest === undefined ? {} : { supportDigest: plan.supportDigest }),
+                ...(onPhase === undefined ? {} : { onPhase }),
+                ...(signal === undefined ? {} : { signal }),
+                ...(assertFence === undefined ? {} : { assertFence }),
+            }, { ...(options?.serialized === undefined ? {} : { serialized: options.serialized }) });
+            return { ok: result.ok, message: result.message, ...(result.code === undefined ? {} : { code: result.code }), ...(result.archived === undefined ? {} : { archived: result.archived }), ...(result.mutations === undefined ? {} : { mutations: result.mutations }) };
+        },
+        async restoreTarget(name, body) {
+            if (body === null) {
+                await skills.archive(name, { reason: 'unit-rollback' });
+                return;
+            }
+            const result = await skills.update(name, body);
+            if (!result.ok)
+                throw new Error(result.message);
+        },
+        async restoreSupportFile(name, path, content) {
+            const result = content === null ? await skills.removeSupportFile(name, path) : await skills.writeSupportFile(name, path, content);
+            if (!result.ok)
+                throw new Error(result.message);
+        },
+        async restoreSource(name, body) {
+            const restored = await skills.restoreFromArchive(name);
+            if (restored.ok)
+                return;
+            const result = await skills.update(name, body);
+            if (!result.ok)
+                throw new Error(result.message);
+        },
+    };
+}
+//# sourceMappingURL=skill-library-unit-backend.js.map

package/lib/types/undo-merge.d.ts

@@ -3,8 +3,8 @@
  * sources; this module resolves versions, plans the cross-skill undo and runs the shared
  * executor. No command/routing logic here.
  */
-import type { SkillVersion } from '@lmzhen/dsh-evolution-core';
-import { type UnitUndoExecution, type UnitUndoSink } from '@lmzhen/dsh-evolution-core';
+import type { SkillVersion } from '@lmzhen/dsh-evolution-core/skills';
+import { type UnitUndoExecution, type UnitUndoSink } from '@lmzhen/dsh-evolution-core/write';
 import type { CommitReceipt } from './commit-receipt.ts';
 export interface MergeUndoPort extends UnitUndoSink {
     listVersions(skill: string): Promise<readonly SkillVersion[]>;

package/lib/types/undo-merge.js

@@ -1,4 +1,4 @@
-import { executeUnitUndo, planUnitUndoAcross } from '@lmzhen/dsh-evolution-core';
+import { executeUnitUndo, planUnitUndoAcross } from '@lmzhen/dsh-evolution-core/write';
 export async function undoMergeReceipt(receipt, port) {
     const targetVersions = (await port.listVersions(receipt.target)).filter(entry => entry.unitId === receipt.unitId);
     if (targetVersions.length === 0) {

package/lib/types/undo-operation.js

@@ -5,7 +5,7 @@ import { writeUndoJournal } from "./domain/undo-journal.js";
 import { readUndoReceipt, writeUndoReceipt } from "./domain/undo-receipt.js";
 import { recordPair } from "./domain/pair-index-store.js";
 import { readRunMeta, writeRunMeta } from "./domain/run-coordinator.js";
-import { readUnitEvidence } from '@lmzhen/dsh-evolution-core';
+import { readUnitEvidence } from '@lmzhen/dsh-evolution-core/write';
 import { evidenceSha256 as unitEvidenceDigest } from "./domain/evidence-hash.js";
 function digest(value) { return value === null ? null : contentHash(value); }
 function sortReceipts(receipts) {

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

@@ -1,5 +1,5 @@
 import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
-import type { UnitClaimPort } from '@lmzhen/dsh-evolution-core';
+import type { UnitClaimPort } from '@lmzhen/dsh-evolution-core/write';
 /** Commit-phase claim: 24h is only stale recovery; commit releases immediately, no approve TTL. */
 export declare function targetClaimUnitPort(io: EvolutionIoLike, home: string, now: () => number): UnitClaimPort;
 //# sourceMappingURL=unit-claim.d.ts.map

package/lib/types/unit-protocol.d.ts

@@ -0,0 +1,227 @@
+import type { EvolutionIoLike, SkillLimits } from '@lmzhen/dsh-evolution-core';
+import type { HomeFence } from '@lmzhen/dsh-evolution-core';
+import { type UnitEvidenceRecord } from '@lmzhen/dsh-evolution-core/write';
+import { type UnitJournalPhase } from '@lmzhen/dsh-evolution-core/write';
+export interface UnitSupportFile {
+    readonly path: string;
+    readonly content: string;
+}
+export interface UnitPlan {
+    readonly runId: string;
+    /** Filled by the transaction before the backend write; history records it. */
+    readonly unitId?: string;
+    readonly pairKey: string;
+    readonly target: string;
+    readonly targetExists: boolean;
+    readonly sources: readonly string[];
+    readonly body: string;
+    readonly supportFiles: readonly UnitSupportFile[];
+    readonly expectedTargetBody: string | null;
+    readonly expectedSourceBodies: readonly {
+        name: string;
+        body: string;
+    }[];
+    readonly origin: "foreground" | "subagent" | "background_review";
+    readonly summary: string;
+    readonly skillLimits?: SkillLimits;
+    readonly limitsDigest?: string;
+    readonly validationPlan?: {
+        readonly planVersion: 1;
+        readonly stageDigest: string;
+        readonly revision: string;
+    };
+    readonly targetRevision?: {
+        readonly kind: 'absent';
+    } | {
+        readonly kind: 'present';
+        readonly sha256: string;
+    };
+    readonly sourceRevisions?: Readonly<Record<string, {
+        readonly kind: 'absent';
+    } | {
+        readonly kind: 'present';
+        readonly sha256: string;
+    }>>;
+    readonly supportDigest?: string;
+}
+export interface UnitCommitResult {
+    readonly ok: boolean;
+    readonly message: string;
+    /** Typed backend refusal (revision CAS); absent means a generic commit failure. */
+    readonly code?: UnitErrorCode;
+    readonly archived?: readonly string[];
+    readonly mutations?: number;
+}
+export interface UnitBackend {
+    readSkill(name: string): Promise<string | null>;
+    readSupportFile(name: string, path: string): Promise<string | null>;
+    commit(plan: UnitPlan, onPhase?: (phase: "target-pending" | "target-applied" | "target-written" | "source-archiving" | "sources-archived" | "support-pending" | "unit-written", detail?: {
+        source?: string;
+    }) => void | Promise<void>, signal?: AbortSignal, assertFence?: () => Promise<boolean>, options?: {
+        readonly serialized?: boolean;
+    }): Promise<UnitCommitResult>;
+    restoreTarget(name: string, body: string | null): Promise<void>;
+    restoreSource(name: string, body: string): Promise<void>;
+    restoreSupportFile?(name: string, path: string, content: string | null): Promise<void>;
+}
+import type { UnitClaimPort } from '@lmzhen/dsh-evolution-core/write';
+export interface UnitTransactionOptions {
+    readonly io: EvolutionIoLike;
+    readonly home: string;
+    readonly backend: UnitBackend;
+    readonly claim: UnitClaimPort;
+    readonly now?: () => number;
+    readonly waitMs?: number;
+    /** Gate/fault-injection seam: called after each journal phase is durable. */
+    readonly onPhase?: (phase: UnitJournalPhase) => void | Promise<void>;
+    /** Gate instrumentation: tree fence then target claim. */
+    readonly onLock?: (lock: "tree" | "claim") => void;
+    /** One home fence owned by authority; when set, MergeUnitTransactions must not acquire tree-lock itself. */
+    readonly fence?: HomeFence;
+    /** Writer queue acquired BEFORE the fence, so merge and ordinary store writes share one lock order. */
+    readonly serial?: <T>(task: () => Promise<T>) => Promise<T>;
+    /** Optional run liveness gate: false means the run is terminal and must not commit. */
+    readonly isActive?: (runId: string) => boolean | Promise<boolean>;
+}
+export type UnitErrorCode = "unit-plan-missing" | "unit-conflict" | "unit-committed" | "unit-prepare-failed" | "unit-commit-failed" | "unit-claim-failed" | "unit-fence-failed" | "unit-run-inactive" | "unit-rollback-blocked" | "target-changed" | "source-changed" | "support-changed";
+export interface UnitFailure {
+    readonly ok: false;
+    readonly code: UnitErrorCode;
+    readonly message: string;
+}
+export interface UnitPrepared {
+    readonly unitId: string;
+    readonly planDigest: string;
+}
+export interface UnitTransaction {
+    prepare(plan: UnitPlan): Promise<{
+        ok: true;
+        prepared: UnitPrepared;
+    } | UnitFailure>;
+    commit(prepared: UnitPrepared, options?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        ok: true;
+        evidence: UnitEvidenceRecord;
+    } | UnitFailure>;
+    verify(ref: {
+        unitId: string;
+    } | {
+        runId: string;
+    }): Promise<UnitEvidenceRecord | UnitEvidenceRecord[] | null>;
+    rollback(ref: {
+        unitId: string;
+        reason: string;
+    }): Promise<{
+        ok: true;
+        evidence: UnitEvidenceRecord;
+    } | UnitFailure>;
+    finalize(unitId: string): Promise<{
+        ok: true;
+        evidence: UnitEvidenceRecord;
+    } | UnitFailure>;
+    rollForward(unitId: string): Promise<{
+        ok: true;
+        evidence: UnitEvidenceRecord;
+    } | UnitFailure>;
+    cancel(unitId: string, reason: string): Promise<{
+        ok: boolean;
+        phase: UnitJournalPhase | "none";
+    }>;
+}
+export declare function unitEvidenceDigest(evidence: UnitEvidenceRecord): string;
+export declare class MergeUnitTransactions implements UnitTransaction {
+    private readonly options;
+    private readonly prepared;
+    private readonly commits;
+    private readonly now;
+    constructor(options: UnitTransactionOptions);
+    private unitId;
+    private snapshot;
+    prepare(plan: UnitPlan): Promise<{
+        ok: true;
+        prepared: {
+            unitId: string;
+            planDigest: string;
+        };
+        code?: never;
+        message?: never;
+    } | {
+        ok: false;
+        code: "unit-conflict";
+        message: string;
+        prepared?: never;
+    }>;
+    commit(prepared: UnitPrepared, options?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        ok: true;
+        evidence: UnitEvidenceRecord;
+    } | UnitFailure>;
+    private commitOnce;
+    verify(ref: {
+        unitId: string;
+    } | {
+        runId: string;
+    }): Promise<UnitEvidenceRecord | UnitEvidenceRecord[] | null>;
+    private withRecoveryFence;
+    finalize(unitId: string): Promise<{
+        ok: true;
+        evidence: UnitEvidenceRecord;
+        code?: never;
+        message?: never;
+    } | {
+        ok: false;
+        code: "unit-rollback-blocked";
+        message: string;
+        evidence?: never;
+    }>;
+    private finalizeUnlocked;
+    rollForward(unitId: string): Promise<{
+        ok: true;
+        evidence: UnitEvidenceRecord;
+        code?: never;
+        message?: never;
+    } | {
+        ok: false;
+        code: "unit-rollback-blocked";
+        message: string;
+        evidence?: never;
+    }>;
+    private rollForwardUnlocked;
+    rollback(ref: {
+        unitId: string;
+        reason: string;
+    }): Promise<{
+        ok: false;
+        code: "unit-committed";
+        message: string;
+        evidence?: never;
+    } | {
+        ok: false;
+        code: "unit-rollback-blocked";
+        message: string;
+        evidence?: never;
+    } | {
+        ok: false;
+        code: "unit-fence-failed";
+        message: string;
+        evidence?: never;
+    } | {
+        ok: true;
+        evidence: UnitEvidenceRecord;
+        code?: never;
+        message?: never;
+    }>;
+    cancel(unitId: string, reason: string): Promise<{
+        ok: boolean;
+        phase: "none";
+    } | {
+        ok: boolean;
+        phase: "target-pending" | "target-written" | "source-archiving" | "sources-archived" | "support-pending";
+    } | {
+        ok: boolean;
+        phase: "failed" | "committed" | "unit-written" | "prepared" | "rolled-back";
+    }>;
+}
+//# sourceMappingURL=unit-protocol.d.ts.map