@lmzhen/dsh-evolution-merge 0.29.0 → 0.30.1

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.js

@@ -0,0 +1,83 @@
+import { buildRound2Prompt, STANDBY_PROMPT } from "./prompts.js";
+import { createStaging, readStaging, setStagingTarget, stageKeyOf, stagingRoot } from "./staging.js";
+import { pairKey } from "./contracts.js";
+import { readStagedTree } from "./staged-tree.js";
+import { validateStagedTree, hasBlockingFinding } from "./rules.js";
+import { commitStagedRun } from "./commit-execute.js";
+export async function runNewChildAuthoring(options, row, decision, signal) {
+    const targetCard = options.cards.find(card => card.name === decision.target);
+    if (targetCard?.protectionUnknown === true || targetCard?.protectedBy === 'pinned')
+        return { kind: 'failed', failure: { stage: 'author', code: 'target-pinned', message: 'target is pinned: ' + decision.target, retryable: false, retryFrom: 'none' } };
+    const stageKey = row.stagingRef ?? stageKeyOf(options.runId, pairKey(row.a, row.b));
+    const existing = await readStaging(options.io, options.home, stageKey);
+    if (existing.kind === 'present') {
+        await setStagingTarget(options.io, options.home, stageKey, decision.target, decision.mode);
+    }
+    else {
+        const staging = await createStaging(options.io, options.home, {
+            runId: stageKey,
+            target: decision.target,
+            mode: decision.mode,
+            sources: options.cards
+                .filter(card => card.name === row.a || card.name === row.b)
+                .map(card => ({ name: card.name, body: card.body, files: card.files ?? [] })),
+            promptVersion: 'merge-b/v1',
+            ttlDays: 7,
+            now: options.now,
+        });
+        if (!staging.ok)
+            return { kind: 'failed', failure: { stage: 'author', code: 'staging-create', message: staging.message, retryable: true, retryFrom: 'agent2' } };
+    }
+    const opened = await options.channel.open({
+        parent: options.parent,
+        label: 'merge-round2',
+        promptText: STANDBY_PROMPT,
+        kind: 'maintainer',
+        allow: options.allow,
+        cwd: stagingRoot(options.home, stageKey),
+        timeoutMs: options.timeoutMs,
+        signal,
+    });
+    if (opened.kind !== 'ok') {
+        return { kind: 'failed', failure: { stage: 'author', code: opened.kind, message: opened.kind === 'unavailable' ? opened.reason : 'round2 aborted', retryable: opened.kind !== 'aborted', retryFrom: opened.kind === 'aborted' ? 'none' : 'agent2' } };
+    }
+    options.onChild?.({ runId: stageKey, childId: opened.childId, expectedChildId: opened.childId, phase: 'author' });
+    try {
+        if (opened.turn.stopReason !== 'completed') {
+            return { kind: 'failed', failure: { stage: 'author', code: opened.turn.stopReason, message: 'standby did not complete', retryable: true, retryFrom: 'agent2' } };
+        }
+        const turn = await options.channel.continueTurn(opened.childId, buildRound2Prompt(row, decision, 'fresh'), { timeoutMs: options.timeoutMs, signal });
+        if (turn.kind !== 'ok')
+            return { kind: 'failed', failure: { stage: 'author', code: turn.kind, message: turn.kind === 'unavailable' ? turn.reason : 'round2 aborted', retryable: turn.kind !== 'aborted', retryFrom: turn.kind === 'aborted' ? 'none' : 'agent2' } };
+        if (turn.turn.stopReason !== 'completed') {
+            return { kind: 'failed', failure: { stage: 'author', code: turn.turn.stopReason, message: 'round2 did not complete', retryable: true, retryFrom: 'agent2' } };
+        }
+        const tree = await readStagedTree(options.io, options.home, stageKey);
+        if (tree.kind !== 'present')
+            return { kind: 'failed', failure: { stage: 'author', code: 'staging-missing', message: tree.kind === 'unknown' ? tree.reason : 'staged tree absent', retryable: true, retryFrom: 'agent2' } };
+        const findings = validateStagedTree(tree.value);
+        if (hasBlockingFinding(findings))
+            return { kind: 'failed', failure: { stage: 'validate', code: 'rule-gate', message: 'staged tree failed the rule gate', retryable: true, retryFrom: 'agent2' } };
+        const commit = await commitStagedRun(options.io, options.home, stageKey, options.commitPort, { origin: 'subagent', summary: 'merge ' + row.a + ' + ' + row.b, now: options.now });
+        if (!commit.ok)
+            return { kind: 'failed', failure: { stage: 'commit', code: 'commit-failed', message: commit.message, retryable: true, retryFrom: 'agent2' } };
+        const receipt = commit.receipt;
+        return {
+            kind: 'merged',
+            ...(receipt?.unitId === undefined ? {} : { unitId: receipt.unitId }),
+            archived: receipt?.archived ?? [],
+            target: { requested: decision.target, actual: commit.plan.target, created: receipt?.create ?? false },
+        };
+    }
+    finally {
+        try {
+            await options.channel.dispose(opened.childId);
+        }
+        catch { /* teardown must not replace the outcome */ }
+        options.onChildClosed?.(opened.childId);
+    }
+}
+export function createNewChildRound2(options) {
+    return (row, decision, signal, runId) => runNewChildAuthoring({ ...options, runId }, row, decision, signal);
+}
+//# sourceMappingURL=new-child-authoring.js.map

