@lmzhen/dsh-evolution-merge 0.28.0 → 0.30.0

package/lib/types/state.js

@@ -0,0 +1,103 @@
+/**
+ * The one merge-state ledger: <home>/merge/merge-state.json.
+ *
+ * Reads are pure projections (no write, no reconciliation side effect). Every write goes
+ * through mutateMergeState and a single transactIo, so there is no second file and no
+ * incremental writer. A row's queue is always derived from its state on read; a hand-edited
+ * mismatch is repaired by the next write, never by a GET.
+ */
+import { join } from 'node:path';
+import { transactIo } from '@lmzhen/dsh-evolution-core';
+import { MERGE_STATE_VERSION, queueOf, } from "./contracts.js";
+import { parseLedger } from "./domain/ledger.js";
+export function mergeStatePath(home) {
+    return join(home, 'merge', 'merge-state.json');
+}
+function parseState(raw) {
+    const parsed = parseLedger(raw);
+    if (!parsed.ok)
+        return { ok: false, rows: [] };
+    return {
+        ok: true,
+        rows: parsed.ledger.rows,
+        ...(parsed.note === undefined ? {} : { note: parsed.note }),
+    };
+}
+/** Pure read: never writes, never deletes a row. */
+export async function loadMergeState(io, home) {
+    let raw = null;
+    try {
+        raw = await io.readText(mergeStatePath(home));
+    }
+    catch {
+        return { ok: false, state: { schemaVersion: MERGE_STATE_VERSION, rows: [] } };
+    }
+    const parsed = parseState(raw);
+    return {
+        ok: parsed.ok,
+        state: { schemaVersion: MERGE_STATE_VERSION, rows: parsed.rows },
+        ...(parsed.note === undefined ? {} : { note: parsed.note }),
+    };
+}
+/** The ONE write point. The callback returns the whole row set, not a delta. */
+export async function mutateMergeState(io, home, now, fn) {
+    let result;
+    let ran = false;
+    await transactIo(io, mergeStatePath(home), (current) => {
+        ran = true;
+        const parsed = parseState(current);
+        const out = fn(parsed.rows);
+        result = out.result;
+        return JSON.stringify({ schemaVersion: MERGE_STATE_VERSION, rows: out.rows }, null, 2);
+    });
+    // transactIo only returns after fn ran; a skipped write is not a state outcome.
+    void ran;
+    void now;
+    return result;
+}
+export async function upsertRow(io, home, now, row) {
+    await mutateMergeState(io, home, now, (rows) => {
+        const index = rows.findIndex(item => item.pairKey === row.pairKey);
+        const normalized = { ...row, queue: queueOf(row.state) };
+        const next = [...rows];
+        if (index < 0)
+            next.push(normalized);
+        else
+            next[index] = { ...normalized, createdAt: rows[index]?.createdAt ?? normalized.createdAt };
+        return { rows: next, result: undefined };
+    });
+}
+export async function moveRow(io, home, now, id, patch) {
+    return await mutateMergeState(io, home, now, (rows) => {
+        const index = rows.findIndex(item => item.id === id);
+        if (index < 0)
+            return { rows, result: undefined };
+        const current = rows[index];
+        const state = patch.state ?? current.state;
+        const next = {
+            ...current,
+            state,
+            queue: queueOf(state),
+            updatedAt: new Date(now()).toISOString(),
+            ...(patch.failure === undefined ? {} : { failure: patch.failure }),
+            ...(patch.runId === undefined ? {} : { runId: patch.runId }),
+            ...(patch.unitId === undefined ? {} : { unitId: patch.unitId }),
+            ...(patch.origin === undefined ? {} : { origin: patch.origin }),
+            ...(patch.attempts === undefined ? {} : { attempts: patch.attempts }),
+        };
+        const copy = [...rows];
+        copy[index] = next;
+        return { rows: copy, result: next };
+    });
+}
+export async function dropRow(io, home, now, id) {
+    return await mutateMergeState(io, home, now, (rows) => {
+        const next = rows.filter(item => item.id !== id);
+        return { rows: next, result: next.length !== rows.length };
+    });
+}
+export async function rowsOf(io, home, queue) {
+    const loaded = await loadMergeState(io, home);
+    return queue === undefined ? loaded.state.rows : loaded.state.rows.filter(row => row.queue === queue);
+}
+//# sourceMappingURL=state.js.map

