@lmzhen/dsh-evolution-core 0.30.17 → 0.30.18

package/lib/subagent/index.js

@@ -1,4 +1,4 @@
-import { h as restrictedPresetId, n as ensureRestrictedPreset, r as restrictedPresetState } from "../ensure-MEYMj9jn.js";
+import { h as restrictedPresetId, n as ensureRestrictedPreset, r as restrictedPresetState } from "../ensure-BuWsjPGD.js";
 //#region lib/types/subagent/readiness.js
 function serviceOf$1(ctx, name) {
 	return ctx.get(name);

package/lib/types/composition/composer.js

@@ -372,7 +372,7 @@ export function presetRowBlock(patchText, rowId) {
     const span = rowBlockSpan(lines, rowId);
     if (span === null)
         return null;
-    const block = [...lines.slice(span.start, span.end)];
+    const block = lines.slice(span.start, span.end);
     while (block.length > 0 && (block[block.length - 1] ?? '').trim() === '')
         block.pop();
     return block.join('\n') + '\n';

package/lib/types/frontmatter.js

@@ -385,7 +385,7 @@ export function yamlPlainScalarNeedsQuotes(value) {
         return true;
     if (/^(?:[-+]?\.inf|\.nan)$/i.test(value))
         return true;
-    if (/^[-?:,[\]{}#&*!|>'\"%@`\s]/.test(value))
+    if (/^[-?:,[\]{}#&*!|>'"%@`\s]/.test(value))
         return true;
     return false;
 }

package/lib/types/http-routes.d.ts

@@ -56,6 +56,8 @@ export declare const HOST_ROUTES: {
     readonly merge: {
         readonly view: "/api/dsh-evolution/merge/view";
         readonly rows: "/api/dsh-evolution/merge/rows";
+        readonly run: "/api/dsh-evolution/merge/run";
+        readonly runs: "/api/dsh-evolution/merge/runs";
         readonly body: "/api/dsh-evolution/merge/body";
         readonly history: "/api/dsh-evolution/merge/history";
     };

package/lib/types/http-routes.js

@@ -53,6 +53,8 @@ export const HOST_ROUTES = {
     merge: {
         view: '/api/dsh-evolution/merge/view',
         rows: '/api/dsh-evolution/merge/rows',
+        run: '/api/dsh-evolution/merge/run',
+        runs: '/api/dsh-evolution/merge/runs',
         body: '/api/dsh-evolution/merge/body',
         history: '/api/dsh-evolution/merge/history',
     },

package/lib/types/index.d.ts

@@ -33,6 +33,10 @@
  */
 export * from './citations.ts';
 export * from './tree-write.ts';
+export * from './unit-storage.ts';
+export * from './unit-journal.ts';
+export * from './unit-transaction.ts';
+export * from './unit-backend.ts';
 export * from './package-identity.ts';
 export * from './write-authority.ts';
 export * from './write-gates.ts';

package/lib/types/index.js

@@ -34,6 +34,10 @@
 export * from "./citations.js";
 // G1/1.1: the ONE authority behind a write (its type and the authorityFrom builder).
 export * from "./tree-write.js";
+export * from "./unit-storage.js";
+export * from "./unit-journal.js";
+export * from "./unit-transaction.js";
+export * from "./unit-backend.js";
 export * from "./package-identity.js";
 export * from "./write-authority.js";
 export * from "./write-gates.js";

package/lib/types/params.js

@@ -208,7 +208,6 @@ export const PARAM_EXPOSURE = Object.freeze([
     { id: 'mergeSkippedTtlDays', group: 'merge', tier: 'E3', authority: 'cordis', owner: 'evolution-merge', applies: 'live', docAnchor: 'PARAMETERS.md#merge', summary: 'Days a skipped pair stays out of screening; 0 means it never expires.', label: '无需合并保留天数', hint: '判定无需合并的对，多少天内不再参与筛选；0 表示一直保留。', control: 'number', unit: '天', values: '', card: 'evolution-merge' },
     { id: 'mergeRunTimeoutMinutes', group: 'merge', tier: 'E3', authority: 'cordis', owner: 'evolution-merge', applies: 'live', docAnchor: 'PARAMETERS.md#merge', summary: 'Wall-clock budget of one merge run; 0 means no limit.', label: '单次运行上限', hint: '一次合并运行最多持续多少分钟；0 表示不设上限。', control: 'number', unit: '分钟', values: '', card: 'evolution-merge' },
     { id: 'mergePairTimeoutMinutes', group: 'merge', tier: 'E2', authority: 'cordis', owner: 'evolution-merge', applies: 'none', docAnchor: 'PARAMETERS.md#merge', summary: 'Wall-clock budget of one pair round (a stuck child guard).', why: 'internal' },
-    { id: 'mergeModelsRoot', group: 'merge', tier: 'E2', authority: 'cordis', owner: 'evolution-merge', applies: 'none', docAnchor: 'PARAMETERS.md#merge', summary: 'Local model root containing the int8 and pca64 model directories; empty falls back to SKILL_MERGE_MODELS_ROOT. No auto provisioning.', why: 'path' },
 ]);
 /** The settings namespace each OWNER PACKAGE registers (design §7.2).
  *

package/lib/types/platform-services.d.ts

@@ -20,7 +20,7 @@ export interface PlatformServiceProbe {
     /** Where the probe runs. */
     readonly side: 'host' | 'client';
 }
-/** The 26 probes, in service-name order (the guard checks this list against the tree). */
+/** The 25 probes, in service-name order (the guard checks this list against the tree). */
 export declare const PLATFORM_SERVICE_PROBES: readonly PlatformServiceProbe[];
 /**
  * The HOST-side probes that do not resolve in this runtime — what `/evolution doctor` prints as

package/lib/types/platform-services.js

@@ -11,7 +11,7 @@
  * `client` probes run in the browser half, where the host has no view of the seats.
  * @module @lmzhen/dsh-evolution-core
  */
-/** The 26 probes, in service-name order (the guard checks this list against the tree). */
+/** The 25 probes, in service-name order (the guard checks this list against the tree). */
 export const PLATFORM_SERVICE_PROBES = Object.freeze([
     { service: 'agents', feature: 'review and curator subagent wake-ups', side: 'host' },
     { service: 'approval', feature: 'the platform approval policy the approval row shadows', side: 'host' },
@@ -20,9 +20,9 @@ export const PLATFORM_SERVICE_PROBES = Object.freeze([
     { service: 'evolutionApproval', feature: 'pending writes: list, approve and reject from the command surface', side: 'host' },
     { service: 'evolutionCurator', feature: '/evolution curator subcommands, skill undo and history', side: 'host' },
     { service: 'evolutionIo', feature: 'every durable read and write (the IO seam)', side: 'host' },
+    { service: 'evolutionMerge', feature: 'merge rows and run state', side: 'host' },
     { service: 'hmr', feature: 'the preset install read-merge-write commit (the platform HMR lock serializes it)', side: 'host' },
     { service: 'evolutionMemoryBudget', feature: 'the memory-budget divergence section of this report', side: 'host' },
-    { service: 'evolutionMerge', feature: 'the merge command and its read-only panel routes', side: 'host' },
     { service: 'evolutionPolicy', feature: 'the policy snapshot that shadows row knobs', side: 'host' },
     { service: 'evolutionReplay', feature: '/evolution replay', side: 'host' },
     { service: 'evolutionState', feature: 'the state facade behind activity and replay', side: 'host' },

package/lib/types/redact.js

@@ -30,7 +30,7 @@ const SECRET_PATTERNS = [
     ['google api key', /AIza[0-9A-Za-z_-]{30,}/g],
     // F-335 (0.3.23): case-insensitive (`bearer`), and `\s+` so a tab or run of
     // spaces between `Bearer` and the token is still masked (`Bearer\t...`).
-    ['bearer credential', /Bearer[\s]+[a-z0-9._~+/=\-]{16,}/gi],
+    ['bearer credential', /Bearer[\s]+[a-z0-9._~+/=-]{16,}/gi],
     // R3 (round-2 audit): HTTP Basic — `Authorization: Basic <base64>` crossed
     // every model boundary: `Basic` was in no value-shape row and
     // `authorization` in no keyword set, so the base64 user:password blob
@@ -117,7 +117,7 @@ const PEM_PRIVATE_KEY_PATTERN = new RegExp(`${PEM_HEAD}[\\s\\S]*?${PEM_TAIL}`, '
 // secret crossed verbatim. Both anchors now tolerate an optional `\r` so the
 // line-paired pass behaves identically on LF and CRLF input (Windows-authored
 // .env / compose / kubectl YAML is the realistic carrier).
-const BLOCK_KEY_ONLY_LINE = /(?:^|\s)([\w-]*[_\-])?((?:token|api[_-]?key|secret|password|passwd)(?:[_\-][\w-]*)?)\s*:(?:\r)?$/i;
+const BLOCK_KEY_ONLY_LINE = /(?:^|\s)([\w-]*[_-])?((?:token|api[_-]?key|secret|password|passwd)(?:[_-][\w-]*)?)\s*:(?:\r)?$/i;
 // S0.3 (v37 P0-2): the two patterns above cannot express a camelCase hump —
 // they are case-INSENSITIVE, so [A-Z] would match lowercase too. This pair
 // decides by a case-insensitive KEYWORD test that rejects a lowercase

package/lib/types/run-registry.d.ts

@@ -114,6 +114,12 @@ export interface RunRegistry {
         ok: boolean;
         note?: string;
     }>;
+    /** Load and throw on unreadable/invalid index. */
+    ensureLoaded(): Promise<void>;
+    /** The active run after ensureLoaded; explicit read entry. */
+    findActive(kind?: RunKind): Promise<RunRecord | undefined>;
+    /** Whether this run id is currently owned by a live running process (RG0b). */
+    hasOwner(id: string): Promise<boolean>;
     /**
      * Register a new run, arm its cancellation, and return its handle.
      *
@@ -146,6 +152,8 @@ export interface RunRegistry {
     runs(kind?: RunKind): readonly RunRecord[];
     /** One run by id, converged view included. */
     find(id: string): RunRecord | undefined;
+    /** Settle a running run whose owner is gone as failed(orphan). @returns whether a run was running. */
+    settleOrphan(id: string): Promise<boolean>;
     /** Ask a running run to stop; it settles as `cancelled`. @returns whether it was running. */
     cancel(id: string): boolean;
     /** Ask every running run to stop (fiber dispose). @returns how many were running. */

package/lib/types/run-registry.js

@@ -291,6 +291,26 @@ export function newRunRegistry(options) {
             ].filter((note) => note !== undefined);
             return { ok: true, ...(notes.length > 0 ? { note: notes.join('; ') } : {}) };
         },
+        async ensureLoaded() {
+            const loaded = await this.load();
+            if (!loaded.ok)
+                throw new Error(loaded.note ?? 'runs-unreadable');
+        },
+        async findActive(kind) {
+            await this.ensureLoaded();
+            return this.inFlight(kind);
+        },
+        async hasOwner(id) {
+            await this.ensureLoaded();
+            return this.find(id)?.state === 'running';
+        },
+        async settleOrphan(id) {
+            const run = this.find(id);
+            if (run?.state !== 'running')
+                return false;
+            await this.settle(id, { state: 'failed', failure: 'orphan', mergeStatus: 'orphan' });
+            return true;
+        },
         async begin(kind, seed) {
             const id = randomUUID();
             const startedAt = now();

package/lib/types/skill-store.d.ts

@@ -198,6 +198,14 @@ export interface CommitMergePlan {
     }[];
     readonly origin: WriteOrigin;
     readonly summary: string;
+    /** Real write-phase callback used by UnitTransaction; not persisted. */
+    readonly onPhase?: (phase: 'target-pending' | 'target-applied' | 'target-written' | 'source-archiving' | 'sources-archived' | 'support-pending' | 'unit-written', detail?: {
+        source?: string;
+    }) => void | Promise<void>;
+    /** Phase-boundary cancellation; checked before target/source writes. */
+    readonly signal?: AbortSignal;
+    /** Tree-fence guard; checked before every tree/source write. */
+    readonly assertFence?: () => Promise<boolean>;
 }
 export interface CommitMergeResult {
     readonly ok: boolean;
@@ -444,6 +452,8 @@ export declare class SkillLibrary {
     deleteProtection(rawName: string, options?: {
         allowBundled?: boolean | undefined;
     }): Promise<string | null>;
+    /** Whether the target directory exists at all (a SKILL.md-less ghost still occupies the name). */
+    skillDirExists(rawName: string): Promise<boolean>;
     isManaged(rawName: string): Promise<boolean>;
     /** Whether the skill carries the bundled marker (curator prune-builtins eligibility). */
     isBundled(rawName: string): Promise<boolean>;

package/lib/types/skill-store.js

@@ -51,7 +51,7 @@ import { contentHash, loadMutations, recordMutation } from "./mutations.js";
 import { contentRetentionFeedback, HISTORY_DIR, loadVersionContent, loadVersions, recordVersions } from "./skill-history.js";
 import { suppressedFile, usageFile } from "./usage.js";
 import { assessStructureHealth, DEFAULT_HEALTH_THRESHOLDS, lintBody } from "./skill-health.js";
-import { CONTENT_SPLIT_HINT, DEFAULT_SKILL_VERSION_KEEP, SKILL_NAME_RE, SUPPORT_DIRS } from "./constants.js";
+import { CONTENT_SPLIT_HINT, DEFAULT_SKILL_VERSION_KEEP, PROTECTED_BUILTIN_SKILLS, SKILL_NAME_RE, SUPPORT_DIRS } from "./constants.js";
 /**
  * The CLASS boundary default authority (G1/1.1, Stage 2).
  *
@@ -949,6 +949,13 @@ export class SkillLibrary {
         }
         return null;
     }
+    /** Whether the target directory exists at all (a SKILL.md-less ghost still occupies the name). */
+    async skillDirExists(rawName) {
+        const name = rawName.trim();
+        if (this.badName(name) !== null)
+            return false;
+        return await this.io.exists(this.dirOf(name));
+    }
     async isManaged(rawName) {
         // One trim per entry: paths (dirOf), validation and messages all see the same name.
         const name = rawName.trim();
@@ -1477,7 +1484,7 @@ export class SkillLibrary {
         // marker never landed" inside the fsync/durability wrapper, producing a
         // self-contradicting operator-facing message.
         let markerWarning = '';
-        if (origin !== 'foreground') {
+        if (origin !== 'foreground' || options.managed === true) {
             // v29 SK-05: the marker write gets the same committed-only tolerance as
             // every other write in this file (A1-15) — a post-rename dir-fsync
             // failure means the MARKER landed; rejecting the create as a plain
@@ -1942,9 +1949,17 @@ export class SkillLibrary {
             if (bad)
                 return { ok: false, message: bad };
         }
+        if (PROTECTED_BUILTIN_SKILLS.has(target))
+            return { ok: false, message: `目标技能「${target}」是受保护的内置技能。` };
+        const protectedSource = sources.find(name => PROTECTED_BUILTIN_SKILLS.has(name));
+        if (protectedSource !== undefined)
+            return { ok: false, message: `来源技能「${protectedSource}」是受保护的内置技能。` };
         return await this.serial(async () => {
             const dir = this.dirOf(target);
             const targetPath = join(dir, 'SKILL.md');
+            if (!plan.targetExists && await this.io.exists(dir)) {
+                return { ok: false, message: `目标目录「${target}」已存在但不是技能；拒绝把 SKILL.md 写进同名目录。` };
+            }
             const currentTarget = await this.io.readText(targetPath);
             if (plan.targetExists !== (currentTarget !== null)) {
                 return { ok: false, message: plan.targetExists ? `目标技能「${target}」不存在。` : `目标技能「${target}」已存在。` };
@@ -1952,6 +1967,12 @@ export class SkillLibrary {
             if (currentTarget !== plan.expectedTargetBody) {
                 return { ok: false, message: `目标技能「${target}」在计划之后被改过；拒绝提交（未写入任何内容）。` };
             }
+            if (plan.targetExists && !(await this.isManaged(target))) {
+                return { ok: false, message: `目标技能「${target}」不是 family-managed；拒绝提交。` };
+            }
+            if (await this.io.exists(markerPath(dir, 'pinned'))) {
+                return { ok: false, message: `目标技能「${target}」已被固定；拒绝提交。` };
+            }
             const targetProtection = await this.writeProtection(target, plan.origin);
             if (targetProtection)
                 return { ok: false, message: `技能「${target}」受保护（${targetProtection}）。` };
@@ -2081,6 +2102,9 @@ export class SkillLibrary {
                         expected: supportPrevious.get(file.path) ?? null,
                     })),
                 ];
+                await plan.onPhase?.('target-pending');
+                if (plan.assertFence !== undefined && !(await plan.assertFence()))
+                    return { ok: false, message: 'tree fence lost before target write' };
                 const result = await this.applyTreeChange({
                     name: target,
                     origin: plan.origin,
@@ -2094,13 +2118,28 @@ export class SkillLibrary {
                 });
                 if (!result.ok)
                     return rollbackMessage(result.message, []);
+                await plan.onPhase?.('target-applied');
+                await plan.onPhase?.('target-written');
+                if (plan.signal?.aborted) {
+                    const stuck = await rollbackTarget();
+                    return rollbackMessage('cancelled before sources archived', stuck);
+                }
                 for (const source of sources) {
+                    if (plan.signal?.aborted) {
+                        const stuck = await rollbackSources();
+                        stuck.push(...await rollbackTarget());
+                        return rollbackMessage('cancelled before next source archive', stuck);
+                    }
                     const fresh = await this.io.readText(join(this.dirOf(source), 'SKILL.md'));
                     if (fresh !== sourceBodies.get(source)) {
                         const stuck = await rollbackSources();
                         stuck.push(...await rollbackTarget());
                         return rollbackMessage(`来源技能「${source}」在归档前被改过`, stuck);
                     }
+                    if (plan.assertFence !== undefined && !(await plan.assertFence())) {
+                        return { ok: false, message: 'tree fence lost before source archive; recovery required' };
+                    }
+                    await plan.onPhase?.('source-archiving', { source });
                     const archivedResult = await this.archive(source, {
                         absorbedInto: target,
                         unitId,
@@ -2114,12 +2153,30 @@ export class SkillLibrary {
                     }
                     archived.push(source);
                 }
+                await plan.onPhase?.('sources-archived');
+                await plan.onPhase?.('unit-written');
                 return { ok: true, message: `已把 ${sources.join(', ')} 合并进「${target}」。`, unitId, targetPath: dir, archived, mutations: 1 + sources.length };
             }
-            const created = await this.createCore(target, plan.body, plan.origin, { unitId, unitHead });
+            await plan.onPhase?.('target-pending');
+            if (plan.assertFence !== undefined && !(await plan.assertFence()))
+                return { ok: false, message: 'tree fence lost before target write' };
+            const created = await this.createCore(target, plan.body, plan.origin, { unitId, unitHead, managed: true });
             if (!created.ok)
                 return { ok: false, message: created.message };
+            await plan.onPhase?.('target-applied');
+            await plan.onPhase?.('target-written');
+            if (plan.signal?.aborted) {
+                const targetRollback = await this.archive(target, { reason: 'merge cancelled' }, plan.origin);
+                return rollbackMessage('cancelled before sources archived', targetRollback.ok ? [] : [target]);
+            }
             for (const source of sources) {
+                if (plan.signal?.aborted) {
+                    const stuck = await rollbackSources();
+                    const targetRollback = await this.archive(target, { reason: 'merge cancelled' }, plan.origin);
+                    if (!targetRollback.ok)
+                        stuck.push(target);
+                    return rollbackMessage('cancelled before next source archive', stuck);
+                }
                 const fresh = await this.io.readText(join(this.dirOf(source), 'SKILL.md'));
                 if (fresh !== sourceBodies.get(source)) {
                     const stuck = await rollbackSources();
@@ -2128,6 +2185,10 @@ export class SkillLibrary {
                         stuck.push(target);
                     return rollbackMessage(`来源技能「${source}」在归档前被改过`, stuck);
                 }
+                if (plan.assertFence !== undefined && !(await plan.assertFence())) {
+                    return { ok: false, message: 'tree fence lost before source archive; recovery required' };
+                }
+                await plan.onPhase?.('source-archiving', { source });
                 const result = await this.archive(source, {
                     absorbedInto: target,
                     unitId,
@@ -2144,6 +2205,10 @@ export class SkillLibrary {
                 archived.push(source);
             }
             if (plan.supportFiles.length > 0) {
+                await plan.onPhase?.('support-pending');
+                if (plan.assertFence !== undefined && !(await plan.assertFence())) {
+                    return { ok: false, message: 'tree fence lost before support write; recovery required' };
+                }
                 const writes = plan.supportFiles.map(file => ({
                     target: join(dir, ...file.path.replace(/\\/g, '/').split('/').filter(Boolean)),
                     content: file.content,
@@ -2168,6 +2233,8 @@ export class SkillLibrary {
                     return rollbackMessage(result.message, stuck);
                 }
             }
+            await plan.onPhase?.('sources-archived');
+            await plan.onPhase?.('unit-written');
             return { ok: true, message: `已把 ${sources.join(', ')} 合并进「${target}」。`, unitId, targetPath: dir, archived, mutations: 1 + sources.length };
         });
     }

package/lib/types/tree-lock.d.ts

@@ -1,14 +1,17 @@
 import type { EvolutionIoLike } from './io.ts';
 export interface TreeLockRecord {
     readonly token: string;
+    readonly epoch: number;
     readonly pid: number;
     readonly startedAt: number;
 }
 export interface TreeLock {
     readonly token: string;
+    readonly epoch: number;
     readonly path: string;
     readonly acquiredAt: number;
     release(): Promise<void>;
+    assertHeld(): Promise<boolean>;
 }
 export type TreeLockAcquireResult = {
     readonly ok: true;

package/lib/types/tree-lock.js

@@ -25,7 +25,7 @@ function parseLock(raw) {
         const value = JSON.parse(raw);
         if (typeof value.token !== 'string' || typeof value.pid !== 'number' || typeof value.startedAt !== 'number')
             return undefined;
-        return { token: value.token, pid: value.pid, startedAt: value.startedAt };
+        return { token: value.token, epoch: typeof value.epoch === 'number' ? value.epoch : 0, pid: value.pid, startedAt: value.startedAt };
     }
     catch {
         return undefined;
@@ -40,6 +40,7 @@ export async function readTreeLock(io, home) {
 async function tryAcquire(io, home, now) {
     const path = treeLockFile(home);
     let token;
+    let epoch;
     let holder;
     await transactIo(io, path, (current) => {
         const existing = parseLock(current);
@@ -47,11 +48,12 @@ async function tryAcquire(io, home, now) {
             holder = existing;
             return current;
         }
-        // Absent, corrupt, our own stale row, or a dead owner: take it.
+        // Absent, corrupt, our own stale row, or a dead owner: take it and bump the epoch.
         token = randomUUID();
-        return JSON.stringify({ token, pid: process.pid, startedAt: now() });
+        epoch = (existing?.epoch ?? 0) + 1;
+        return JSON.stringify({ token, epoch, pid: process.pid, startedAt: now() });
     });
-    return token === undefined ? (holder === undefined ? {} : { holder }) : { token };
+    return token === undefined ? (holder === undefined ? {} : { holder }) : { token, epoch: epoch ?? 0 };
 }
 /**
  * Acquire the tree write lock, waiting up to `waitMs`.
@@ -71,19 +73,25 @@ export async function acquireTreeWriteLock(options) {
             const attempt = await tryAcquire(options.io, options.home, now);
             if (attempt.token !== undefined) {
                 const token = attempt.token;
+                const epoch = attempt.epoch ?? 0;
                 const path = treeLockFile(options.home);
                 let released = false;
                 const lock = {
                     token,
+                    epoch,
                     path,
                     acquiredAt: now(),
+                    async assertHeld() {
+                        const current = parseLock(await options.io.readText(path));
+                        return current?.token === token && current.epoch === epoch;
+                    },
                     async release() {
                         if (released)
                             return;
                         released = true;
                         await transactIo(options.io, path, (current) => {
                             const existing = parseLock(current);
-                            return existing?.token === token ? null : current;
+                            return existing?.token === token && existing.epoch === epoch ? null : current;
                         });
                     },
                 };

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

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

package/lib/types/unit-backend.js

@@ -0,0 +1,49 @@
+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) {
+            const result = await skills.commitMerge({
+                target: plan.target,
+                targetExists: plan.targetExists,
+                sources: plan.sources,
+                body: plan.body,
+                supportFiles: plan.supportFiles,
+                expectedTargetBody: plan.expectedTargetBody,
+                expectedSourceBodies: plan.expectedSourceBodies,
+                origin: plan.origin,
+                summary: plan.summary,
+                ...(onPhase === undefined ? {} : { onPhase }),
+                ...(signal === undefined ? {} : { signal }),
+                ...(assertFence === undefined ? {} : { assertFence }),
+            });
+            return { ok: result.ok, message: result.message, ...(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=unit-backend.js.map

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

@@ -0,0 +1,29 @@
+import type { EvolutionIoLike } from './io.ts';
+export declare const UNIT_JOURNAL_SCHEMA_VERSION = 1;
+export declare const UNIT_JOURNAL_PHASES: readonly ["prepared", "target-pending", "target-written", "source-archiving", "sources-archived", "support-pending", "committed", "failed", "rolled-back"];
+export type UnitJournalPhase = typeof UNIT_JOURNAL_PHASES[number];
+export interface UnitJournalCheckpoint {
+    readonly source: string;
+    readonly phase: 'archived';
+    readonly hash: string;
+    readonly at: number;
+}
+export interface UnitJournal {
+    readonly schemaVersion: typeof UNIT_JOURNAL_SCHEMA_VERSION;
+    readonly unitId: string;
+    readonly runId: string;
+    readonly planDigest: string;
+    readonly target: string;
+    readonly sources: readonly string[];
+    readonly phase: UnitJournalPhase;
+    readonly storageKey: string;
+    readonly snapshotSha256: string;
+    readonly checkpoints?: readonly UnitJournalCheckpoint[];
+    readonly updatedAt: number;
+}
+export declare function unitJournalPath(home: string, unitId: string): string;
+export declare function unitJournalPhaseRank(phase: UnitJournalPhase): number;
+export declare function assertUnitJournalTransition(from: UnitJournalPhase, to: UnitJournalPhase): void;
+export declare function writeUnitJournal(io: EvolutionIoLike, home: string, journal: UnitJournal): Promise<string>;
+export declare function readUnitJournal(io: EvolutionIoLike, home: string, unitId: string): Promise<UnitJournal | null>;
+//# sourceMappingURL=unit-journal.d.ts.map

package/lib/types/unit-journal.js

@@ -0,0 +1,50 @@
+/** G2 unit journal: intent/phase/checkpoint only, never evidence bodies. */
+import { createHash } from 'node:crypto';
+import { join } from 'node:path';
+export const UNIT_JOURNAL_SCHEMA_VERSION = 1;
+export const UNIT_JOURNAL_PHASES = [
+    'prepared',
+    'target-pending',
+    'target-written',
+    'source-archiving',
+    'sources-archived',
+    'support-pending',
+    'committed',
+    'failed',
+    'rolled-back',
+];
+export function unitJournalPath(home, unitId) {
+    return join(home, 'merge', 'unit-journals', createHash('sha256').update(unitId).digest('hex') + '.json');
+}
+export function unitJournalPhaseRank(phase) {
+    return UNIT_JOURNAL_PHASES.indexOf(phase);
+}
+export function assertUnitJournalTransition(from, to) {
+    if (to === 'failed' || to === 'rolled-back')
+        return;
+    if (from === 'failed' || from === 'rolled-back' || from === 'committed')
+        throw new Error('unit-journal-terminal:' + from);
+    if (unitJournalPhaseRank(to) <= unitJournalPhaseRank(from))
+        throw new Error('unit-journal-nonmonotonic:' + from + '->' + to);
+}
+export async function writeUnitJournal(io, home, journal) {
+    const path = unitJournalPath(home, journal.unitId);
+    const content = JSON.stringify(journal, null, 2) + '\n';
+    if (io.transact !== undefined)
+        await io.transact(path, () => content);
+    else
+        await io.writeText(path, content);
+    return path;
+}
+export async function readUnitJournal(io, home, unitId) {
+    const raw = await io.readText(unitJournalPath(home, unitId));
+    if (raw === null)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=unit-journal.js.map

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

@@ -0,0 +1,5 @@
+/** G2 recovery arbitration: unit journal/evidence wins over a legacy commit journal. */
+import type { EvolutionIoLike } from './io.ts';
+export type UnitAuthority = 'unit' | 'legacy' | 'none';
+export declare function resolveUnitAuthority(io: EvolutionIoLike, home: string, unitId: string, legacyExists: boolean): Promise<UnitAuthority>;
+//# sourceMappingURL=unit-recovery.d.ts.map

package/lib/types/unit-recovery.js

@@ -0,0 +1,12 @@
+import { readUnitEvidence, readUnitSnapshot } from "./unit-storage.js";
+import { readUnitJournal } from "./unit-journal.js";
+export async function resolveUnitAuthority(io, home, unitId, legacyExists) {
+    if (await readUnitEvidence(io, home, unitId) !== null)
+        return 'unit';
+    if (await readUnitJournal(io, home, unitId) !== null)
+        return 'unit';
+    if (await readUnitSnapshot(io, home, unitId) !== null)
+        return 'unit';
+    return legacyExists ? 'legacy' : 'none';
+}
+//# sourceMappingURL=unit-recovery.js.map