package/lib/types/pair-command.js

@@ -0,0 +1,18 @@
+import { runScanCommand } from "./scan-command.js";
+export async function runPairCommand(options) {
+    const scanOptions = {
+        io: options.io,
+        home: options.home,
+        registry: options.registry,
+        approval: options.approval,
+        platformWrite: options.platformWrite,
+        now: options.now,
+        ports: {
+            ...options.ports,
+            screening: () => Promise.resolve([{ a: options.a, b: options.b }]),
+        },
+        ...(options.timeoutMinutes === undefined ? {} : { timeoutMinutes: options.timeoutMinutes }),
+    };
+    return await runScanCommand(scanOptions);
+}
+//# sourceMappingURL=pair-command.js.map

package/lib/types/params.js

@@ -0,0 +1,49 @@
+export const MERGE_PARAM_DEFAULTS = {
+    mergeApproval: false,
+    mergeSkippedTtlDays: 0,
+    mergeRunTimeoutMinutes: 0,
+    mergePairTimeoutMinutes: 15,
+    mergeModelsRoot: '',
+};
+const KEYS = new Set(Object.keys(MERGE_PARAM_DEFAULTS));
+function materialize(value) {
+    if (typeof value === 'object' && value !== null && typeof value.get === 'function') {
+        return value.get();
+    }
+    return value;
+}
+function nonNegative(name, value) {
+    const resolved = materialize(value);
+    if (typeof resolved !== 'number' || !Number.isInteger(resolved) || resolved < 0)
+        throw new Error(name + ' must be a non-negative integer');
+    return resolved;
+}
+export function resolveMergeParams(input = {}) {
+    if (typeof input !== 'object' || input === null || Array.isArray(input))
+        throw new Error('merge params must be an object');
+    for (const key of Object.keys(input))
+        if (!KEYS.has(key))
+            throw new Error('unknown merge parameter: ' + key);
+    const record = input;
+    const approval = record.mergeApproval === undefined ? MERGE_PARAM_DEFAULTS.mergeApproval : materialize(record.mergeApproval);
+    if (typeof approval !== 'boolean')
+        throw new Error('mergeApproval must be a boolean');
+    return {
+        mergeApproval: approval,
+        mergeSkippedTtlDays: record.mergeSkippedTtlDays === undefined ? MERGE_PARAM_DEFAULTS.mergeSkippedTtlDays : nonNegative('mergeSkippedTtlDays', record.mergeSkippedTtlDays),
+        mergeRunTimeoutMinutes: record.mergeRunTimeoutMinutes === undefined ? MERGE_PARAM_DEFAULTS.mergeRunTimeoutMinutes : nonNegative('mergeRunTimeoutMinutes', record.mergeRunTimeoutMinutes),
+        mergeModelsRoot: record.mergeModelsRoot === undefined ? MERGE_PARAM_DEFAULTS.mergeModelsRoot : (() => {
+            const value = materialize(record.mergeModelsRoot);
+            if (typeof value !== 'string')
+                throw new Error('mergeModelsRoot must be a string');
+            return value;
+        })(),
+        mergePairTimeoutMinutes: record.mergePairTimeoutMinutes === undefined ? MERGE_PARAM_DEFAULTS.mergePairTimeoutMinutes : (() => {
+            const value = nonNegative('mergePairTimeoutMinutes', record.mergePairTimeoutMinutes);
+            if (value === 0)
+                throw new Error('mergePairTimeoutMinutes must be > 0');
+            return value;
+        })(),
+    };
+}
+//# sourceMappingURL=params.js.map

