@lmzhen/dsh-evolution-merge 0.29.0 → 0.30.1

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

@@ -0,0 +1,57 @@
+/** Pure merge decision state machine. No IO, no host imports. */
+export type MergeState = 'verify' | 'pending' | 'approved' | 'fuse' | 'skipped';
+export type MergeQueue = 'verify' | 'pending' | 'fuse' | 'skipped';
+export type MergeEvent = {
+    readonly type: 'candidate';
+} | {
+    readonly type: 'round1-start';
+} | {
+    readonly type: 'round1-keep';
+} | {
+    readonly type: 'round1-merge';
+    readonly approval: boolean;
+} | {
+    readonly type: 'round1-fail';
+} | {
+    readonly type: 'approve';
+} | {
+    readonly type: 'reject';
+} | {
+    readonly type: 'round2-start';
+} | {
+    readonly type: 'round2-fail';
+} | {
+    readonly type: 'round2-merged';
+} | {
+    readonly type: 'round2-cancel';
+} | {
+    readonly type: 'staging-expired';
+} | {
+    readonly type: 'source-gone';
+} | {
+    readonly type: 'target-taken';
+} | {
+    readonly type: 'source-changed';
+} | {
+    readonly type: 'cancel';
+} | {
+    readonly type: 'timeout';
+};
+export type TransitionResult = {
+    readonly ok: true;
+    readonly state: MergeState;
+} | {
+    readonly ok: true;
+    readonly state: null;
+    readonly removed: true;
+} | {
+    readonly ok: false;
+    readonly code: 'invalid-transition';
+    readonly message: string;
+};
+export declare function queueOf(state: MergeState): MergeQueue;
+export declare function isTerminal(state: MergeState): boolean;
+/** Single transition point; callers must not mutate fields outside this function. */
+export declare function transition(state: MergeState, event: MergeEvent): TransitionResult;
+export declare function allowedEvents(state: MergeState): readonly MergeEvent['type'][];
+//# sourceMappingURL=state.d.ts.map

package/lib/types/domain/state.js

@@ -0,0 +1,65 @@
+export function queueOf(state) {
+    switch (state) {
+        case 'verify': return 'verify';
+        case 'pending': return 'pending';
+        case 'approved':
+        case 'fuse': return 'fuse';
+        case 'skipped': return 'skipped';
+    }
+}
+export function isTerminal(state) {
+    return state === 'skipped';
+}
+function fail(state, event) {
+    return { ok: false, code: 'invalid-transition', message: 'cannot apply ' + event.type + ' to ' + state };
+}
+/** Single transition point; callers must not mutate fields outside this function. */
+export function transition(state, event) {
+    switch (event.type) {
+        case 'candidate':
+            return state === 'verify' ? { ok: true, state: 'verify' } : fail(state, event);
+        case 'round1-start':
+            return state === 'verify' ? { ok: true, state: 'verify' } : fail(state, event);
+        case 'round1-keep':
+            return state === 'verify' ? { ok: true, state: 'skipped' } : fail(state, event);
+        case 'round1-merge':
+            return state === 'verify'
+                ? { ok: true, state: event.approval ? 'pending' : 'approved' }
+                : fail(state, event);
+        case 'round1-fail':
+            return state === 'verify' ? { ok: true, state: 'verify' } : fail(state, event);
+        case 'approve':
+            return state === 'pending' ? { ok: true, state: 'approved' } : fail(state, event);
+        case 'reject':
+            return state === 'pending' || state === 'approved' || state === 'fuse'
+                ? { ok: true, state: 'skipped' }
+                : fail(state, event);
+        case 'round2-start':
+            return state === 'approved' ? { ok: true, state: 'fuse' } : fail(state, event);
+        case 'round2-fail':
+        case 'round2-cancel':
+            return state === 'fuse' || state === 'approved' ? { ok: true, state: 'approved' } : fail(state, event);
+        case 'round2-merged':
+            return state === 'fuse' || state === 'approved' ? { ok: true, state: null, removed: true } : fail(state, event);
+        case 'staging-expired':
+            return state === 'fuse' ? { ok: true, state: 'approved' } : fail(state, event);
+        case 'source-gone':
+            return { ok: true, state: null, removed: true };
+        case 'target-taken':
+        case 'source-changed':
+            return state === 'pending' ? { ok: true, state: 'pending' } : fail(state, event);
+        case 'cancel':
+        case 'timeout':
+            return state === 'verify' || state === 'approved' || state === 'fuse' ? { ok: true, state } : fail(state, event);
+    }
+}
+export function allowedEvents(state) {
+    switch (state) {
+        case 'verify': return ['candidate', 'round1-start', 'round1-keep', 'round1-merge', 'round1-fail', 'source-gone', 'cancel', 'timeout'];
+        case 'pending': return ['approve', 'reject', 'target-taken', 'source-changed', 'source-gone'];
+        case 'approved': return ['round2-start', 'reject', 'staging-expired', 'source-gone', 'cancel', 'timeout'];
+        case 'fuse': return ['round2-fail', 'round2-merged', 'round2-cancel', 'staging-expired', 'reject', 'source-gone', 'cancel', 'timeout'];
+        case 'skipped': return [];
+    }
+}
+//# sourceMappingURL=state.js.map

