@lmzhen/dsh-evolution-merge 0.28.0 → 0.30.0

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.d.ts

@@ -32,5 +32,8 @@ export interface MergeCommandDefinitionLike {
     readonly handler: (invocation: CommandInvocationLike) => Promise<CommandResultLike>;
 }
 export declare function createReadOnlyMergeService(io: EvolutionIoLike, home: string): MergeCommandService;
+export declare function runMergeCommand(service: MergeCommandService, rawInput: string, invocation?: {
+    readonly agent?: unknown;
+}): Promise<MergeCommandResult>;
 export declare function createMergeCommand(service: MergeCommandService): MergeCommandDefinitionLike;
 //# sourceMappingURL=merge-command.d.ts.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,16 +6,27 @@ 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;
 }
 export declare function makeMergeRoutes(deps: {
     getSource: () => MergeRouteSource | undefined;

package/lib/types/merge-routes.js

@@ -0,0 +1,99 @@
+import { HOST_ROUTES, json, methodNotAllowed } from '@lmzhen/dsh-evolution-core/http-routes';
+import { buildMergeView, pageQueue, toRunFact } from "./routes.js";
+import { renderMarkdown } from "./domain/markdown.js";
+const MERGE_PATHS = HOST_ROUTES.merge;
+const MERGE_BASE = MERGE_PATHS.view.slice(0, -'view'.length);
+export const MERGE_ROUTES = {
+    view: MERGE_PATHS.view,
+    rows: MERGE_PATHS.rows,
+    body: (MERGE_PATHS.body ?? MERGE_BASE + 'body'),
+    history: (MERGE_PATHS.history ?? MERGE_BASE + 'history'),
+};
+export function makeMergeRoutes(deps, _audit) {
+    const absent = () => json(503, { ok: false, error: { code: 'merge-service-absent', message: 'merge service is not mounted' } });
+    const get = (request) => (request.method === 'GET' ? null : methodNotAllowed(['GET']));
+    const url = (request) => new URL(request.url, 'http://local');
+    return [
+        {
+            path: MERGE_ROUTES.view,
+            methods: ['GET'],
+            requestBody: 'buffered',
+            fetch: async (request) => {
+                const denied = get(request);
+                if (denied !== null)
+                    return denied;
+                const source = deps.getSource();
+                if (source === undefined)
+                    return absent();
+                const runs = await source.runs(undefined, 20);
+                const latestMerge = runs.find(run => run.kind === 'merge');
+                return json(200, {
+                    ok: true,
+                    data: buildMergeView(await source.rows(), source.commands(), latestMerge === undefined ? undefined : toRunFact(latestMerge), source.approval?.()),
+                });
+            },
+        },
+        {
+            path: MERGE_ROUTES.rows,
+            methods: ['GET'],
+            requestBody: 'buffered',
+            fetch: async (request) => {
+                const denied = get(request);
+                if (denied !== null)
+                    return denied;
+                const source = deps.getSource();
+                if (source === undefined)
+                    return absent();
+                const query = url(request).searchParams;
+                const queue = query.get('queue') ?? 'verify';
+                if (queue !== 'verify' && queue !== 'pending' && queue !== 'fuse' && queue !== 'skipped') {
+                    return json(400, { ok: false, error: { code: 'bad-queue', message: 'queue must be verify/pending/fuse/skipped' } });
+                }
+                const cursor = Number.parseInt(query.get('cursor') ?? '0', 10);
+                const limit = Number.parseInt(query.get('limit') ?? '50', 10);
+                return json(200, {
+                    ok: true,
+                    data: pageQueue(await source.rows(), queue, Number.isFinite(cursor) ? cursor : 0, Number.isFinite(limit) ? limit : 50),
+                });
+            },
+        },
+        {
+            path: MERGE_ROUTES.body,
+            methods: ['GET'],
+            requestBody: 'buffered',
+            fetch: async (request) => {
+                const denied = get(request);
+                if (denied !== null)
+                    return denied;
+                const source = deps.getSource();
+                if (source === undefined)
+                    return absent();
+                const query = url(request).searchParams;
+                const id = query.get('id');
+                const side = query.get('side');
+                if (id === null || id === '' || (side !== 'a' && side !== 'b')) {
+                    return json(400, { ok: false, error: { code: 'bad-body-query', message: 'id and side=a|b are required' } });
+                }
+                const content = await source.body(id, side);
+                return content === null
+                    ? json(404, { ok: false, error: { code: 'body-not-found', message: 'merge body not found: ' + id } })
+                    : json(200, { ok: true, data: { content, markdown: true, html: renderMarkdown(content) } });
+            },
+        },
+        {
+            path: MERGE_ROUTES.history,
+            methods: ['GET'],
+            requestBody: 'buffered',
+            fetch: async (request) => {
+                const denied = get(request);
+                if (denied !== null)
+                    return denied;
+                const source = deps.getSource();
+                if (source === undefined)
+                    return absent();
+                return json(200, { ok: true, data: { items: await source.history() } });
+            },
+        },
+    ];
+}
+//# sourceMappingURL=merge-routes.js.map

package/lib/types/merge-tool.js

@@ -0,0 +1,69 @@
+import { applyStageTool } from "./stage-tool.js";
+export const MERGE_STAGE_TOOL_NAME = 'merge_stage';
+function shapeError(message) {
+    return { ok: false, code: 'bad-path', message };
+}
+function operation(args) {
+    const op = args.op;
+    if (op === 'list') {
+        const area = args.area;
+        if (area !== 'sources' && area !== 'merged')
+            return shapeError('list.area must be sources or merged');
+        return { op, area, ...(typeof args.path === 'string' ? { path: args.path } : {}), ...(typeof args.source === 'string' ? { source: args.source } : {}) };
+    }
+    if (op === 'read') {
+        const area = args.area;
+        if (area !== 'sources' && area !== 'merged')
+            return shapeError('read.area must be sources or merged');
+        if (typeof args.path !== 'string' || args.path === '')
+            return shapeError('read.path is required');
+        return { op, area, path: args.path, ...(typeof args.source === 'string' ? { source: args.source } : {}) };
+    }
+    if (op === 'write') {
+        if (typeof args.path !== 'string' || args.path === '')
+            return shapeError('write.path is required');
+        if (typeof args.content !== 'string')
+            return shapeError('write.content must be a string');
+        return { op, path: args.path, content: args.content };
+    }
+    if (op === 'copy') {
+        if (typeof args.source !== 'string' || typeof args.from !== 'string' || typeof args.to !== 'string')
+            return shapeError('copy requires source/from/to');
+        return { op, source: args.source, from: args.from, to: args.to };
+    }
+    return shapeError('op must be list/read/write/copy');
+}
+export function createMergeStageTool(io, home, context) {
+    return {
+        name: MERGE_STAGE_TOOL_NAME,
+        description: 'Read source copies and write the merged skill into the staging tree. list/read use area=sources|merged plus source (for sources); write/copy paths are relative to merged/<target> (for example path=SKILL.md, from=SKILL.md, to=references/x.md). Write/copy are only allowed in the author phase.',
+        parameters: {
+            type: 'object',
+            properties: {
+                op: { type: 'string', enum: ['list', 'read', 'write', 'copy'] },
+                area: { type: 'string', enum: ['sources', 'merged'] },
+                path: { type: 'string' },
+                source: { type: 'string' },
+                content: { type: 'string' },
+                from: { type: 'string' },
+                to: { type: 'string' },
+            },
+            required: ['op'],
+            additionalProperties: false,
+        },
+        output: {
+            schema: { type: 'string' },
+            render: (_args, value) => [{ type: 'text', text: value }],
+        },
+        async execute(args, exec) {
+            const op = operation(args);
+            if ('ok' in op)
+                return JSON.stringify(op);
+            const ctx = context(exec);
+            if (ctx === undefined)
+                return JSON.stringify({ ok: false, code: 'not-merge-child', message: 'merge_stage is only available to an active merge child' });
+            return JSON.stringify(await applyStageTool(io, home, ctx, op));
+        },
+    };
+}
+//# sourceMappingURL=merge-tool.js.map

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

@@ -4,7 +4,7 @@
  */
 import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
 import type { MergeDecision, MergeRow } from './contracts.ts';
-import type { SkillCard } from './screening.ts';
+import type { SkillCard } from './skill-card.ts';
 import type { ConversationChannelLike } from './channel-port.ts';
 import { type CommitPort } from './commit-execute.ts';
 import type { StageToolContext } from './stage-tool.ts';