package/lib/types/pending-actions.js

@@ -0,0 +1,28 @@
+import { transition } from "./coordinator.js";
+import { mutateMergeState } from "./state.js";
+async function act(io, home, now, id, type) {
+    return await mutateMergeState(io, home, now, (rows) => {
+        const index = rows.findIndex(row => row.id === id);
+        if (index < 0)
+            return { rows, result: { ok: false, reason: 'not-found', message: 'pending row not found: ' + id } };
+        const current = rows[index];
+        if (current.state !== 'pending')
+            return { rows, result: { ok: false, reason: 'not-pending', message: 'row is not pending: ' + current.state } };
+        const event = type === 'approve'
+            ? { type: 'approve', at: new Date(now()).toISOString() }
+            : { type: 'reject', at: new Date(now()).toISOString() };
+        const next = transition(current, event);
+        if (!next.ok || next.row === null)
+            return { rows, result: { ok: false, reason: 'invalid', message: next.ok ? 'transition produced no row' : next.message } };
+        const copy = [...rows];
+        copy[index] = next.row;
+        return { rows: copy, result: { ok: true, row: next.row } };
+    });
+}
+export async function approvePending(io, home, now, id) {
+    return await act(io, home, now, id, 'approve');
+}
+export async function rejectPending(io, home, now, id) {
+    return await act(io, home, now, id, 'reject');
+}
+//# sourceMappingURL=pending-actions.js.map

package/lib/types/prompts.js

@@ -0,0 +1,60 @@
+export const MERGE_PROMPT_VERSION = 'merge-b/v1';
+export const STANDBY_PROMPT = 'You are a merge worker. Wait for instructions.';
+function sourcePath(name) { return 'sources/' + name; }
+function mergedPath(target) { return 'merged/' + target; }
+function wireDecision(decision) {
+    return {
+        shouldMerge: decision.shouldMerge,
+        mode: decision.mode,
+        target: decision.target,
+        sources: decision.sources,
+        rationale: decision.rationale,
+        confidence: decision.confidence,
+        a_summary: decision.aSummary,
+        b_summary: decision.bSummary,
+    };
+}
+export function buildRound1Prompt(candidate, cards) {
+    void cards;
+    return [
+        '你是技能合并决策 agent。第 1 轮只做判断，不要写文件、不要修改任何源目录。',
+        '',
+        '在当前工作目录下用 merge_stage 的 list/read 完整阅读两个源技能：',
+        '- A: ' + sourcePath(candidate.a) + '（name=' + candidate.a + '）',
+        '- B: ' + sourcePath(candidate.b) + '（name=' + candidate.b + '）',
+        '包含 SKILL.md 与 references/templates/scripts 等支撑文件。',
+        '',
+        '判断规则：',
+        '1) 两者是否语义等价/互补到值得合并，而不是词面相似；',
+        '2) 合并后是否更容易发现和使用，而不是变成更大的巨技能；',
+        '3) 若合并会破坏触发面/生命周期/可发现性，应输出 keep。',
+        '',
+        '只输出一个 JSON（不要 markdown 围栏）：',
+        '{"should_merge":true|false,"mode":"merge-into-existing|create-umbrella|keep","target":"kebab-case","sources":["源技能名"],"rationale":"<=150字","confidence":0.0,"a_summary":"A 的一句话摘要","b_summary":"B 的一句话摘要"}',
+    ].join('\n');
+}
+export function buildRound2Prompt(row, decision, mode = 'continue') {
+    const decisionJson = JSON.stringify(wireDecision(decision));
+    const head = [
+        '现在执行第 2 轮：把两个技能融合成一个完整、可用的技能，直接在当前工作目录的 merged/ 下写文件。',
+        '不要修改 ' + sourcePath(row.a) + ' 或 ' + sourcePath(row.b) + '（只读源副本）；不要访问工作目录以外的路径。',
+        '',
+    ];
+    const body = [
+        '决策结果：' + decisionJson,
+        '目标技能名：' + decision.target,
+        '',
+        '工作方式：',
+        '- 用 merge_stage 的 list/read/write/copy 创建 ' + mergedPath(decision.target) + '/SKILL.md 与需要的 references/templates/scripts；',
+        '- 可以复制源文件作为草稿基础，然后逐段修改；可以多轮读写；',
+        '- 保留两源独特内容，不编造事实，不留下 TODO/占位符；',
+        '- SKILL.md 以合法 YAML frontmatter 开头，name 等于目标名，description 不超过 60 字符；',
+        '- 正文与支撑文件的引用必须成对，路径只允许 references/templates/scripts/assets 下的相对路径。',
+        '',
+        '完成后只输出一个 JSON（不要 markdown 围栏）：',
+        '{"target":"' + decision.target + '","files":["SKILL.md","references/..."],"changelog":["一条变更"],"notes":"可选的一句话"}',
+    ];
+    return (mode === 'fresh' ? ['基于已持久化的 decision。', ...head, ...body] : [...head, ...body]).join('\n');
+}
+export function buildStandbyPrompt() { return STANDBY_PROMPT; }
+//# sourceMappingURL=prompts.js.map