package/lib/types/gate-cache.js

@@ -0,0 +1,36 @@
+/**
+ * File-backed gate cache: <home>/merge/gate-cache.json.
+ * Reads are three-state; a malformed file is reported, not overwritten. Writes are one
+ * transact so two runs cannot interleave a partial cache.
+ */
+import { join } from 'node:path';
+import { probeText, transactIo } from '@lmzhen/dsh-evolution-core';
+import { GateCache } from "./ladder.js";
+export const GATE_CACHE_VERSION = 1;
+export function gateCachePath(home) {
+    return join(home, 'merge', 'gate-cache.json');
+}
+export async function loadGateCache(io, home) {
+    const probe = await probeText(io, gateCachePath(home));
+    if (probe.kind === 'absent')
+        return { cache: new GateCache() };
+    if (probe.kind === 'unknown')
+        return { cache: new GateCache(), note: probe.reason };
+    try {
+        const parsed = JSON.parse(probe.value);
+        if (parsed.schemaVersion !== GATE_CACHE_VERSION || typeof parsed.entries !== 'object' || parsed.entries === null) {
+            return { cache: new GateCache(), note: 'gate cache has an unexpected shape' };
+        }
+        return { cache: GateCache.fromObject(parsed.entries) };
+    }
+    catch (error) {
+        return { cache: new GateCache(), note: 'gate cache is not JSON: ' + (error instanceof Error ? error.message : String(error)) };
+    }
+}
+export async function saveGateCache(io, home, cache) {
+    await transactIo(io, gateCachePath(home), () => JSON.stringify({ schemaVersion: GATE_CACHE_VERSION, entries: cache.toObject() }, null, 2) + '\n');
+}
+export function hasGateCache(cache) {
+    return cache.size > 0;
+}
+//# sourceMappingURL=gate-cache.js.map

package/lib/types/index.js