package/lib/types/status.d.ts

@@ -4,8 +4,9 @@
  */
 import type { MergeQueue, MergeRow } from './contracts.ts';
 export interface MergeCounts {
+    readonly verify: number;
     readonly pending: number;
-    readonly retry: number;
+    readonly fuse: number;
     readonly skipped: number;
 }
 export declare function countRows(rows: readonly MergeRow[]): MergeCounts;

package/lib/types/status.js

@@ -0,0 +1,28 @@
+import { queueOf, stageOf } from "./contracts.js";
+export function countRows(rows) {
+    const counts = { verify: 0, pending: 0, fuse: 0, skipped: 0 };
+    for (const row of rows)
+        counts[queueOf(row.state)] += 1;
+    return counts;
+}
+function describe(row) {
+    const stage = stageOf(row.state);
+    const target = row.decision?.shouldMerge === true ? ' → ' + row.decision.target : '';
+    return row.a + ' + ' + row.b + ' [' + row.state + (stage === null ? '' : '/' + stage) + ']' + target + (row.failure === undefined ? '' : ' — ' + row.failure.message);
+}
+export function formatStatus(rows) {
+    const counts = countRows(rows);
+    const lines = [
+        'merge: verify ' + String(counts.verify) + ', pending ' + String(counts.pending) + ', fuse ' + String(counts.fuse) + ', skipped ' + String(counts.skipped),
+    ];
+    for (const row of rows)
+        lines.push('- ' + describe(row));
+    return lines.join('\n');
+}
+export function formatQueue(rows, queue) {
+    const selected = rows.filter(row => queueOf(row.state) === queue);
+    if (selected.length === 0)
+        return 'merge ' + queue + ': empty';
+    return ['merge ' + queue + ': ' + String(selected.length)].concat(selected.map(row => '- ' + describe(row))).join('\n');
+}
+//# sourceMappingURL=status.js.map

package/lib/types/supersede.js

@@ -0,0 +1,14 @@
+export function mergeRunIdsToSupersede(runs) {
+    return runs.filter(run => run.kind === 'merge' && run.supersededAt === undefined).map(run => run.id);
+}
+export async function supersedeMergeRuns(registry) {
+    const shared = registry.supersedeKind;
+    if (typeof shared === 'function')
+        return await shared.call(registry, 'merge');
+    const ids = mergeRunIdsToSupersede(registry.runs());
+    if (ids.length === 0)
+        return 0;
+    await registry.supersede(ids);
+    return ids.length;
+}
+//# sourceMappingURL=supersede.js.map

package/lib/types/undo-merge.js

@@ -0,0 +1,23 @@
+import { executeUnitUndo, planUnitUndoAcross } from '@lmzhen/dsh-evolution-core';
+export async function undoMergeReceipt(receipt, port) {
+    const targetVersions = (await port.listVersions(receipt.target)).filter(entry => entry.unitId === receipt.unitId);
+    if (targetVersions.length === 0) {
+        return { ok: false, message: 'unit ' + receipt.unitId + ' is not in the target history; refusing to guess', reverted: [] };
+    }
+    const members = [{ skill: receipt.target, entries: targetVersions, status: 'live', ...(receipt.create ? { createdInUnit: true } : {}) }];
+    for (const source of receipt.sources) {
+        const live = await port.readSkill(source);
+        members.push({
+            skill: source,
+            entries: (await port.listVersions(source)).filter(entry => entry.unitId === receipt.unitId),
+            status: live === null ? 'archived' : 'live',
+            ...(live === null ? { archivedPath: 'archive' } : {}),
+        });
+    }
+    const plan = planUnitUndoAcross(members);
+    if (plan.refusals.length > 0) {
+        return { ok: false, message: 'merge undo preflight refused: ' + plan.refusals.join('; '), reverted: [] };
+    }
+    return await executeUnitUndo(plan, port);
+}
+//# sourceMappingURL=undo-merge.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-merge",
   "description": "Skill auto-merge domain: screening, two-round authoring, queues and commit orchestration (community build)",