package/lib/types/read-commands.js

@@ -0,0 +1,32 @@
+import { loadMergeState } from "./state.js";
+import { formatQueue, formatStatus } from "./status.js";
+import { mergeUsage } from "./commands.js";
+export async function handleReadOnlyMergeCommand(command, io, home) {
+    if (command.verb === 'status') {
+        const loaded = await loadMergeState(io, home);
+        if (command.id !== undefined) {
+            const row = loaded.state.rows.find(item => item.id === command.id);
+            return row === undefined ? 'merge row not found: ' + command.id : formatStatus([row]);
+        }
+        return formatStatus(loaded.state.rows);
+    }
+    if (command.verb === 'pending') {
+        const loaded = await loadMergeState(io, home);
+        const rows = command.expired === true ? loaded.state.rows.filter(row => row.expired !== undefined) : loaded.state.rows;
+        return command.expired === true ? formatStatus(rows) : formatQueue(rows, 'pending');
+    }
+    if (command.verb === 'candidates') {
+        const loaded = await loadMergeState(io, home);
+        const rows = command.retry === true ? loaded.state.rows.filter(row => row.state === 'approved') : loaded.state.rows;
+        return formatQueue(rows, command.retry === true ? 'fuse' : 'verify');
+    }
+    if (command.verb === 'skipped') {
+        const loaded = await loadMergeState(io, home);
+        return formatQueue(loaded.state.rows, 'skipped');
+    }
+    return null;
+}
+export function mergeCommandHelp() {
+    return mergeUsage();
+}
+//# sourceMappingURL=read-commands.js.map

package/lib/types/report.js