@@ -0,0 +1,241 @@
+import { join } from 'node:path';
+import z from '@deepseek-ai/schemastery';
+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, DEFAULT_SKILL_LIMITS, evolutionHome, evolutionIoAdapter, newRunRegistry, newSkillLibrary, policyStageLimits } from '@lmzhen/dsh-evolution-core';
+import { registerHostRoutes } from '@lmzhen/dsh-evolution-core/http-routes';
+import { loadMergeState, upsertRow } from "./state.js";
+import { cleanupExpiredStaging } from "./staging.js";
+import { readCommitReceipts } from "./commit-receipt.js";
+import { transition } from "./coordinator.js";
+import { makeMergeRoutes } from "./merge-routes.js";
+import { createMergeCommand, runMergeCommand } from "./merge-command.js";
+import { createMergeRuntime } from "./runtime.js";
+import { resolveMergeParams } from "./params.js";
+import { subagentChannelAdapter } from "./adapters/channel.js";
+import { StageToolRegistry } from "./stage-tool-registry.js";
+import { createMergeStageTool } from "./merge-tool.js";
+import { supersedeMergeRuns } from "./supersede.js";
+/** E3 knobs are volatile (user layer); the E2 pair timeout is deployment-only. */
+export const Config = z.object({
+    mergeApproval: z.boolean().default(false).volatile(),
+    mergeSkippedTtlDays: z.number().min(0).default(0).volatile(),
+    mergeRunTimeoutMinutes: z.number().min(0).default(0).volatile(),
+    mergePairTimeoutMinutes: z.number().min(1).default(15),
+    mergeModelsRoot: z.string().default(''),
+});
+export function engineConfigFromEnv(configuredRoot) {
+    const root = configuredRoot !== undefined && configuredRoot !== '' ? configuredRoot : process.env.SKILL_MERGE_MODELS_ROOT;
+    if (root === undefined || root === '')
+        return undefined;
+    return {
+        models_dir: '',
+        offline: true,
+        auto_provision: false,
+        embed_backend: 'local',
+        embedder_model: join(root, 'potion-multilingual-128M-int8'),
+        embedder_model_last: join(root, 'potion-multilingual-128M-pca64-int8'),
+    };
+}
+/** Suppress the platform auto form; the registry renders the merge card instead. */
+export function configureMergePresentation(ctx) {
+    ctx.inject(['settings'], (scope) => {
+        const settings = scope.settings;
+        if (typeof settings?.configure !== 'function')
+            return;
+        const disposer = settings.configure({ auto: false }, ctx.fiber);
+        if (typeof disposer === 'function')
+            scope.effect(() => disposer, 'evolution-merge: settings presentation');
+    });
+}
+export * from "./contracts.js";
+export * from "./skill-card.js";
+export * from "./state.js";
+export * from "./coordinator.js";
+export * from "./report.js";
+export * from "./staging.js";
+export * from "./staging-files.js";
+export * from "./rules.js";
+export * from "./commit-plan.js";
+export * from "./stage-tool.js";
+export * from "./stage-tool-registry.js";
+export * from "./staged-tree.js";
+export * from "./commit-assembly.js";
+export * from "./commit-receipt.js";
+export * from "./commit-execute.js";
+export * from "./undo-merge.js";
+export * from "./adapters/library.js";
+export * from "./adapters/model-runner.js";
+export * from "./adapters/channel.js";
+export * from "./adapters/engine-screen.js";
+export * from "./adapters/undo.js";
+export * from "./run-shell.js";
+export * from "./scan-run.js";
+export * from "./pending-actions.js";
+export * from "./scan-command.js";
+export * from "./round2-outcome.js";
+export * from "./approve-command.js";
+export * from "./pair-command.js";
+export * from "./resume-command.js";
+export * from "./decision.js";
+export * from "./prompts.js";
+export * from "./channel-port.js";
+export * from "./authoring-flow.js";
+export * from "./merge-tool.js";
+export * from "./commands.js";
+export * from "./scan-ports.js";
+export * from "./new-child-authoring.js";
+export * from "./status.js";
+export * from "./skipped.js";
+export * from "./read-commands.js";
+export * from "./routes.js";
+export * from "./merge-routes.js";
+export * from "./merge-command.js";
+export * from "./params.js";
+export * from "./doctor.js";
+export * from "./supersede.js";
+export * from "./runtime.js";
+export const inject = [];
+export function apply(ctx, rawConfig = {}) {
+    configureMergePresentation(ctx);
+    const params = resolveMergeParams(rawConfig);
+    let mergeRun;
+    const mergeService = {
+        async run(rawInput, invocation) {
+            return mergeRun === undefined ? { ok: false, text: 'merge 未就绪：evolutionIo 尚未挂载' } : mergeRun(rawInput, invocation);
+        },
+    };
+    const mergeContext = ctx;
+    if (typeof mergeContext.provide === 'function') {
+        ;
+        mergeContext.provide('evolutionMerge', mergeService);
+    }
+    let source;
+    registerHostRoutes(ctx, audit => makeMergeRoutes({ getSource: () => source }, audit));
+    ctx.inject(['commands', 'evolutionIo'], (scope) => {
+        const registry = scope.get('evolutionIo');
+        if (registry === undefined)
+            return;
+        const io = evolutionIoAdapter(() => registry.provider());
+        const home = evolutionHome();
+        void loadMergeState(io, home).then(loaded => cleanupExpiredStaging(io, home, Date.now(), new Set(loaded.state.rows.map(row => row.runId).filter((id) => id !== undefined)))).catch((error) => { ctx.logger.warn('merge staging cleanup failed: ' + (error instanceof Error ? error.message : String(error))); });
+        const runs = newRunRegistry({ io, home, warn: (message) => { ctx.logger.warn(message); } });
+        void runs.load();
+        ctx.effect(() => {
+            const host = ctx;
+            if (typeof host.on !== 'function')
+                return () => { };
+            return host.on('evolution/skill-mutated', (event) => {
+                if (event.action === 'restore')
+                    void supersedeMergeRuns(runs);
+            });
+        }, 'evolution-merge: restore supersede');
+        const policySnapshot = ctx.get('evolutionPolicy');
+        const skills = newSkillLibrary({
+            io, ctx, authority: authorityFrom({ origin: 'subagent' }),
+            limits: { ...DEFAULT_SKILL_LIMITS, ...policyStageLimits(policySnapshot?.get?.()) },
+        });
+        const channel = subagentChannelAdapter(createSubagentChannel(ctx));
+        const stage = new StageToolRegistry();
+        const engineConfig = engineConfigFromEnv(params.mergeModelsRoot);
+        const llm = ctx.get('llm');
+        const defaultModel = ctx.get('agentDefaultModel');
+        const runner = llm === undefined || defaultModel === undefined
+            ? undefined
+            : createEngineRunner(llm, () => defaultModel.currentSelection());
+        const engineScreening = createEngineScreening({
+            io,
+            home,
+            engine: { screen: engineScreen },
+            select: selectWithErrors,
+            cfg: { ...(engineConfig ?? {}), judge: 'deepseek' },
+            ...(runner === undefined ? {} : { runner }),
+            async onSelection(selection) {
+                const loaded = await loadMergeState(io, home);
+                const at = new Date().toISOString();
+                for (const skipped of selection.skipped) {
+                    if (loaded.state.rows.some(row => row.pairKey === skipped.pairKey))
+                        continue;
+                    const next = transition(undefined, {
+                        type: 'gate-keep', a: skipped.a, b: skipped.b,
+                        ...(skipped.reason === undefined ? {} : { reason: skipped.reason }), at,
+                    });
+                    if (next.ok && next.row !== null)
+                        await upsertRow(io, home, () => Date.now(), next.row);
+                }
+            },
+        });
+        source = {
+            rows() { return loadMergeState(io, home).then(loaded => loaded.state.rows); },
+            run(id) { return Promise.resolve(runs.runs().find(record => record.id === id)); },
+            runs() { return Promise.resolve(runs.runs()); },
+            async body(id, side) {
+                const row = (await loadMergeState(io, home)).state.rows.find(item => item.id === id);
+                if (row === undefined)
+                    return null;
+                return await skills.read(side === 'a' ? row.a : row.b);
+            },
+            async history() {
+                const receipts = await readCommitReceipts(io, home);
+                const items = new Map();
+                for (const receipt of receipts) {
+                    for (const source of receipt.sources) {
+                        const key = source + ':' + receipt.runId;
+                        if (items.has(key))
+                            continue;
+                        items.set(key, { name: source, kind: 'merged', reason: 'Merged into ' + receipt.target, lastVersion: 1, archivedAt: new Date(receipt.at).toISOString(), sourceRunId: receipt.runId });
+                    }
+                }
+                const archived = await skills.archivedNames?.() ?? [];
+                const seen = new Set([...items.values()].map(item => item.name));
+                for (const name of archived) {
+                    if (seen.has(name))
+                        continue;
+                    items.set('archived:' + name, { name, kind: 'other', reason: 'archived', lastVersion: 1, archivedAt: new Date(Date.now()).toISOString() });
+                }
+                return [...items.values()];
+            },
+            approval() { return params.mergeApproval; },
+            commands() {
+                return ['merge scan', 'merge doctor', 'merge status', 'merge pending', 'merge skipped', 'merge report', 'merge runs', 'merge cancel'];
+            },
+        };
+        const commands = scope.get('commands');
+        if (commands === undefined)
+            return;
+        const runtime = createMergeRuntime({
+            io, home, registry: runs, skills, now: () => Date.now(), params, platformWrite: true,
+            channel, parent: undefined, allow: ['merge_stage'], timeoutMinutes: params.mergeRunTimeoutMinutes,
+            async cards(signal) {
+                const listed = await skills.list({ withContent: true });
+                if (signal.aborted)
+                    return [];
+                return Promise.all(listed.map(async (item) => {
+                    const probe = await skills.listSupportFiles(item.name);
+                    const paths = probe.kind === 'present' ? probe.value : [];
+                    const files = await Promise.all(paths.map(async (path) => ({ path, content: await skills.readSupportFile(item.name, path) ?? '' })));
+                    return { name: item.name, description: item.description, body: item.content ?? '', files, protectedBy: item.protectedBy, protectionUnknown: item.protectionUnknown };
+                }));
+            },
+            screeningForRun: engineScreening,
+            stage: {
+                bind: (context) => { stage.bind(context.childId, context); },
+                unbind: (childId) => { stage.unbind(childId); },
+            },
+        });
+        mergeRun = (rawInput, invocation) => runMergeCommand(runtime, rawInput, invocation);
+        const command = createMergeCommand(runtime);
+        scope.effect(() => commands.register(command), 'evolution-merge: command');
+        ctx.inject(['tools'], (toolScope) => {
+            const tools = toolScope.get('tools');
+            if (tools === undefined)
+                return;
+            const tool = createMergeStageTool(io, home, exec => stage.resolve(exec));
+            toolScope.effect(() => tools.register(tool), 'evolution-merge: merge_stage');
+        });
+        scope.effect(() => () => { runs.cancelAll(); }, 'evolution-merge: runs');
+    });
+}
+//# sourceMappingURL=index.js.map

