@lmzhen/dsh-evolution-merge 0.30.17 → 0.30.19

package/lib/types/domain/authoring-manifest.js

@@ -0,0 +1,43 @@
+/**
+ * Parse `{"target":..., "files":[...]}` from a child's final turn text.
+ * @param text - the child's answer (JSON is expected; prose is tolerated).
+ * @returns the manifest, or null when the turn carried no well-formed envelope.
+ */
+export function parseAuthoringManifest(text) {
+    try {
+        const value = JSON.parse(text);
+        if (!Array.isArray(value.files) || value.files.some(file => typeof file !== 'string'))
+            return null;
+        if (value.target !== undefined && typeof value.target !== 'string')
+            return null;
+        return { ...(typeof value.target === 'string' ? { target: value.target } : {}), files: value.files };
+    }
+    catch {
+        return null;
+    }
+}
+/** Files a manifest promises for a staged tree (declared list, or the tree when undeclared). */
+export function manifestFilesOf(manifest, stagedPaths) {
+    if (manifest !== null)
+        return manifest.files;
+    return ['SKILL.md', ...stagedPaths];
+}
+/**
+ * The first file the manifest promises but the staged tree does not contain.
+ * SKILL.md itself is always required, whether or not the manifest lists it.
+ * @param files - manifest files (see {@link manifestFilesOf}).
+ * @param stagedPaths - support-file paths actually present in the staged tree.
+ * @returns the missing path, or null when the declaration is satisfied.
+ */
+export function missingManifestFile(files, stagedPaths) {
+    if (!files.includes('SKILL.md'))
+        return 'SKILL.md';
+    for (const path of files) {
+        if (path === 'SKILL.md')
+            continue;
+        if (!stagedPaths.includes(path))
+            return path;
+    }
+    return null;
+}
+//# sourceMappingURL=authoring-manifest.js.map

package/lib/types/domain/claim.d.ts

@@ -3,8 +3,11 @@ export interface Claim {
     readonly id: string;
     readonly token: string;
     readonly expiresAt: number;
+    readonly pid?: number;
+    /** Process start time; detects pid reuse when the same pid hosts a newer process. */
+    readonly startedAt?: number;
 }
-export declare function acquireClaim(current: Claim | undefined, now: number, leaseMs: number, token: string): Claim | undefined;
+export declare function acquireClaim(current: Claim | undefined, now: number, leaseMs: number, token: string, pid?: number, startedAt?: number): Claim | undefined;
 export declare function releaseClaim(current: Claim | undefined, token: string): Claim | undefined;
 export declare function isClaimExpired(current: Claim | undefined, now: number): boolean;
 //# sourceMappingURL=claim.d.ts.map

package/lib/types/domain/claim.js