@@ -0,0 +1,70 @@
+/**
+ * Merge run report: JSON is the machine source, Markdown is the human digest.
+ *
+ * Reports are written before registry.settle, so a settled run's resultRef is readable.
+ * readMergeReport uses the three-state probe: absent is not "no pairs", unknown is not empty.
+ */
+import { join } from 'node:path';
+import { isPresent, probePresent, probeText, probeUnknown, } from '@lmzhen/dsh-evolution-core';
+export function mergeReportPath(home, runId) {
+    return join(home, 'reports', 'merge-' + runId + '.json');
+}
+export function mergeReportDigestPath(home, runId) {
+    return join(home, 'reports', 'merge-' + runId + '.md');
+}
+function isReport(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const report = value;
+    return report.schemaVersion === 2
+        && report.kind === 'merge'
+        && typeof report.runId === 'string'
+        && typeof report.command === 'string'
+        && typeof report.startedAt === 'number'
+        && typeof report.endedAt === 'number'
+        && Array.isArray(report.pairs)
+        && typeof report.totals === 'object'
+        && Array.isArray(report.notes);
+}
+function digest(report) {
+    const lines = [];
+    lines.push('# merge ' + report.runId);
+    lines.push('');
+    lines.push('- command: ' + report.command);
+    lines.push('- stop: ' + report.stopReason);
+    lines.push('- pairs: ' + String(report.pairs.length));
+    lines.push('- totals: merged ' + String(report.totals.merged) + ', kept ' + String(report.totals.kept) + ', pending ' + String(report.totals.pending) + ', failed ' + String(report.totals.failed));
+    for (const pair of report.pairs) {
+        lines.push('- ' + pair.a + ' + ' + pair.b + ' -> ' + pair.outcome + (pair.target === undefined ? '' : ' (' + pair.target.actual + ')'));
+    }
+    if (report.remaining !== undefined && report.remaining.length > 0) {
+        lines.push('');
+        lines.push('- remaining: ' + report.remaining.map(item => item.pairKey).join(', '));
+    }
+    return lines.join('\n') + '\n';
+}
+/** Write JSON first, then the digest; returns the JSON path (the registry resultRef). */
+export async function writeMergeReport(io, home, report) {
+    const path = mergeReportPath(home, report.runId);
+    await io.writeText(path, JSON.stringify(report, null, 2) + '\n');
+    await io.writeText(mergeReportDigestPath(home, report.runId), digest(report));
+    return path;
+}
+export async function readMergeReport(io, home, runId) {
+    const probe = await probeText(io, mergeReportPath(home, runId));
+    if (!isPresent(probe))
+        return probe;
+    try {
+        const parsed = JSON.parse(probe.value);
+        return isReport(parsed) ? probePresent(parsed) : probeUnknown('merge report has an unexpected shape');
+    }
+    catch (error) {
+        return probeUnknown('merge report is not JSON: ' + (error instanceof Error ? error.message : String(error)));
+    }
+}
+/** Pairs this run actually merged (for merge undo / reports). */
+export async function committedPairs(io, home, runId) {
+    const probe = await readMergeReport(io, home, runId);
+    return isPresent(probe) ? probe.value.pairs.filter(pair => pair.outcome === 'merged') : [];
+}
+//# sourceMappingURL=report.js.map

package/lib/types/resume-command.js

@@ -0,0 +1,57 @@
+import { loadMergeState } from "./state.js";
+import { runScanCommand } from "./scan-command.js";
+import { withMergeRun } from "./run-shell.js";
+import { recordRound2Outcome } from "./round2-outcome.js";
+export async function runResumeCommand(options) {
+    const loaded = await loadMergeState(options.io, options.home);
+    const row = loaded.state.rows.find(item => item.id === options.rowId);
+    if (row === undefined)
+        return { ok: false, message: 'merge row not found: ' + options.rowId };
+    if (row.state === 'verify') {
+        return await runScanCommand({
+            io: options.io, home: options.home, registry: options.registry,
+            approval: true, platformWrite: options.platformWrite, now: options.now,
+            ...(options.makePorts === undefined
+                ? { ports: { ...options.ports, screening: () => Promise.resolve([{ a: row.a, b: row.b }]) } }
+                : {
+                    makePorts: (runId) => {
+                        const makePorts = options.makePorts;
+                        if (makePorts === undefined)
+                            throw new Error('resume makePorts disappeared');
+                        return { ...makePorts(runId), screening: () => Promise.resolve([{ a: row.a, b: row.b }]) };
+                    },
+                }),
+            ...(options.timeoutMinutes === undefined ? {} : { timeoutMinutes: options.timeoutMinutes }),
+        });
+    }
+    if (row.state !== 'fuse' && row.state !== 'approved')
+        return { ok: false, message: 'row is not resumable from state ' + row.state };
+    const decision = row.decision;
+    if (decision === undefined)
+        return { ok: false, message: 'fuse row has no decision' };
+    return await withMergeRun({
+        io: options.io, home: options.home, registry: options.registry,
+        command: 'resume', approval: { platformWrite: options.platformWrite, mergeApproval: true }, now: options.now,
+        async body(ctx) {
+            await ctx.stage('author', { done: 0, total: 1 });
+            let outcome;
+            try {
+                outcome = options.round2WithRun === undefined
+                    ? await options.ports.round2(row, decision, ctx.signal)
+                    : await options.round2WithRun(row, decision, ctx.signal, ctx.runId);
+            }
+            catch (error) {
+                outcome = { kind: 'failed', failure: { stage: 'author', code: 'merge-failed', message: error instanceof Error ? error.message : String(error), retryable: true, retryFrom: 'agent2' } };
+            }
+            const record = await recordRound2Outcome(options.io, options.home, options.now, row, outcome);
+            return {
+                stopReason: record.merged ? 'completed' : 'failed',
+                scope: { candidatePairs: 1, queueBefore: { verify: 0, pending: 0, fuse: 1, skipped: 0 } },
+                pairs: [record.pair],
+                totals: record.merged ? { merged: 1, kept: 0, pending: 0, failed: 0 } : { merged: 0, kept: 0, pending: 0, failed: 1 },
+                notes: [],
+            };
+        },
+    });
+}
+//# sourceMappingURL=resume-command.js.map