package/lib/types/ladder.js

@@ -0,0 +1,162 @@
+/**
+ * L0–L2 candidate gate. This is a CANDIDATE classifier, not a content quality judge.
+ * Routing follows the frozen table: L0 -1 stops; L0 1/0 → L1; L1 -1 stops; L1 0/1 → L2;
+ * L2 1 → agent1; L2 0 → agent1 (undecided); L2 -1 → skipped.
+ */
+import { createHash } from 'node:crypto';
+export class GateCache {
+    entries = new Map();
+    get(key) { return this.entries.get(key); }
+    put(key, value) { this.entries.set(key, value); }
+    get size() { return this.entries.size; }
+    toObject() { return Object.fromEntries(this.entries); }
+    static fromObject(value) {
+        const cache = new GateCache();
+        if (typeof value !== 'object' || value === null)
+            return cache;
+        for (const [key, entry] of Object.entries(value)) {
+            if (typeof entry !== 'object' || entry === null)
+                continue;
+            const verdict = entry;
+            if (verdict.verdict === 1 || verdict.verdict === 0 || verdict.verdict === -1) {
+                cache.put(key, { level: verdict.level === 'L0' || verdict.level === 'L1' || verdict.level === 'L2' ? verdict.level : 'L2', verdict: verdict.verdict, reason: typeof verdict.reason === 'string' ? verdict.reason : '', evidence: Array.isArray(verdict.evidence) ? verdict.evidence : [], cached: true });
+            }
+        }
+        return cache;
+    }
+}
+export function gateCacheKey(level, payload, model) {
+    return createHash('sha256').update(JSON.stringify({ level, payload, model })).digest('hex');
+}
+function payloadFor(level, candidate, facts) {
+    const a = facts.get(candidate.a);
+    const b = facts.get(candidate.b);
+    if (a === undefined || b === undefined)
+        throw new Error('candidate names are not in the fact set');
+    const base = {
+        level,
+        skill_a: { name: a.name, description: a.description },
+        skill_b: { name: b.name, description: b.description },
+        scores: { jaccard_summary: candidate.score ?? null },
+        schema: { verdict: '1 | 0 | -1', reason: '<=80 chars' },
+    };
+    if (level === 'L0')
+        return JSON.stringify(base);
+    const withHead = {
+        ...base,
+        skill_a: { ...base.skill_a, head: a.body.slice(0, 2400) },
+        skill_b: { ...base.skill_b, head: b.body.slice(0, 2400) },
+    };
+    if (level === 'L1')
+        return JSON.stringify(withHead);
+    return JSON.stringify({
+        ...withHead,
+        skill_a: { ...withHead.skill_a, body_excerpt: a.body.slice(0, 4000) },
+        skill_b: { ...withHead.skill_b, body_excerpt: b.body.slice(0, 4000) },
+    });
+}
+const SYSTEM = 'Judge whether two skill documents describe the same reusable capability. Shared vocabulary or a shared preamble is not duplication. Return only strict JSON: {"verdict":1|0|-1,"reason":"..."}';
+function extractJson(text) {
+    const fenced = /\`\`\`(?:json)?\s*([\s\S]*?)\`\`\`/i.exec(text);
+    const body = fenced?.[1] ?? text;
+    const start = body.indexOf('{');
+    if (start < 0)
+        return undefined;
+    let depth = 0;
+    for (let index = start; index < body.length; index += 1) {
+        if (body[index] === '{')
+            depth += 1;
+        else if (body[index] === '}') {
+            depth -= 1;
+            if (depth === 0) {
+                try {
+                    return JSON.parse(body.slice(start, index + 1));
+                }
+                catch {
+                    return undefined;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+export function parseVerdict(level, raw, cached = false) {
+    const value = typeof raw === 'string' ? extractJson(raw) : raw;
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const record = value;
+    const verdict = record.verdict === 1 || record.verdict === '1' ? 1
+        : record.verdict === 0 || record.verdict === '0' ? 0
+            : record.verdict === -1 || record.verdict === '-1' ? -1
+                : undefined;
+    if (verdict === undefined)
+        return undefined;
+    const reason = typeof record.reason === 'string' ? record.reason.slice(0, 80) : '';
+    const evidence = Array.isArray(record.evidence)
+        ? record.evidence
+            .filter(item => typeof item === 'object' && item !== null)
+            .map((item) => {
+            const entry = item;
+            return { path: typeof entry.path === 'string' ? entry.path : '', line: typeof entry.line === 'number' ? entry.line : -1, quote: typeof entry.quote === 'string' ? entry.quote.slice(0, 120) : '' };
+        })
+        : [];
+    return { level, verdict, reason, evidence, cached };
+}
+/** Deterministic 10% L0 audit selection from the run seed + pair key. */
+export function selectedForAudit(pairKey, seed, rate = 0.1) {
+    const digest = createHash('sha256').update(seed + '\u0000' + pairKey).digest();
+    return digest[0] !== undefined && digest[0] < Math.round(Math.max(0, Math.min(1, rate)) * 256);
+}
+export async function runLadder(options) {
+    const facts = new Map(options.facts.map(fact => [fact.name, fact]));
+    const verdicts = [];
+    let calls = 0;
+    let level = options.startLevel ?? 'L0';
+    for (;;) {
+        let payload;
+        try {
+            payload = payloadFor(level, options.candidate, facts);
+        }
+        catch (error) {
+            return { route: 'error', verdicts, calls, error: error instanceof Error ? error.message : String(error) };
+        }
+        const key = gateCacheKey(level, payload, options.modelName);
+        const cached = options.cache?.get(key);
+        let verdict;
+        if (cached !== undefined)
+            verdict = { ...cached, level, cached: true };
+        else {
+            try {
+                calls += 1;
+                const raw = await options.model.callJson({ system: SYSTEM, user: payload, maxTokens: 500, signal: options.signal });
+                verdict = parseVerdict(level, raw);
+                if (verdict !== undefined)
+                    options.cache?.put(key, verdict);
+            }
+            catch (error) {
+                return { route: 'error', verdicts, calls, error: error instanceof Error ? error.message : String(error) };
+            }
+        }
+        if (verdict === undefined)
+            return { route: 'error', verdicts, calls, error: 'invalid gate JSON' };
+        verdicts.push(verdict);
+        if (level === 'L0') {
+            if (verdict.verdict === -1)
+                return { route: 'keep', verdicts, calls, droppedAt: 'L0' };
+            level = 'L1';
+            continue;
+        }
+        if (level === 'L1') {
+            if (verdict.verdict === -1)
+                return { route: 'keep', verdicts, calls, droppedAt: 'L1' };
+            level = 'L2';
+            continue;
+        }
+        if (verdict.verdict === 1)
+            return { route: 'merge', verdicts, calls };
+        if (verdict.verdict === 0)
+            return { route: 'undecided', verdicts, calls };
+        return { route: 'keep', verdicts, calls, droppedAt: 'L2' };
+    }
+}
+//# sourceMappingURL=ladder.js.map

package/lib/types/merge-command.js

@@ -0,0 +1,43 @@
+import { parseMergeCommand, mergeUsage } from "./commands.js";
+import { handleReadOnlyMergeCommand } from "./read-commands.js";
+import { formatMergeError } from "./domain/errors.js";
+export function createReadOnlyMergeService(io, home) {
+    return {
+        async execute(command) {
+            const text = await handleReadOnlyMergeCommand(command, io, home);
+            return text === null
+                ? { ok: false, text: 'merge ' + command.verb + ' 需要运行引擎（当前只挂载了只读命令）' }
+                : { ok: true, text };
+        },
+    };
+}
+export async function runMergeCommand(service, rawInput, invocation) {
+    const tokens = rawInput.trim().split(/\s+/).filter(Boolean);
+    if (tokens[0] === 'merge' || tokens[0] === '/merge' || tokens[0] === 'evolution' || tokens[0] === '/evolution')
+        tokens.shift();
+    if (tokens[0] === 'merge')
+        tokens.shift();
+    const parsed = parseMergeCommand(tokens);
+    if (!parsed.ok)
+        return { ok: false, text: parsed.message };
+    if (parsed.help === true)
+        return { ok: true, text: mergeUsage() };
+    try {
+        return await service.execute(parsed.command, invocation?.agent === undefined ? {} : { parent: invocation.agent });
+    }
+    catch (error) {
+        return { ok: false, text: formatMergeError({ kind: 'runtime', code: 'merge-command-failed', message: error instanceof Error ? error.message : String(error) }) };
+    }
+}
+export function createMergeCommand(service) {
+    return {
+        name: 'merge',
+        description: '技能自动合并：扫描、待批准、重跑、报告与 undo（兼容别名；请用 /evolution merge）',
+        input: { hint: mergeUsage() },
+        async handler(invocation) {
+            const result = await runMergeCommand(service, invocation.rawInput, invocation);
+            return { kind: result.ok ? 'success' : 'error', text: result.text };
+        },
+    };
+}
+//# sourceMappingURL=merge-command.js.map

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

@@ -6,15 +6,25 @@ import type { RunRecord } from '@lmzhen/dsh-evolution-core';
 import { type ConnectionFetchRouteLike, type DecisionAudit } from '@lmzhen/dsh-evolution-core/http-routes';
 import type { MergeRow } from './contracts.ts';
 export declare const MERGE_ROUTES: {
-    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";
+    view: `/api/dsh-evolution/${string}`;
+    rows: `/api/dsh-evolution/${string}`;
+    body: `/api/dsh-evolution/${string}`;
+    history: `/api/dsh-evolution/${string}`;
 };
+export interface MergeHistoryItem {
+    readonly name: string;
+    readonly kind: 'merged' | 'deleted' | 'split' | 'other';
+    readonly reason: string;
+    readonly lastVersion: number;
+    readonly archivedAt: string;
+    readonly sourceRunId?: string;
+}
 export interface MergeRouteSource {
     rows(): Promise<readonly MergeRow[]>;
     run(id: string): Promise<RunRecord | undefined>;
     runs(cursor?: string, limit?: number): Promise<readonly RunRecord[]>;
+    body(id: string, side: 'a' | 'b'): Promise<string | null>;
+    history(): Promise<readonly MergeHistoryItem[]>;
     commands(): readonly string[];
     approval?(): boolean;
 }