-  "version": "0.28.0",
+  "version": "0.30.0",
   "publishConfig": {
     "access": "public"
   },
@@ -21,21 +21,18 @@
     "./package.json": "./package.json"
   },
   "files": [
-    "lib/*.js",
+    "lib/**/*.js",
     "lib/types/**/*.d.ts"
   ],
   "license": "MIT",
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.5",
-    "@lmzhen/dsh-evolution-core": "^0.28.0"
+    "@lmzhen/dsh-evolution-core": "^0.30.0",
+    "@lmzhen/dsh-evolution-merge-engine": "^0.30.0"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.5"
   },
-  "devDependencies": {
-    "@deepseek-ai/cordis": "^4.0.5",
-    "@lmzhen/dsh-evolution-core": "^0.28.0"
-  },
   "engines": {
     "dsh": ">=0.2.1-rc.1 <0.2.2-0"
   }

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

@@ -1,31 +0,0 @@
-/**
- * Structural ModelPort adapter over the platform llm service. The platform exposes either
- * `stream()` (the current shape) or the older prepareCall()/stream pair; both return raw text
- * because the gate and proposer own JSON extraction.
- */
-import type { ModelPort } from '../propose.ts';
-export interface ModelRoute {
-    readonly provider: string;
-    readonly model: string;
-}
-export interface LlmChunkLike {
-    readonly type: string;
-    readonly text?: string;
-    readonly usage?: unknown;
-    readonly reason?: {
-        readonly kind?: string;
-        readonly failure?: {
-            readonly message?: string;
-        };
-    };
-}
-export interface LlmCallLike {
-    readonly config: Record<string, unknown>;
-    stream(input: Record<string, unknown>): AsyncIterable<LlmChunkLike>;
-}
-export interface LlmServiceLike {
-    prepareCall?(config: Record<string, unknown>, signal?: AbortSignal): Promise<LlmCallLike>;
-    stream?(options: Record<string, unknown>): AsyncIterable<LlmChunkLike>;
-}
-export declare function createModelPort(llm: LlmServiceLike, route: () => ModelRoute): ModelPort;
-//# sourceMappingURL=model.d.ts.map

package/lib/types/gate-filter.d.ts

@@ -1,31 +0,0 @@
-/**
- * Gate filter: turn lexical/proposed candidates into the candidates scan may process.
- * L0 keeps are dropped unless the deterministic 10% audit re-runs L2 and overrides.
- */
-import type { MergeCandidate } from './contracts.ts';
-import { type GateCache, type GateFacts, type GateModelPort, type GateVerdict } from './ladder.ts';
-export interface GateFilterOptions {
-    readonly facts: readonly GateFacts[];
-    readonly model: GateModelPort;
-    readonly modelName: string;
-    readonly signal: AbortSignal;
-    readonly runSeed: string;
-    readonly cache?: GateCache;
-    readonly auditRate?: number;
-}
-export interface GateDecision {
-    readonly candidate: MergeCandidate;
-    readonly verdicts: readonly GateVerdict[];
-    readonly auditOverride: boolean;
-}
-export interface GateFilterResult {
-    readonly kept: readonly GateDecision[];
-    readonly dropped: readonly GateDecision[];
-    readonly errors: readonly {
-        readonly candidate: MergeCandidate;
-        readonly message: string;
-    }[];
-    readonly calls: number;
-}
-export declare function filterCandidates(candidates: readonly MergeCandidate[], options: GateFilterOptions): Promise<GateFilterResult>;
-//# sourceMappingURL=gate-filter.d.ts.map

package/lib/types/propose.d.ts