@@ -1,7 +1,7 @@
-export function acquireClaim(current, now, leaseMs, token) {
+export function acquireClaim(current, now, leaseMs, token, pid, startedAt) {
     if (current !== undefined && current.expiresAt > now)
         return undefined;
-    return { id: 'claim', token, expiresAt: now + Math.max(1, leaseMs) };
+    return { id: 'claim', token, expiresAt: now + Math.max(1, leaseMs), ...(pid === undefined ? {} : { pid }), ...(startedAt === undefined ? {} : { startedAt }) };
 }
 export function releaseClaim(current, token) {
     return current?.token === token ? undefined : current;

package/lib/types/domain/commit-journal-store.js

@@ -5,7 +5,11 @@ export function journalPath(home, runId) {
 }
 export async function writeJournal(io, home, journal) {
     const path = journalPath(home, journal.runId);
-    await io.writeText(path, JSON.stringify(journal, null, 2));
+    const content = JSON.stringify(journal, null, 2);
+    if (io.transact !== undefined)
+        await io.transact(path, () => content);
+    else
+        await io.writeText(path, content);
     return path;
 }
 export async function readJournal(io, home, runId) {

package/lib/types/domain/commit-journal.js

@@ -1,5 +1,5 @@
 const NEXT = {
-    prepared: ['target-written', 'failed'],
+    prepared: ['committed', 'target-written', 'failed'],
     'target-written': ['sources-archived', 'rolled-back', 'failed'],
     'sources-archived': ['committed', 'rolled-back', 'failed'],
     committed: [],

package/lib/types/domain/consistency.d.ts

@@ -0,0 +1,22 @@
+/** RG0 cross-artifact consistency. Pure; no IO. */
+export type RowState = 'verify' | 'pending' | 'approved' | 'fuse' | 'skipped' | 'merged';
+export type RunState = 'none' | 'awaiting-approval' | 'running' | 'succeeded' | 'failed' | 'cancelled' | 'orphan';
+export type StagingState = 'none' | 'cleaned' | 'kept' | 'missing';
+export type JournalState = 'none' | 'committing' | 'prepared' | 'committed' | 'rolled-back' | 'failed';
+export type EvidenceState = 'none' | 'receipt';
+export interface ArtifactState {
+    readonly row: RowState;
+    readonly run: RunState;
+    readonly staging: StagingState;
+    readonly journal: JournalState;
+    readonly evidence: EvidenceState;
+    readonly activeRuns: number;
+    readonly hasOwner?: boolean;
+    readonly recovery?: boolean;
+}
+export interface ConsistencyResult {
+    readonly ok: boolean;
+    readonly reason?: string;
+}
+export declare function validateArtifacts(state: ArtifactState): ConsistencyResult;
+//# sourceMappingURL=consistency.d.ts.map

package/lib/types/domain/consistency.js

@@ -0,0 +1,50 @@
+const ALLOWED = [
+    { row: 'verify', run: 'none', staging: 'none', journal: 'none', evidence: 'none', activeRuns: 0 },
+    { row: 'verify', run: 'running', staging: 'none', journal: 'none', evidence: 'none', activeRuns: 1 },
+    { row: 'verify', run: 'failed', staging: 'none', journal: 'none', evidence: 'none', activeRuns: 0 },
+    { row: 'pending', run: 'none', staging: 'none', journal: 'none', evidence: 'none', activeRuns: 0 },
+    { row: 'pending', run: 'awaiting-approval', staging: 'none', journal: 'none', evidence: 'none', activeRuns: 1 },
+    { row: 'approved', run: 'none', staging: 'none', journal: 'none', evidence: 'none', activeRuns: 0 },
+    { row: 'approved', run: 'running', staging: 'none', journal: 'none', evidence: 'none', activeRuns: 1 },
+    { row: 'fuse', run: 'none', staging: 'kept', journal: 'none', evidence: 'none', activeRuns: 0 },
+    { row: 'fuse', run: 'running', staging: 'kept', journal: 'none', evidence: 'none', activeRuns: 1 },
+    { row: 'fuse', run: 'failed', staging: 'kept', journal: 'none', evidence: 'none', activeRuns: 0 },
+    { row: 'fuse', run: 'orphan', staging: 'kept', journal: 'none', evidence: 'none', activeRuns: 0 },
+    { row: 'fuse', run: 'none', staging: 'none', journal: 'none', evidence: 'none', activeRuns: 0, recovery: true },
+    { row: 'fuse', run: 'failed', staging: 'none', journal: 'none', evidence: 'none', activeRuns: 0, recovery: true },
+    { row: 'fuse', run: 'orphan', staging: 'none', journal: 'none', evidence: 'none', activeRuns: 0, recovery: true },
+    { row: 'fuse', run: 'running', staging: 'none', journal: 'none', evidence: 'none', activeRuns: 1, recovery: true },
+    { row: 'fuse', run: 'none', staging: 'missing', journal: 'none', evidence: 'none', activeRuns: 0, recovery: true },
+    { row: 'fuse', run: 'failed', staging: 'missing', journal: 'none', evidence: 'none', activeRuns: 0, recovery: true },
+    { row: 'fuse', run: 'orphan', staging: 'missing', journal: 'none', evidence: 'none', activeRuns: 0, recovery: true },
+    { row: 'fuse', run: 'running', staging: 'missing', journal: 'none', evidence: 'none', activeRuns: 1, recovery: true },
+    { row: 'fuse', run: 'running', staging: 'kept', journal: 'committing', evidence: 'none', activeRuns: 1 },
+    { row: 'skipped', run: 'none', staging: 'none', journal: 'none', evidence: 'none', activeRuns: 0 },
+    { row: 'merged', run: 'succeeded', staging: 'cleaned', journal: 'committed', evidence: 'receipt', activeRuns: 0 },
+    { row: 'merged', run: 'succeeded', staging: 'kept', journal: 'committed', evidence: 'receipt', activeRuns: 0 },
+];
+function same(a, b) {
+    return a.row === b.row && a.run === b.run && a.staging === b.staging && a.journal === b.journal
+        && a.evidence === b.evidence && a.activeRuns === b.activeRuns
+        && (b.recovery ?? false) === (a.recovery ?? false);
+}
+export function validateArtifacts(state) {
+    if (state.activeRuns > 1)
+        return { ok: false, reason: 'multiple-active-runs' };
+    if (state.activeRuns > 0 && state.hasOwner === false)
+        return { ok: false, reason: 'active-run-no-owner' };
+    if (ALLOWED.some(item => same(state, item)))
+        return { ok: true };
+    if (state.row === 'pending' && state.staging !== 'none')
+        return { ok: false, reason: 'pending-staging' };
+    if (state.row === 'skipped' && state.run === 'running')
+        return { ok: false, reason: 'skipped-running' };
+    if (state.row === 'fuse' && state.staging === 'missing' && state.recovery !== true)
+        return { ok: false, reason: 'fuse-lost-staging' };
+    if (state.journal === 'committed' && state.evidence !== 'receipt')
+        return { ok: false, reason: 'committed-no-evidence' };
+    if (state.row === 'merged' && state.journal === 'rolled-back')
+        return { ok: false, reason: 'committed-rollback' };
+    return { ok: false, reason: 'not-allowed' };
+}
+//# sourceMappingURL=consistency.js.map

package/lib/types/domain/engine-criteria.d.ts

@@ -0,0 +1,10 @@
+/** Batch 3 engine criteria projection: merge maps level/verdict/action, engine does not. */
+export interface EngineCriteria {
+    readonly decision: 'keep' | 'merge' | 'candidate';
+    readonly validation: 'not-run' | 'report-only' | 'required';
+    readonly commit: 'never' | 'if-approved' | 'required';
+    readonly archive: 'none' | 'sources';
+    readonly evidence: 'none' | 'receipt';
+}
+export declare function criteriaFrom(level: 'L0' | 'L1' | 'L2', verdict: 1 | 0 | -1, action: 'keep' | 'merge'): EngineCriteria;
+//# sourceMappingURL=engine-criteria.d.ts.map

package/lib/types/domain/engine-criteria.js

@@ -0,0 +1,11 @@
+export function criteriaFrom(level, verdict, action) {
+    const candidate = level === 'L2' && verdict !== -1;
+    return {
+        decision: action === 'keep' ? 'keep' : candidate ? 'merge' : 'candidate',
+        validation: level === 'L2' ? 'required' : 'report-only',
+        commit: candidate && action === 'merge' ? 'required' : 'never',
+        archive: candidate && action === 'merge' ? 'sources' : 'none',
+        evidence: candidate && action === 'merge' ? 'receipt' : 'none',
+    };
+}
+//# sourceMappingURL=engine-criteria.js.map

package/lib/types/domain/engine-input.d.ts

@@ -0,0 +1,10 @@
+/** OI-11 engine input allowlist: exactly modelsRoot/reportOnly/maxTokens/timeoutMs. */
+export interface EngineInput {
+    readonly modelsRoot: string;
+    readonly reportOnly: boolean;
+    readonly maxTokens: number;
+    readonly timeoutMs: number;
+}
+export declare const ENGINE_FORBIDDEN_KEYS: readonly ["offline", "auto_provision", "embed_backend", "rank_mode", "models_dir", "embedder_model", "embedder_model_last", "judge"];
+export declare function resolveEngineInput(input?: unknown): EngineInput;
+//# sourceMappingURL=engine-input.d.ts.map

package/lib/types/domain/engine-input.js

@@ -0,0 +1,26 @@
+const ALLOWED = new Set(['modelsRoot', 'reportOnly', 'maxTokens', 'timeoutMs']);
+export const ENGINE_FORBIDDEN_KEYS = ['offline', 'auto_provision', 'embed_backend', 'rank_mode', 'models_dir', 'embedder_model', 'embedder_model_last', 'judge'];
+function integer(name, value, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < 0)
+        throw new Error(name + ' must be a non-negative integer');
+    return value;
+}
+export function resolveEngineInput(input = {}) {
+    if (typeof input !== 'object' || input === null || Array.isArray(input))
+        throw new Error('engine input must be an object');
+    for (const key of Object.keys(input)) {
+        if (ENGINE_FORBIDDEN_KEYS.includes(key))
+            throw new Error('engine input key is forbidden: ' + key);
+        if (!ALLOWED.has(key))
+            throw new Error('unknown engine input: ' + key);
+    }
+    const record = input;
+    if (record.modelsRoot !== undefined && typeof record.modelsRoot !== 'string')
+        throw new Error('modelsRoot must be a string');
+    if (record.reportOnly !== undefined && typeof record.reportOnly !== 'boolean')
+        throw new Error('reportOnly must be a boolean');
+    return { modelsRoot: typeof record.modelsRoot === 'string' ? record.modelsRoot : '', reportOnly: record.reportOnly === true, maxTokens: integer('maxTokens', record.maxTokens, 0), timeoutMs: integer('timeoutMs', record.timeoutMs, 0) };
+}
+//# sourceMappingURL=engine-input.js.map

package/lib/types/domain/errors.d.ts

@@ -1,12 +1,26 @@
-/** Pure merge error rendering: parameter errors are two lines, runtime/target failures three. */
+/** Pure merge error rendering: parameter errors stay one line; command failures are code/hint/next. */
 export type MergeErrorKind = 'parameter' | 'runtime' | 'target' | 'approval';
 export interface MergeError {
     readonly kind: MergeErrorKind;
     readonly code: string;
     readonly message: string;
+    /** Reader-facing explanation; defaults to the message (plus detail). */
+    readonly hint?: string;
+    /** The one next step; every runtime failure names one. */
+    readonly next?: string;
     readonly detail?: string;
     readonly stage?: string;
     readonly runId?: string;
 }
+/** Build the typed failure every command/CLI/runtime branch returns. */
+export declare function commandError(stage: string, code: string, hint: string, next: string, runId?: string): MergeError;
+/** Render a merge command failure: one line for syntax, three lines (code/hint/next) for runtime. */
 export declare function formatMergeError(error: MergeError): string;
+/** A typed failure result: `message` is the rendered three-line text, `error` keeps the fields. */
+export interface FailureResult {
+    readonly ok: false;
+    readonly message: string;
+    readonly error: MergeError;
+}
+export declare function failure(stage: string, code: string, hint: string, next: string, runId?: string): FailureResult;
 //# sourceMappingURL=errors.d.ts.map

package/lib/types/domain/errors.js

@@ -4,12 +4,31 @@ function redact(text) {
         .replace(/Bearer\s+\S+/gi, 'Bearer [redacted]')
         .replace(/(api[_-]?key\s*[:=]\s*)\S+/gi, '$1[redacted]');
 }
+/** Build the typed failure every command/CLI/runtime branch returns. */
+export function commandError(stage, code, hint, next, runId) {
+    return { kind: 'runtime', code, message: hint, hint, next, stage, ...(runId === undefined ? {} : { runId }) };
+}
+function oneLine(value) {
+    return value.replace(/\r?\n+/g, ' ').trim();
+}
+function render(error) {
+    const where = [
+        error.stage === undefined ? undefined : 'stage=' + error.stage,
+        error.runId === undefined ? undefined : 'run=' + error.runId,
+    ].filter((value) => value !== undefined).join(', ');
+    const heading = 'code: ' + error.code + (where === '' ? '' : ' (' + where + ')');
+    const hint = 'hint: ' + oneLine(error.hint ?? [error.message, error.detail].filter((value) => value !== undefined && value !== '').join(' — '));
+    const next = 'next: ' + oneLine(error.next ?? error.detail ?? 'fix the target or rerun after the cause is gone');
+    return redact([heading, hint, next].join('\n'));
+}
+/** Render a merge command failure: one line for syntax, three lines (code/hint/next) for runtime. */
 export function formatMergeError(error) {
     if (error.kind === 'parameter')
         return 'merge: ' + error.message + ' (' + error.code + ')';
-    const where = error.stage === undefined && error.runId === undefined
-        ? (error.detail ?? 'no additional detail')
-        : [error.stage === undefined ? undefined : 'stage=' + error.stage, error.runId === undefined ? undefined : 'run=' + error.runId].filter(Boolean).join(' ');
-    return redact('merge failed: ' + error.message + ' (' + error.code + ')\n' + where + '\nnext: fix the target or rerun after the cause is gone');
+    return render(error);
+}
+export function failure(stage, code, hint, next, runId) {
+    const error = commandError(stage, code, hint, next, runId);
+    return { ok: false, message: formatMergeError(error), error };
 }
 //# sourceMappingURL=errors.js.map

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

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

package/lib/types/domain/evidence-hash.js

@@ -0,0 +1,14 @@
+/** Canonical evidence JSON hash shared with core unit receipts. */
+import { createHash } from 'node:crypto';
+function canonical(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return '[' + value.map(canonical).join(',') + ']';
+    const object = value;
+    return '{' + Object.keys(object).sort().map(key => JSON.stringify(key) + ':' + canonical(object[key])).join(',') + '}';
+}
+export function evidenceSha256(evidence) {
+    return createHash('sha256').update(canonical({ ...evidence, at: 0, mutations: 0 })).digest('hex');
+}
+//# sourceMappingURL=evidence-hash.js.map

package/lib/types/domain/failure-route.d.ts

@@ -20,6 +20,20 @@ export type MergeFailureRoute = {
 } | {
     readonly kind: 'runtime';
     readonly reportOnly: true;
+} | {
+    readonly kind: 'over-limit';
+    readonly reportOnly: true;
+    readonly reason: 'merge-over-limit';
+    readonly lengths: Readonly<Record<string, number>>;
 };
+export declare function routeLimitFailure(lengths: Readonly<Record<string, number>>): MergeFailureRoute;
 export declare function routeFailure(code: string): MergeFailureRoute;
+/** Batch 2 typed CAS hook; Batch 3 owns full targetRevision expiry. */
+export type CasFailureCode = 'target-changed' | 'target-taken' | 'source-changed' | 'support-changed';
+export interface CasHookResult {
+    readonly kind: 'expired';
+    readonly reason: Exclude<CasFailureCode, 'target-changed' | 'support-changed'>;
+    readonly write: false;
+}
+export declare function casExpiredHook(code: string): CasHookResult | null;
 //# sourceMappingURL=failure-route.d.ts.map

package/lib/types/domain/failure-route.js

@@ -4,7 +4,12 @@ const TARGET_TAKEN = new Set(['target-taken', 'target-exists']);
 const VALIDATION = new Set(['validation-failed', 'invalid-decision']);
 const COMMIT = new Set(['commit-failed', 'commit-refused']);
 const SCHEMA = new Set(['schema-invalid', 'schema-version']);
+export function routeLimitFailure(lengths) {
+    return { kind: 'over-limit', reportOnly: true, reason: 'merge-over-limit', lengths };
+}
 export function routeFailure(code) {
+    if (code === 'merge-over-limit')
+        return routeLimitFailure({});
     if (PARAMETER.has(code))
         return { kind: 'parameter', reportOnly: false };
     if (SOURCE_GONE.has(code))
@@ -19,4 +24,11 @@ export function routeFailure(code) {
         return { kind: 'schema', reportOnly: true };
     return { kind: 'runtime', reportOnly: true };
 }
+export function casExpiredHook(code) {
+    if (code === 'target-changed' || code === 'target-taken')
+        return { kind: 'expired', reason: 'target-taken', write: false };
+    if (code === 'source-changed' || code === 'support-changed')
+        return { kind: 'expired', reason: 'source-changed', write: false };
+    return null;
+}
 //# sourceMappingURL=failure-route.js.map

package/lib/types/domain/ledger.js

@@ -1,5 +1,7 @@
 /** Pure v2 ledger normalization/projection. No IO. */
 import { migrateV1Row } from "./migrate-v1.js";
+import { isV3Row } from "./row-v3.js";
+import { v3ToLegacy } from "./row-v3-bridge.js";
 import { queueOf } from "./state.js";
 function isRow(value) {
     const row = value;
@@ -17,11 +19,18 @@ export function parseLedger(raw) {
         return { ok: false, ledger: { schemaVersion: 2, rows: [] }, note: 'invalid json' };
     }
     const body = parsed;
-    if (typeof body.schemaVersion === 'number' && body.schemaVersion > 2) {
+    if (typeof body.schemaVersion === 'number' && body.schemaVersion > 3) {
         return { ok: false, ledger: { schemaVersion: 2, rows: [] }, note: 'merge-state-forward-only' };
     }
     if (!Array.isArray(body.rows))
         return { ok: false, ledger: { schemaVersion: 2, rows: [] }, note: 'rows missing' };
+    if (body.schemaVersion === 3) {
+        if (!body.rows.every(isV3Row)) {
+            const v3Like = body.rows.some(row => row !== null && typeof row === 'object' && 'pairKey' in row && 'version' in row);
+            return { ok: false, ledger: { schemaVersion: 2, rows: [] }, note: v3Like ? 'merge-state-needs-repair' : 'merge-state-forward-only' };
+        }
+        return { ok: true, ledger: { schemaVersion: 2, rows: body.rows.map(v3ToLegacy) } };
+    }
     const rows = [];
     let skipped = 0;
     for (const value of body.rows) {

package/lib/types/domain/live-facts.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Read-time convergence facts for pending rows (FR-LIFE-14).
+ *
+ * Snapshot and reconcile must agree on WHY a pending row is no longer actionable, but no
+ * reader may write. This module is the single derivation both sides call: given the live
+ * library view it answers absent/source-gone/target-taken/source-changed, and the
+ * persisted row state is only consulted for an already-recorded expiry.
+ */
+import type { RevisionRef } from '../contracts.ts';
+import type { SkillCard } from '../skill-card.ts';
+import type { V4Row } from './row-v4.ts';
+/** Why a pending row reads as expired. `source-gone` rows are removed by reconcile. */
+export type PendingExpiryKind = 'target-taken' | 'source-changed' | 'source-gone';
+/** The live library facts the derivation needs; no io, no writes. */
+export interface LiveRowFacts {
+    readonly managed: (name: string) => boolean;
+    readonly targetRevisionRef: (name: string) => RevisionRef;
+    readonly sourceRevisionRef: (a: string, b: string) => RevisionRef;
+    readonly supportDigest: (names: readonly string[]) => string;
+}
+export declare function liveRowFactsOf(cards: readonly SkillCard[]): LiveRowFacts;
+/**
+ * The read-only expiry verdict for one row.
+ * @param row - the persisted row (only pending rows converge here).
+ * @param live - current library facts; absent means "cannot derive".
+ * @returns the expiry kind, or null when the row is still actionable.
+ */
+export declare function pendingExpiry(row: V4Row, live: LiveRowFacts | undefined): PendingExpiryKind | null;
+/** The persisted expiry kind, when the row already carries one. */
+export declare function persistedExpiry(row: V4Row): PendingExpiryKind | null;
+//# sourceMappingURL=live-facts.d.ts.map

package/lib/types/domain/live-facts.js

@@ -0,0 +1,54 @@
+import { revisionMismatch, sourceRevisionRefOf, supportDigestOf, targetRevisionRefOf } from "../revision.js";
+export function liveRowFactsOf(cards) {
+    const byName = new Map(cards.map(card => [card.name, card]));
+    return {
+        managed: name => byName.get(name)?.managed === true,
+        targetRevisionRef: name => targetRevisionRefOf(cards, name),
+        sourceRevisionRef: (a, b) => sourceRevisionRefOf(cards, a, b),
+        supportDigest: names => supportDigestOf(cards, names),
+    };
+}
+/**
+ * The read-only expiry verdict for one row.
+ * @param row - the persisted row (only pending rows converge here).
+ * @param live - current library facts; absent means "cannot derive".
+ * @returns the expiry kind, or null when the row is still actionable.
+ */
+export function pendingExpiry(row, live) {
+    if (live === undefined)
+        return null;
+    if (row.state === 'verify') {
+        return !live.managed(row.a) || !live.managed(row.b) ? 'source-gone' : null;
+    }
+    if (row.state !== 'pending' && row.state !== 'fuse' && row.state !== 'approved')
+        return null;
+    if (!live.managed(row.a) || !live.managed(row.b))
+        return 'source-gone';
+    const decision = row.decision;
+    if (row.state !== 'pending') {
+        if (revisionMismatch(decision.sourceRevisionRef, live.sourceRevisionRef(row.a, row.b)) !== null)
+            return 'source-changed';
+        if (decision.supportDigest !== undefined && decision.supportDigest !== live.supportDigest([decision.target, row.a, row.b]))
+            return 'source-changed';
+        return null;
+    }
+    if (decision.mode !== 'create-umbrella') {
+        if (!live.managed(decision.target))
+            return 'target-taken';
+    }
+    // A create-umbrella decision recorded "this name was free"; the name being taken now is
+    // the same conflict the approve precheck reports.
+    if (revisionMismatch(decision.targetRevisionRef, live.targetRevisionRef(decision.target)) !== null)
+        return 'target-taken';
+    const expectedSource = decision.sourceRevisionRef;
+    if (revisionMismatch(expectedSource, live.sourceRevisionRef(row.a, row.b)) !== null)
+        return 'source-changed';
+    if (decision.supportDigest !== undefined && decision.supportDigest !== live.supportDigest([decision.target, row.a, row.b]))
+        return 'source-changed';
+    return null;
+}
+/** The persisted expiry kind, when the row already carries one. */
+export function persistedExpiry(row) {
+    return row.state === 'pending' && row.expired !== undefined ? row.expired : null;
+}
+//# sourceMappingURL=live-facts.js.map

package/lib/types/domain/merge-limits.d.ts

@@ -0,0 +1,18 @@
+import { policyStageLimits, type SkillLimits } from '@lmzhen/dsh-evolution-core';
+export interface MergeLimitsSnapshot {
+    readonly skillLimits: SkillLimits;
+    readonly limitsDigest: string;
+}
+export declare function resolveLimitsSnapshot(policy?: Parameters<typeof policyStageLimits>[0]): MergeLimitsSnapshot;
+export declare function limitsSnapshotOf(skillLimits: SkillLimits): MergeLimitsSnapshot;
+export declare function mergeLimitFinding(path: string, limit: string, observed: number, limitValue: number): {
+    readonly rule: string;
+    readonly path: string;
+    readonly severity: 'block';
+    readonly code: 'limit';
+    readonly limit: string;
+    readonly observed: number;
+    readonly limitValue: number;
+    readonly message: string;
+};
+//# sourceMappingURL=merge-limits.d.ts.map

package/lib/types/domain/merge-limits.js

@@ -0,0 +1,22 @@
+/** One limits snapshot shared by authoring, validation and commit. */
+import { createHash } from 'node:crypto';
+import { DEFAULT_SKILL_LIMITS, policyStageLimits } from '@lmzhen/dsh-evolution-core';
+function canonical(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return '[' + value.map(canonical).join(',') + ']';
+    const object = value;
+    return '{' + Object.keys(object).sort().map(key => JSON.stringify(key) + ':' + canonical(object[key])).join(',') + '}';
+}
+export function resolveLimitsSnapshot(policy) {
+    const skillLimits = { ...DEFAULT_SKILL_LIMITS, ...policyStageLimits(policy) };
+    return { skillLimits, limitsDigest: createHash('sha256').update(canonical(skillLimits)).digest('hex') };
+}
+export function limitsSnapshotOf(skillLimits) {
+    return { skillLimits, limitsDigest: createHash('sha256').update(canonical(skillLimits)).digest('hex') };
+}
+export function mergeLimitFinding(path, limit, observed, limitValue) {
+    return { rule: 'limit', path, severity: 'block', code: 'limit', limit, observed, limitValue, message: path + ' exceeds ' + limit + ' (' + String(observed) + ' > ' + String(limitValue) + ')' };
+}
+//# sourceMappingURL=merge-limits.js.map

package/lib/types/domain/merge-report.d.ts

@@ -0,0 +1,41 @@
+/** 1b-1 additive report schema; values are filled by later batches. */
+export interface MergeReportLimits {
+    readonly maxSkillFileBytes?: number;
+    readonly maxTokenBytes?: number;
+    readonly pairTimeoutMinutes?: number;
+}
+export interface MergeReportValidation {
+    readonly ok: boolean;
+    readonly errors: readonly string[];
+}
+export interface MergeReport {
+    readonly schemaVersion: 2;
+    readonly reportId: string;
+    readonly runId: string;
+    readonly pairKey: string;
+    readonly target: string;
+    readonly sourceRevisions?: Readonly<Record<string, string>>;
+    readonly targetRevision?: string;
+    readonly validation: MergeReportValidation;
+    readonly limits: MergeReportLimits;
+    readonly q09?: {
+        readonly forwardRefs: readonly string[];
+        readonly reverseRefs: readonly string[];
+        readonly orphanFiles: readonly string[];
+    };
+    readonly threat?: {
+        readonly body: string;
+        readonly source: string;
+    };
+    readonly createdAt: string;
+}
+export interface MergeReportRef {
+    readonly path: string;
+    readonly digest: string;
+    readonly writtenAt: string;
+}
+export interface MergeReportWriter {
+    write(report: MergeReport): Promise<MergeReportRef>;
+    read(runId: string): Promise<MergeReport | null>;
+}
+//# sourceMappingURL=merge-report.d.ts.map

package/lib/types/domain/merge-report.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=merge-report.js.map