package/lib/types/round2-outcome.js

@@ -0,0 +1,50 @@
+import { transition } from "./coordinator.js";
+import { dropRow, upsertRow } from "./state.js";
+import { recordPair } from "./domain/pair-index-store.js";
+export async function recordRound2Outcome(io, home, now, row, outcome) {
+    const at = new Date(now()).toISOString();
+    if (outcome.kind === 'merged') {
+        const success = transition(row, { type: 'round2-success', at });
+        if (success.ok) {
+            await dropRow(io, home, now, row.id);
+            const target = outcome.target?.actual ?? outcome.target?.requested ?? row.decision?.target;
+            await recordPair(io, home, {
+                pairKey: row.pairKey,
+                runId: row.runId ?? 'merge',
+                result: 'merged',
+                ...(target === undefined ? {} : { target }),
+                ...(outcome.unitId === undefined ? {} : { reportRef: outcome.unitId }),
+            });
+        }
+        return {
+            merged: true,
+            pair: {
+                id: row.id, pairKey: row.pairKey, a: row.a, b: row.b, queue: row.queue,
+                ...(row.decision === undefined ? {} : { decision: row.decision }),
+                outcome: 'merged', archived: outcome.archived ?? [],
+                ...(outcome.unitId === undefined ? {} : { unitId: outcome.unitId }),
+                ...(outcome.target === undefined ? {} : { target: outcome.target }),
+            },
+        };
+    }
+    const failure = outcome.failure ?? { stage: 'author', code: 'merge-failed', message: 'round2 failed', retryable: true, retryFrom: 'agent2' };
+    const next = transition(row, { type: 'round2-fail', failure, at });
+    if (next.ok && next.row !== null) {
+        await upsertRow(io, home, now, next.row);
+        await recordPair(io, home, {
+            pairKey: row.pairKey,
+            runId: row.runId ?? 'merge',
+            result: 'failed',
+            ...(row.decision?.target === undefined ? {} : { target: row.decision.target }),
+        });
+    }
+    return {
+        merged: false,
+        pair: {
+            id: row.id, pairKey: row.pairKey, a: row.a, b: row.b, queue: row.queue,
+            ...(row.decision === undefined ? {} : { decision: row.decision }),
+            outcome: 'failed', archived: [], failure,
+        },
+    };
+}
+//# sourceMappingURL=round2-outcome.js.map

package/lib/types/routes.d.ts

@@ -25,13 +25,16 @@ export interface MergeRowView {
         readonly retryable: boolean;
     };
     readonly attempts?: number;
-    readonly origin?: 'agent' | 'human';
+    readonly origin?: 'agent' | 'human' | 'system';
     readonly stagingExpiresAt?: number;
+    readonly expired?: 'target-taken' | 'source-changed';
+    readonly reason?: string;
+    readonly summary?: readonly string[];
     readonly actions: readonly string[];
 }
 export declare function toRowView(row: MergeRow): MergeRowView;
 export interface MergeView {
-    readonly schemaVersion: 1;
+    readonly schemaVersion: 2;
     readonly counts: MergeCounts;
     readonly tabs: readonly {
         readonly queue: MergeQueue;