@lmzhen/dsh-evolution-merge 0.30.1 → 0.30.3

package/lib/types/commit-execute.js

@@ -2,11 +2,18 @@ import { assembleStagedCommit } from "./commit-assembly.js";
 import { writeCommitReceipt } from "./commit-receipt.js";
 import { pairKey } from "./contracts.js";
 import { writeJournal } from "./domain/commit-journal-store.js";
+import { writeCommitSnapshot } from "./commit-snapshot.js";
 export async function commitStagedRun(io, home, runId, port, options) {
     const assembled = await assembleStagedCommit(io, home, runId, port, { origin: options.origin, summary: options.summary });
     if (!assembled.ok)
         return { ok: false, message: assembled.message };
-    const journal = { runId, target: assembled.plan.target, create: !assembled.plan.targetExists, sources: assembled.plan.sources, phase: 'prepared', updatedAt: new Date(options.now()).toISOString() };
+    try {
+        await writeCommitSnapshot(io, home, runId, assembled.plan, options.now(), port);
+    }
+    catch (error) {
+        return { ok: false, message: 'commit snapshot failed; refusing to write: ' + (error instanceof Error ? error.message : String(error)), plan: assembled.plan };
+    }
+    const journal = { runId, target: assembled.plan.target, create: !assembled.plan.targetExists, sources: assembled.plan.sources, phase: 'sources-archived', updatedAt: new Date(options.now()).toISOString() };
     try {
         await writeJournal(io, home, journal);
     }
@@ -19,6 +26,11 @@ export async function commitStagedRun(io, home, runId, port, options) {
         catch { }
         return { ok: false, message: result.message, plan: assembled.plan };
     }
+    const committed = { ...journal, phase: 'committed', updatedAt: new Date(options.now()).toISOString() };
+    try {
+        await writeJournal(io, home, committed);
+    }
+    catch { }
     if (result.unitId === undefined)
         return { ok: true, plan: assembled.plan, result, warning: 'commit landed without a unitId; receipt not written' };
     const receipt = {
@@ -34,10 +46,6 @@ export async function commitStagedRun(io, home, runId, port, options) {
     };
     try {
         await writeCommitReceipt(io, home, receipt);
-        try {
-            await writeJournal(io, home, { ...journal, unitId: result.unitId, phase: 'committed', updatedAt: new Date(options.now()).toISOString() });
-        }
-        catch { }
         return { ok: true, plan: assembled.plan, result, receipt };
     }
     catch (error) {

package/lib/types/commit-recovery.d.ts

@@ -0,0 +1,10 @@
+import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
+import type { CommitJournal } from './domain/commit-journal.ts';
+export interface CommitRecoveryReport {
+    readonly runId: string;
+    readonly phase: CommitJournal['phase'];
+    readonly action: string;
+    readonly ok: boolean;
+}
+export declare function recoverCommitJournals(io: EvolutionIoLike, home: string, now: number, skillRoot: string, restoreSource?: (name: string) => Promise<boolean>): Promise<readonly CommitRecoveryReport[]>;
+//# sourceMappingURL=commit-recovery.d.ts.map

package/lib/types/commit-recovery.js

@@ -0,0 +1,84 @@
+/** Startup replay for non-terminal commit journals. */
+import { join } from 'node:path';
+import { recoveryFor } from "./domain/commit-journal.js";
+import { writeJournal } from "./domain/commit-journal-store.js";
+import { readCommitSnapshot, skillBodyPath, skillFilePath } from "./commit-snapshot.js";
+export async function recoverCommitJournals(io, home, now, skillRoot, restoreSource) {
+    const dir = join(home, 'merge', 'journals');
+    if (!(await io.exists(dir)))
+        return [];
+    const files = (await io.list(dir)).filter(name => name.endsWith('.json'));
+    const reports = [];
+    for (const file of files) {
+        let journal;
+        try {
+            journal = JSON.parse(await io.readText(join(dir, file)) ?? '');
+        }
+        catch {
+            continue;
+        }
+        const recovery = recoveryFor(journal);
+        if (recovery === 'none')
+            continue;
+        const snapshot = await readCommitSnapshot(io, home, journal.runId);
+        let action = 'report-only';
+        let ok = true;
+        if (recovery === 'retry-commit') {
+            action = 'no-host-write';
+        }
+        else if (snapshot === null) {
+            action = 'snapshot-missing';
+            ok = false;
+        }
+        else {
+            try {
+                if (recovery === 'rollback-sources') {
+                    let restoredArchived = restoreSource !== undefined;
+                    if (restoreSource !== undefined) {
+                        for (const source of snapshot.sourceBodies) {
+                            if (!(await restoreSource(source.name)))
+                                restoredArchived = false;
+                        }
+                    }
+                    if (!restoredArchived) {
+                        for (const source of snapshot.sourceBodies)
+                            await io.writeText(skillBodyPath(skillRoot, source.name), source.body);
+                    }
+                }
+                if (snapshot.create && snapshot.targetBody === null) {
+                    try {
+                        await io.remove(skillBodyPath(skillRoot, snapshot.target));
+                    }
+                    catch { /* already gone */ }
+                }
+                else if (snapshot.targetBody !== null) {
+                    await io.writeText(skillBodyPath(skillRoot, snapshot.target), snapshot.targetBody);
+                }
+                const oldPaths = new Set((snapshot.targetSupport ?? []).map(file => file.path));
+                for (const file of snapshot.targetSupport ?? []) {
+                    await io.writeText(skillFilePath(skillRoot, snapshot.target, file.path), file.content);
+                }
+                for (const file of snapshot.targetSupportAfter ?? []) {
+                    if (!oldPaths.has(file.path)) {
+                        try {
+                            await io.remove(skillFilePath(skillRoot, snapshot.target, file.path));
+                        }
+                        catch { /* already gone */ }
+                    }
+                }
+                for (const file of snapshot.sourceSupport ?? [])
+                    await io.writeText(skillFilePath(skillRoot, file.name, file.path), file.content);
+                action = recovery === 'rollback-sources' ? 'restored-sources-and-target' : 'restored-target';
+            }
+            catch (error) {
+                action = 'restore-failed: ' + (error instanceof Error ? error.message : String(error));
+                ok = false;
+            }
+        }
+        await writeJournal(io, home, { ...journal, phase: ok ? 'rolled-back' : 'failed', updatedAt: new Date(now).toISOString() });
+        reports.push({ runId: journal.runId, phase: journal.phase, action, ok });
+    }
+    await io.writeText(join(home, 'merge', 'recovery.json'), JSON.stringify(reports, null, 2));
+    return reports;
+}
+//# sourceMappingURL=commit-recovery.js.map

package/lib/types/commit-snapshot.d.ts

@@ -0,0 +1,38 @@
+import type { CommitMergePlan, EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
+export interface CommitSnapshot {
+    readonly runId: string;
+    readonly target: string;
+    readonly create: boolean;
+    readonly sources: readonly string[];
+    readonly targetBody: string | null;
+    readonly sourceBodies: readonly {
+        readonly name: string;
+        readonly body: string;
+    }[];
+    readonly targetSupport?: readonly {
+        readonly path: string;
+        readonly content: string;
+    }[];
+    readonly targetSupportAfter?: readonly {
+        readonly path: string;
+        readonly content: string;
+    }[];
+    readonly sourceSupport?: readonly {
+        readonly name: string;
+        readonly path: string;
+        readonly content: string;
+    }[];
+    readonly at: string;
+}
+export declare function snapshotPath(home: string, runId: string): string;
+export declare function writeCommitSnapshot(io: EvolutionIoLike, home: string, runId: string, plan: CommitMergePlan, now: number, port?: {
+    readSupportFiles?(name: string): Promise<readonly {
+        readonly path: string;
+        readonly content: string;
+    }[]>;
+}): Promise<CommitSnapshot>;
+export declare function readCommitSnapshot(io: EvolutionIoLike, home: string, runId: string): Promise<CommitSnapshot | null>;
+export declare function isSafeSkillName(name: string): boolean;
+export declare function skillFilePath(root: string, name: string, path: string): string;
+export declare function skillBodyPath(root: string, name: string): string;
+//# sourceMappingURL=commit-snapshot.d.ts.map

package/lib/types/commit-snapshot.js

@@ -0,0 +1,65 @@
+/** Pre-commit snapshot: enough to restore the target and archived sources after a crash. */
+import { join, resolve, sep } from 'node:path';
+export function snapshotPath(home, runId) {
+    return join(home, 'merge', 'snapshots', runId.replace(/[^A-Za-z0-9_-]+/g, '_') + '.json');
+}
+export async function writeCommitSnapshot(io, home, runId, plan, now, port) {
+    if (!isSafeSkillName(plan.target) || plan.sources.some(name => !isSafeSkillName(name))) {
+        throw new Error('unsafe skill name in commit plan: ' + plan.target);
+    }
+    const readSupport = port?.readSupportFiles === undefined
+        ? undefined
+        : (name) => port.readSupportFiles?.(name) ?? Promise.resolve([]);
+    const targetSupport = readSupport === undefined || !plan.targetExists ? [] : await readSupport(plan.target);
+    const sourceSupport = [];
+    if (readSupport !== undefined) {
+        for (const name of plan.sources) {
+            for (const file of await readSupport(name))
+                sourceSupport.push({ name, path: file.path, content: file.content });
+        }
+    }
+    const snapshot = {
+        runId, target: plan.target, create: !plan.targetExists, sources: plan.sources,
+        targetBody: plan.expectedTargetBody,
+        sourceBodies: plan.expectedSourceBodies.map(item => ({ name: item.name, body: item.body })),
+        ...(targetSupport.length === 0 ? {} : { targetSupport }),
+        ...(plan.supportFiles.length === 0 ? {} : { targetSupportAfter: plan.supportFiles }),
+        ...(sourceSupport.length === 0 ? {} : { sourceSupport }),
+        at: new Date(now).toISOString(),
+    };
+    await io.writeText(snapshotPath(home, runId), JSON.stringify(snapshot, null, 2));
+    return snapshot;
+}
+export async function readCommitSnapshot(io, home, runId) {
+    const raw = await io.readText(snapshotPath(home, runId));
+    if (raw === null)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function isSafeSkillName(name) {
+    return /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name) && name !== '.' && name !== '..';
+}
+export function skillFilePath(root, name, path) {
+    if (!isSafeSkillName(name) || path.startsWith('/') || path.includes('..'))
+        throw new Error('unsafe skill file: ' + name + '/' + path);
+    const base = resolve(root, name);
+    const file = resolve(base, path);
+    if (!file.startsWith(base + sep))
+        throw new Error('skill file escapes skill: ' + name + '/' + path);
+    return file;
+}
+export function skillBodyPath(root, name) {
+    if (!isSafeSkillName(name))
+        throw new Error('unsafe skill name: ' + name);
+    const base = resolve(root);
+    const path = resolve(base, name, 'SKILL.md');
+    if (!path.startsWith(base + sep))
+        throw new Error('skill path escapes root: ' + name);
+    return path;
+}
+//# sourceMappingURL=commit-snapshot.js.map

package/lib/types/coordinator.d.ts

@@ -20,6 +20,8 @@ export type MergeEvent = {
     readonly decision?: MergeDecision;
     readonly stagingRef?: string;
     readonly stagingExpiresAt?: number;
+    readonly sourceRevision?: string;
+    readonly targetRevision?: string;
     readonly at: string;
 } | {
     readonly type: 'round1-fail';
@@ -49,6 +51,12 @@ export type MergeEvent = {
 } | {
     readonly type: 'source-gone';
     readonly at: string;
+} | {
+    readonly type: 'target-taken';
+    readonly at: string;
+} | {
+    readonly type: 'source-changed';
+    readonly at: string;
 } | {
     readonly type: 'gate-keep';
     readonly a: string;

package/lib/types/coordinator.js

@@ -98,8 +98,8 @@ export function transition(current, event) {
             if (current.state !== 'verify')
                 return invalid(event, current.state);
             return event.approval === 'on'
-                ? next(current, event.at, 'pending', { ...(event.decision === undefined ? {} : { decision: event.decision }), ...(event.stagingRef === undefined ? {} : { stagingRef: event.stagingRef }), ...(event.stagingExpiresAt === undefined ? {} : { stagingExpiresAt: event.stagingExpiresAt }) })
-                : next(current, event.at, 'approved', { ...(event.decision === undefined ? {} : { decision: event.decision }), ...(event.stagingRef === undefined ? {} : { stagingRef: event.stagingRef }), ...(event.stagingExpiresAt === undefined ? {} : { stagingExpiresAt: event.stagingExpiresAt }) });
+                ? next(current, event.at, 'pending', { ...(event.decision === undefined ? {} : { decision: event.decision }), ...(event.stagingRef === undefined ? {} : { stagingRef: event.stagingRef }), ...(event.stagingExpiresAt === undefined ? {} : { stagingExpiresAt: event.stagingExpiresAt }), ...(event.sourceRevision === undefined ? {} : { sourceRevision: event.sourceRevision }), ...(event.targetRevision === undefined ? {} : { targetRevision: event.targetRevision }) })
+                : next(current, event.at, 'approved', { ...(event.decision === undefined ? {} : { decision: event.decision }), ...(event.stagingRef === undefined ? {} : { stagingRef: event.stagingRef }), ...(event.stagingExpiresAt === undefined ? {} : { stagingExpiresAt: event.stagingExpiresAt }), ...(event.sourceRevision === undefined ? {} : { sourceRevision: event.sourceRevision }), ...(event.targetRevision === undefined ? {} : { targetRevision: event.targetRevision }) });
         case 'round1-fail':
             return current.state === 'verify'
                 ? next(current, event.at, 'verify', { failure: event.failure, attempts: (current.attempts ?? 0) + 1 })
@@ -122,6 +122,11 @@ export function transition(current, event) {
             return current.state === 'fuse' || current.state === 'approved'
                 ? { ok: true, row: null }
                 : invalid(event, current.state);
+        case 'target-taken':
+        case 'source-changed':
+            return current.state === 'pending' || current.state === 'approved' || current.state === 'fuse'
+                ? next(current, event.at, current.state, { expired: event.type })
+                : invalid(event, current.state);
         case 'restore':
             return current.state === 'skipped'
                 ? next(current, event.at, 'verify')

package/lib/types/decision.js

@@ -37,8 +37,11 @@ export function parseDecision(text, pair) {
     const target = typeof record.target === 'string' ? record.target.trim() : '';
     const sources = Array.isArray(record.sources) ? record.sources.filter((item) => typeof item === 'string').map(item => item.trim()).filter(Boolean) : [];
     const rationale = typeof record.rationale === 'string' ? record.rationale.trim() : '';
+    const aSummary = typeof record.aSummary === 'string' ? record.aSummary.trim() : typeof record.a_summary === 'string' ? record.a_summary.trim() : '';
+    const bSummary = typeof record.bSummary === 'string' ? record.bSummary.trim() : typeof record.b_summary === 'string' ? record.b_summary.trim() : '';
+    const summaries = { ...(aSummary === '' ? {} : { aSummary }), ...(bSummary === '' ? {} : { bSummary }) };
     if (!shouldMerge || mode === 'keep') {
-        return { ok: true, decision: { shouldMerge: false, mode: 'keep', target, sources, rationale } };
+        return { ok: true, decision: { shouldMerge: false, mode: 'keep', target, sources, rationale, ...summaries } };
     }
     if (target === '')
         return { ok: false, code: 'decision-invalid', message: 'merge decision needs target' };
@@ -54,6 +57,7 @@ export function parseDecision(text, pair) {
             target,
             sources,
             rationale,
+            ...summaries,
             ...(typeof record.confidence === 'number' ? { confidence: record.confidence } : {}),
         },
     };

package/lib/types/index.js

@@ -4,10 +4,11 @@ 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 { authorityFrom, createSubagentChannel, DEFAULT_SKILL_LIMITS, evolutionHome, evolutionIoAdapter, newRunRegistry, newSkillLibrary, policyStageLimits, skillsRoot } 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 { recoverCommitJournals } from "./commit-recovery.js";
 import { readCommitReceipts } from "./commit-receipt.js";
 import { transition } from "./coordinator.js";
 import { makeMergeRoutes } from "./merge-routes.js";
@@ -137,6 +138,11 @@ export function apply(ctx, rawConfig = {}) {
             io, ctx, authority: authorityFrom({ origin: 'subagent' }),
             limits: { ...DEFAULT_SKILL_LIMITS, ...policyStageLimits(policySnapshot?.get?.()) },
         });
+        void recoverCommitJournals(io, home, Date.now(), skillsRoot(), async (name) => {
+            const result = await skills.restoreFromArchive(name);
+            return result.ok;
+        }).then((reports) => { if (reports.length > 0)
+            ctx.logger.info('merge commit recovery: ' + reports.map(report => report.runId + '=' + report.action).join(', ')); }).catch((error) => { ctx.logger.warn('merge commit recovery failed: ' + (error instanceof Error ? error.message : String(error))); });
         const channel = subagentChannelAdapter(createSubagentChannel(ctx));
         const stage = new StageToolRegistry();
         const engineConfig = engineConfigFromEnv(params.mergeModelsRoot);
@@ -216,7 +222,7 @@ export function apply(ctx, rawConfig = {}) {
                     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 };
+                    return { name: item.name, description: item.description, body: item.content ?? '', files, protectedBy: item.protectedBy, protectionUnknown: item.protectionUnknown, managed: item.managed };
                 }));
             },
             screeningForRun: engineScreening,

package/lib/types/presentation-budget.d.ts

@@ -0,0 +1,3 @@
+/** Tool-result budget: keep the head and tail, mark what was omitted. */
+export declare function fitToolText(text: string, max?: number): string;
+//# sourceMappingURL=presentation-budget.d.ts.map

package/lib/types/presentation-budget.js

@@ -0,0 +1,11 @@
+/** Tool-result budget: keep the head and tail, mark what was omitted. */
+export function fitToolText(text, max = 8000) {
+    if (text.length <= max)
+        return text;
+    const marker = '\n... [truncated ' + String(text.length - max) + ' chars] ...\n';
+    const keep = Math.max(0, max - marker.length);
+    const head = Math.ceil(keep * 0.7);
+    const tail = keep - head;
+    return text.slice(0, head) + marker + (tail === 0 ? '' : text.slice(-tail));
+}
+//# sourceMappingURL=presentation-budget.js.map

package/lib/types/revision.d.ts

@@ -0,0 +1,4 @@
+import type { SkillCard } from './skill-card.ts';
+/** Stable source revision for a pair: names sorted, body hashed in that order. */
+export declare function sourceRevisionOf(cards: readonly SkillCard[], a: string, b: string): string | undefined;
+//# sourceMappingURL=revision.d.ts.map

package/lib/types/revision.js

@@ -0,0 +1,12 @@
+import { contentHash } from '@lmzhen/dsh-evolution-core';
+/** Stable source revision for a pair: names sorted, body hashed in that order. */
+export function sourceRevisionOf(cards, a, b) {
+    const byName = new Map(cards.map(card => [card.name, card]));
+    const names = [a, b].sort();
+    const first = byName.get(names[0] ?? '');
+    const second = byName.get(names[1] ?? '');
+    if (first === undefined || second === undefined)
+        return undefined;
+    return contentHash(first.name + '\u0000' + first.body + '\u0000' + second.name + '\u0000' + second.body);
+}
+//# sourceMappingURL=revision.js.map

package/lib/types/routes.d.ts

@@ -18,6 +18,9 @@ export interface MergeRowView {
     readonly createdAt: string;
     readonly target?: string;
     readonly confidence?: number;
+    readonly aSummary?: string;
+    readonly bSummary?: string;
+    readonly rationale?: string;
     readonly failure?: {
         readonly stage: string;
         readonly code: string;

package/lib/types/routes.js

@@ -14,6 +14,9 @@ export function toRowView(row) {
         createdAt: row.createdAt,
         ...(row.decision?.target === undefined ? {} : { target: row.decision.target }),
         ...(row.decision?.confidence === undefined ? {} : { confidence: row.decision.confidence }),
+        ...(row.decision?.aSummary === undefined ? {} : { aSummary: row.decision.aSummary }),
+        ...(row.decision?.bSummary === undefined ? {} : { bSummary: row.decision.bSummary }),
+        ...(row.decision?.rationale === undefined ? {} : { rationale: row.decision.rationale }),
         ...(row.failure === undefined ? {} : {
             failure: { stage: row.failure.stage, code: row.failure.code, message: row.failure.message, retryable: row.failure.retryable },
         }),
@@ -23,9 +26,9 @@ export function toRowView(row) {
         ...(row.expired === undefined ? {} : { expired: row.expired }),
         ...(row.reason === undefined ? {} : { reason: row.reason }),
         summary: [
-            row.a + ' + ' + row.b,
-            row.decision?.rationale ?? row.reason ?? '',
-            row.failure?.message ?? '',
+            row.decision?.aSummary ?? '未提供技能1摘要',
+            row.decision?.bSummary ?? '未提供技能2摘要',
+            row.decision?.rationale ?? row.reason ?? '未提供融合原因',
         ],
         actions: row.state === 'pending'
             ? ['/evolution merge approve ' + row.id, '/evolution merge reject ' + row.id]

package/lib/types/runtime.js

@@ -21,6 +21,13 @@ import { mergeDoctor } from "./doctor.js";
 import { createChannelScanPorts } from "./scan-ports.js";
 import { createNewChildRound2 } from "./new-child-authoring.js";
 import { skillLibraryPort } from "./adapters/library.js";
+import { fitToolText } from "./presentation-budget.js";
+import { sourceRevisionOf } from "./revision.js";
+function forcedDecisionFor(a, b) {
+    const sorted = [a, b].sort();
+    const target = ('merge-' + sorted.join('-')).replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 64);
+    return { shouldMerge: true, mode: 'create-umbrella', target, sources: [a, b], rationale: 'forced pair merge of ' + sorted.join(' and ') };
+}
 export function createMergeRuntime(deps) {
     const readOnly = createReadOnlyMergeService(deps.io, deps.home);
     const timeout = deps.timeoutMinutes > 0 ? deps.timeoutMinutes : undefined;
@@ -41,16 +48,21 @@ export function createMergeRuntime(deps) {
             if (command.verb === 'pair') {
                 const signal = new AbortController().signal;
                 const cards = await deps.cards(signal);
+                const cardA = cards.find(card => card.name === command.a);
+                const cardB = cards.find(card => card.name === command.b);
+                if (cardA === undefined || cardB === undefined || cardA.managed !== true || cardB.managed !== true) {
+                    return { ok: false, text: 'merge pair 仅支持 family-managed 技能: ' + command.a + ' / ' + command.b };
+                }
                 const pair = [{ a: command.a, b: command.b }];
-                let forced;
-                if (command.force === true) {
-                    const key = pairKey(command.a, command.b);
-                    forced = (await loadMergeState(deps.io, deps.home)).state.rows.find(row => row.pairKey === key);
-                    if (forced === undefined || forced.decision === undefined) {
-                        return { ok: false, text: 'pair --force 需要已有决策，找不到该 pair 的 decision: ' + key };
-                    }
+                const existing = (await loadMergeState(deps.io, deps.home)).state.rows.find(row => row.pairKey === pairKey(command.a, command.b));
+                if (existing?.state === 'pending') {
+                    return { ok: false, text: '该 pair 已在待批准队列，先 approve/reject/discard: ' + existing.id };
+                }
+                if (existing?.state === 'approved' || existing?.state === 'fuse') {
+                    return { ok: false, text: '该 pair 已在待合并队列，用 merge resume --retry 复用: ' + (existing.runId ?? existing.id) };
                 }
-                const approval = command.force === true ? false : deps.params.mergeApproval;
+                const forced = command.force === true ? forcedDecisionFor(command.a, command.b) : undefined;
+                const approval = deps.params.mergeApproval;
                 const result = await runScanCommand({
                     ...common,
                     approval,
@@ -66,7 +78,7 @@ export function createMergeRuntime(deps) {
                             commitPort: skillLibraryPort(deps.skills), now: deps.now,
                             ...stageHooks,
                         });
-                        return forced === undefined ? ports : { ...ports, round1: () => Promise.resolve({ kind: 'merge', decision: forced.decision }) };
+                        return forced === undefined ? ports : { ...ports, round1: () => Promise.resolve({ kind: 'merge', decision: forced }) };
                     },
                 });
                 if (!result.ok)
@@ -80,12 +92,17 @@ export function createMergeRuntime(deps) {
             if (command.verb === 'scan') {
                 const signal = new AbortController().signal;
                 const cards = await deps.cards(signal);
+                const managed = new Set(cards.filter(card => card.managed === true).map(card => card.name));
                 const loadedState = await loadMergeState(deps.io, deps.home);
                 const skipped = skippedPairKeys(loadedState.state.rows, deps.params.mergeSkippedTtlDays, deps.now());
-                const held = new Set(loadedState.state.rows.filter(row => row.queue === 'pending' || !canRetry(row)).map(row => row.pairKey));
+                const held = new Set(loadedState.state.rows.filter(row => row.queue === 'pending' || row.queue === 'fuse' || !canRetry(row)).map(row => row.pairKey));
+                const conflictNotes = loadedState.state.rows
+                    .filter(row => row.state === 'pending' || row.state === 'approved' || row.state === 'fuse' || row.state === 'skipped')
+                    .map(row => 'conflict:' + row.state + ':' + row.pairKey + ':' + row.id);
                 const result = await runScanCommand({
                     ...common,
                     approval: deps.params.mergeApproval,
+                    notes: conflictNotes,
                     ...(detached ? { detached: true } : {}),
                     makePorts: runId => createChannelScanPorts({
                         io: deps.io, home: deps.home, runId, cards,
@@ -93,7 +110,7 @@ export function createMergeRuntime(deps) {
                             const raw = await deps.screeningForRun(cards, runId, turnSignal);
                             const filtered = raw.filter((candidate) => {
                                 const key = pairKey(candidate.a, candidate.b);
-                                return !skipped.has(key) && !held.has(key);
+                                return managed.has(candidate.a) && managed.has(candidate.b) && !skipped.has(key) && !held.has(key);
                             });
                             const candidatePairs = raw.candidatePairs;
                             return candidatePairs === undefined ? filtered : Object.assign(filtered, { candidatePairs });
@@ -153,7 +170,7 @@ export function createMergeRuntime(deps) {
                     return { ok: false, text: 'report is unreadable: ' + run.resultRef + '：' + report.reason };
                 return report.kind === 'absent'
                     ? { ok: false, text: 'report is missing: ' + run.resultRef }
-                    : { ok: true, text: report.value.slice(0, 12000) };
+                    : { ok: true, text: 'report: ' + run.resultRef + '\n' + fitToolText(report.value, 7600) };
             }
             if (command.verb === 'discard') {
                 const loaded = await loadMergeState(deps.io, deps.home);
@@ -239,6 +256,27 @@ export function createMergeRuntime(deps) {
             if (command.verb === 'approve') {
                 const signal = new AbortController().signal;
                 const cards = await deps.cards(signal);
+                const candidate = (await loadMergeState(deps.io, deps.home)).state.rows.find(row => row.id === command.id);
+                if (candidate !== undefined && candidate.state === 'pending' && candidate.decision !== undefined) {
+                    const missingSource = [candidate.a, candidate.b].find(name => !cards.some(card => card.name === name && card.managed === true));
+                    if (missingSource !== undefined) {
+                        await dropRow(deps.io, deps.home, deps.now, candidate.id);
+                        return { ok: false, text: 'source-gone：' + missingSource + ' 已不在 family-managed 技能库，已从 active 队列清除；可 merge skipped --discard 清理' };
+                    }
+                    const currentRevision = sourceRevisionOf(cards, candidate.a, candidate.b);
+                    if (candidate.sourceRevision !== undefined && currentRevision !== undefined && currentRevision !== candidate.sourceRevision) {
+                        const changed = transition(candidate, { type: 'source-changed', at: new Date().toISOString() });
+                        if (changed.ok && changed.row !== null)
+                            await upsertRow(deps.io, deps.home, deps.now, changed.row);
+                        return { ok: false, text: 'source-changed：源技能内容在决策后变化，拒绝照跑；出口：重新 merge pair，或 merge skipped --discard' };
+                    }
+                    if (candidate.decision.mode === 'merge-into-existing' && !cards.some(card => card.name === candidate.decision?.target)) {
+                        const expired = transition(candidate, { type: 'target-taken', at: new Date().toISOString() });
+                        if (expired.ok && expired.row !== null)
+                            await upsertRow(deps.io, deps.home, deps.now, expired.row);
+                        return { ok: false, text: 'target-taken：目标 ' + candidate.decision.target + ' 已不存在，行保留 pending --expired；出口：重新 merge pair，或 merge skipped --discard' };
+                    }
+                }
                 const result = await runApproveCommand({
                     ...common,
                     rowId: command.id,

package/lib/types/scan-command.d.ts

@@ -17,6 +17,7 @@ export interface RunScanCommandOptions {
     readonly timeoutMinutes?: number;
     readonly now: () => number;
     readonly detached?: boolean;
+    readonly notes?: readonly string[];
 }
 export declare function runScanCommand(options: RunScanCommandOptions): Promise<WithMergeRunResult>;
 //# sourceMappingURL=scan-command.d.ts.map

package/lib/types/scan-command.js

@@ -23,6 +23,7 @@ export async function runScanCommand(options) {
                 stage: ctx.stage,
                 startedAt: ctx.startedAt,
                 ...(options.timeoutMinutes === undefined ? {} : { timeoutMinutes: options.timeoutMinutes }),
+                ...(options.notes === undefined ? {} : { notes: options.notes }),
             });
         },
     });

package/lib/types/scan-ports.js

@@ -2,6 +2,7 @@ import { pairKey } from "./contracts.js";
 import { runRound1OverChannel } from "./channel-port.js";
 import { runAuthoring } from "./authoring-flow.js";
 import { dropStaging, ensureStaging, stageKeyOf, stagingRoot } from "./staging.js";
+import { sourceRevisionOf } from "./revision.js";
 export function createChannelScanPorts(options) {
     const sessions = new Map();
     return {
@@ -42,8 +43,12 @@ export function createChannelScanPorts(options) {
                     }
                 }
             }
+            const sourceRevision = result.outcome.kind === 'merge' ? sourceRevisionOf(options.cards, candidate.a, candidate.b) : undefined;
             return result.outcome.kind === 'merge'
-                ? { ...result.outcome, stagingRef: stageKey, stagingExpiresAt: options.now() + 7 * 86_400_000 }
+                ? {
+                    ...result.outcome, stagingRef: stageKey, stagingExpiresAt: options.now() + 7 * 86_400_000,
+                    ...(sourceRevision === undefined ? {} : { sourceRevision }),
+                }
                 : result.outcome;
         },
         async round2(row, decision, signal) {

package/lib/types/scan-run.d.ts

@@ -43,6 +43,7 @@ export interface RunScanOptions {
         done: number;
         total: number;
     }) => Promise<void>;
+    readonly notes?: readonly string[];
 }
 export declare function runScan(options: RunScanOptions): Promise<MergeRunReportDraft>;
 //# sourceMappingURL=scan-run.d.ts.map

package/lib/types/scan-run.js

@@ -65,7 +65,9 @@ export async function runScan(options) {
             if (!created.ok || created.row === null)
                 throw new Error(created.ok ? 'candidate row missing' : created.message);
             row = created.row;
-            await upsertRow(options.io, options.home, options.now, row);
+            const placed = await upsertRow(options.io, options.home, options.now, row, 'verify');
+            if (!placed.ok)
+                throw new Error('pair already in ' + placed.current.state);
         }
         catch (error) {
             totals.failed += 1;
@@ -179,7 +181,7 @@ export async function runScan(options) {
         },
         pairs,
         totals,
-        notes: [],
+        notes: [...(options.notes ?? [])],
         ...(remaining.length === 0 ? {} : { remaining }),
     };
 }

package/lib/types/skill-card.d.ts

@@ -8,5 +8,6 @@ export interface SkillCard {
     }[];
     readonly protectedBy?: string | null;
     readonly protectionUnknown?: boolean;
+    readonly managed?: boolean;
 }
 //# sourceMappingURL=skill-card.d.ts.map

package/lib/types/state.d.ts

@@ -22,7 +22,14 @@ export interface MoveRowPatch {
     readonly origin?: MergeRow['origin'];
     readonly attempts?: number;
 }
-export declare function upsertRow(io: EvolutionIoLike, home: string, now: () => number, row: MergeRow): Promise<void>;
+export type UpsertExpect = 'any' | 'absent' | 'verify' | 'pending' | 'fuse' | 'skipped';
+export type UpsertResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly current: MergeRow;
+};
+export declare function upsertRow(io: EvolutionIoLike, home: string, now: () => number, row: MergeRow, expect?: UpsertExpect): Promise<UpsertResult>;
 export declare function moveRow(io: EvolutionIoLike, home: string, now: () => number, id: string, patch: MoveRowPatch): Promise<MergeRow | undefined>;
 export declare function dropRow(io: EvolutionIoLike, home: string, now: () => number, id: string): Promise<boolean>;
 export declare function rowsOf(io: EvolutionIoLike, home: string, queue?: MergeQueue): Promise<readonly MergeRow[]>;