@@ -1,26 +0,0 @@
-/**
- * C3 semantic proposer: one library-level model call (sharded when the library is large)
- * that proposes candidate pairs. It never judges merge quality; L0–L2 does that.
- */
-import type { MergeCandidate } from './contracts.ts';
-import type { SkillCard } from './screening.ts';
-export interface ModelPort {
-    callJson(request: {
-        readonly system: string;
-        readonly user: string;
-        readonly maxTokens: number;
-        readonly signal: AbortSignal;
-    }): Promise<unknown>;
-}
-export interface ProposeOptions {
-    readonly shardSize?: number;
-    readonly maxPairs?: number;
-    readonly signal: AbortSignal;
-}
-export interface ProposeResult {
-    readonly candidates: readonly MergeCandidate[];
-    readonly shards: number;
-    readonly degraded: readonly string[];
-}
-export declare function proposePairs(cards: readonly SkillCard[], port: ModelPort, options: ProposeOptions): Promise<ProposeResult>;
-//# sourceMappingURL=propose.d.ts.map

package/lib/types/screening-port.d.ts

@@ -1,47 +0,0 @@
-/**
- * The real screening port: lexical floor + optional C3 proposal + optional L0–L2 gate.
- * Each stage is independently testable; this file only composes their frozen contracts.
- */
-import { type MergeCandidate } from './contracts.ts';
-import { type SkillCard, type ScreeningOptions } from './screening.ts';
-import { type ModelPort } from './propose.ts';
-import type { GateCache, GateModelPort } from './ladder.ts';
-export interface ScreeningForRunOptions extends Omit<BuildScreeningOptions, 'signal'> {
-    readonly runSeed: string;
-}
-export interface BuildScreeningOptions {
-    readonly cards: readonly SkillCard[];
-    readonly signal: AbortSignal;
-    readonly lexical?: ScreeningOptions;
-    readonly propose?: {
-        readonly model: ModelPort;
-        readonly shardSize?: number;
-        readonly maxPairs?: number;
-    };
-    readonly gate?: {
-        readonly model: GateModelPort;
-        readonly modelName: string;
-        readonly runSeed: string;
-        readonly cache?: GateCache;
-        readonly auditRate?: number;
-    };
-}
-export interface ScreeningPortStats {
-    readonly lexical: number;
-    readonly proposed: number;
-    readonly candidates: number;
-    readonly kept: number;
-    readonly dropped: number;
-    readonly gateCalls: number;
-    readonly gateErrors: number;
-    readonly shards: number;
-}
-export interface ScreeningPortResult {
-    readonly candidates: readonly MergeCandidate[];
-    readonly stats: ScreeningPortStats;
-    readonly degraded: readonly string[];
-}
-export declare function buildScreeningCandidates(options: BuildScreeningOptions): Promise<ScreeningPortResult>;
-/** Build the run-scoped screening function; the run id seeds the 10% audit. */
-export declare function createScreeningForRun(options: ScreeningForRunOptions): (signal: AbortSignal) => Promise<readonly MergeCandidate[]>;
-//# sourceMappingURL=screening-port.d.ts.map

package/lib/types/screening.d.ts

@@ -1,30 +0,0 @@
-import type { MergeCandidate } from './contracts.ts';
-export interface SkillCard {
-    readonly name: string;
-    readonly description: string;
-    readonly body: string;
-}
-export interface ScreeningOptions {
-    /** Body Jaccard at/above this is a candidate on its own. */
-    readonly bodyGate?: number;
-    /** Description Jaccard at/above this is a candidate when the body also clears minAffinity. */
-    readonly summaryGate?: number;
-    /** Minimum body affinity for a summary-led candidate. */
-    readonly minAffinity?: number;
-    /** Upper bound after sorting by score; absent = no cap. */
-    readonly maxCandidates?: number;
-}
-export interface ScreeningStats {
-    readonly skills: number;
-    readonly filtered: number;
-    readonly candidates: number;
-}
-export interface ScreeningResult {
-    readonly candidates: readonly MergeCandidate[];
-    readonly stats: ScreeningStats;
-}
-/** Shannon entropy over characters; a cheap prefilter signal, not a name-quality judge. */
-export declare function nameEntropy(name: string): number;
-export declare function prefilter(cards: readonly SkillCard[]): readonly SkillCard[];
-export declare function lexicalCandidates(cards: readonly SkillCard[], options?: ScreeningOptions): ScreeningResult;
-//# sourceMappingURL=screening.d.ts.map