@lmzhen/dsh-evolution-merge 0.30.16 → 0.30.18

package/lib/types/propose.js

@@ -0,0 +1,69 @@
+const SYSTEM = 'You propose skill pairs that may be merged. Return only a JSON object: {"pairs":[{"a":"skill-a","b":"skill-b","reason":"one sentence"}]}. Use only supplied skill names. Do not decide whether a merge is good.';
+function parsePairs(raw, known, cap) {
+    let value = raw;
+    if (typeof raw === 'string') {
+        try {
+            value = JSON.parse(raw);
+        }
+        catch {
+            return [];
+        }
+    }
+    if (typeof value !== 'object' || value === null)
+        return [];
+    const pairs = value.pairs;
+    if (!Array.isArray(pairs))
+        return [];
+    const out = [];
+    const seen = new Set();
+    for (const item of pairs) {
+        if (out.length >= cap)
+            break;
+        const pair = item;
+        if (typeof pair.a !== 'string' || typeof pair.b !== 'string')
+            continue;
+        const a = pair.a.trim();
+        const b = pair.b.trim();
+        if (a === b || !known.has(a) || !known.has(b))
+            continue;
+        const [first, second] = a < b ? [a, b] : [b, a];
+        const key = first + '\u0000' + second;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push({ a: first, b: second, source: 'proposed', ...(typeof pair.reason === 'string' && pair.reason.trim() !== '' ? { reason: pair.reason.trim() } : {}) });
+    }
+    return out;
+}
+export async function proposePairs(cards, port, options) {
+    const shardSize = Math.max(2, options.shardSize ?? 60);
+    const cap = Math.max(0, options.maxPairs ?? 200);
+    const known = new Set(cards.map(card => card.name));
+    const candidates = [];
+    const degraded = [];
+    let shards = 0;
+    for (let start = 0; start < cards.length && candidates.length < cap; start += shardSize) {
+        const shard = cards.slice(start, start + shardSize);
+        if (shard.length < 2)
+            continue;
+        shards += 1;
+        try {
+            const raw = await port.callJson({
+                system: SYSTEM,
+                user: JSON.stringify(shard.map(card => ({
+                    name: card.name,
+                    description: card.description.slice(0, 400),
+                    body: card.body.slice(0, 600),
+                }))),
+                maxTokens: 1200,
+                signal: options.signal,
+            });
+            candidates.push(...parsePairs(raw, known, cap - candidates.length));
+        }
+        catch (error) {
+            degraded.push('proposal shard failed: ' + (error instanceof Error ? error.message : String(error)));
+        }
+    }
+    return { candidates, shards, degraded };
+}
+//# sourceMappingURL=propose.js.map

package/lib/types/read-commands.d.ts

@@ -2,10 +2,10 @@
  * Read-only command handlers: status/pending/skipped are served from merge-state.
  * Mutating verbs return null so the host shell can route them to the run engine.
  */
-import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
+import type { EvolutionIoLike, RunRecord } from '@lmzhen/dsh-evolution-core';
 import type { MergeCliCommand } from './commands.ts';
 export declare function handleReadOnlyMergeCommand(command: MergeCliCommand, io: EvolutionIoLike, home: string, cards?: readonly {
     readonly name: string;
-}[]): Promise<string | null>;
+}[], runs?: readonly RunRecord[], approval?: boolean): Promise<string | null>;
 export declare function mergeCommandHelp(): string;
 //# sourceMappingURL=read-commands.d.ts.map

package/lib/types/read-commands.js

@@ -1,7 +1,8 @@
+import { buildFacts } from "./facts.js";
 import { loadMergeState } from "./state.js";
-import { formatQueue, formatStatus } from "./status.js";
+import { formatFacts, formatQueue, formatStatus } from "./status.js";
 import { mergeUsage } from "./commands.js";
-export async function handleReadOnlyMergeCommand(command, io, home, cards) {
+export async function handleReadOnlyMergeCommand(command, io, home, cards, runs, approval = false) {
     const withNote = (text, note) => note === undefined ? text : 'note: ' + note + '\n' + text;
     const load = async () => {
         const result = await loadMergeState(io, home);
@@ -15,7 +16,8 @@ export async function handleReadOnlyMergeCommand(command, io, home, cards) {
             const row = loaded.state.rows.find(item => item.id === command.id);
             return withNote(row === undefined ? 'merge row not found: ' + command.id : formatStatus([row]), loaded.note);
         }
-        return withNote(formatStatus(loaded.state.rows), loaded.note);
+        const facts = buildFacts({ rows: loaded.state.rows, runs: runs ?? [], approval, readAt: Date.now(), ...(loaded.note === undefined ? {} : { notes: [loaded.note] }) });
+        return withNote(formatFacts(facts), loaded.note);
     }
     if (command.verb === 'pending') {
         const loaded = await load();

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

@@ -17,6 +17,8 @@ export interface RunResumeCommandOptions {
     readonly round2WithRun?: (row: MergeRow, decision: MergeDecision, signal: AbortSignal, runId: string) => Promise<ScanRound2Outcome>;
     readonly rowId: string;
     readonly platformWrite: boolean;
+    readonly detached?: boolean;
+    readonly pairTimeoutMinutes?: number;
     readonly timeoutMinutes?: number;
     readonly now: () => number;
     readonly isOwnerActive?: (runId: string) => boolean | Promise<boolean>;

package/lib/types/resume-command.js

@@ -14,6 +14,7 @@ export async function runResumeCommand(options) {
         return await runScanCommand({
             io: options.io, home: options.home, registry: options.registry,
             approval: true, platformWrite: options.platformWrite, now: options.now,
+            ...(options.detached === true ? { detached: true } : {}),
             ...(options.makePorts === undefined
                 ? { ports: { ...options.ports, screening: () => Promise.resolve([{ a: row.a, b: row.b }]) } }
                 : {
@@ -36,9 +37,10 @@ export async function runResumeCommand(options) {
     const decision = row.decision;
     if (decision === undefined)
         return { ok: false, message: 'fuse row has no decision' };
-    return await withMergeRun({
+    const result = await withMergeRun({
         io: options.io, home: options.home, registry: options.registry,
         command: 'resume', approval: { platformWrite: options.platformWrite, mergeApproval: true }, now: options.now,
+        ...(options.detached === true ? { detached: true } : {}),
         async body(ctx) {
             await ctx.stage('author', { done: 0, total: 1 });
             let outcome;
@@ -60,5 +62,6 @@ export async function runResumeCommand(options) {
             };
         },
     });
+    return result;
 }
 //# sourceMappingURL=resume-command.js.map

package/lib/types/round2-outcome.js

@@ -1,12 +1,13 @@
-import { transition } from "./coordinator.js";
-import { dropRow, upsertRow } from "./state.js";
+import { v3ToLegacy } from "./domain/row-v3-bridge.js";
+import { dropRowV3, transactRows } 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();
+    void now;
     if (outcome.kind === 'merged') {
-        const success = transition(row, { type: 'round2-success', at });
-        if (success.ok) {
-            await dropRow(io, home, now, row.id);
+        {
+            const dropped = await dropRowV3(io, home, row.id, 'committed', outcome.unitId ?? 'unknown');
+            if (!dropped)
+                return { merged: false, pair: { id: row.id, pairKey: row.pairKey, a: row.a, b: row.b, queue: row.queue, outcome: 'failed', archived: [], failure: { stage: 'commit', code: 'row-changed', message: 'row changed before commit record', retryable: true, retryFrom: 'agent2' } } };
             const target = outcome.target?.actual ?? outcome.target?.requested ?? row.decision?.target;
             await recordPair(io, home, {
                 pairKey: row.pairKey,
@@ -28,9 +29,16 @@ export async function recordRound2Outcome(io, home, now, row, outcome) {
         };
     }
     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);
+    const projected = await transactRows(io, home, tx => {
+        const current = tx.rows().find(item => item.id === row.id);
+        if (current === undefined)
+            return null;
+        const moved = tx.transition(row.id, { type: 'failed', failure }, current.version);
+        return moved.ok && moved.row !== null ? v3ToLegacy(moved.row) : null;
+    });
+    if (projected === null)
+        return { merged: false, pair: { id: row.id, pairKey: row.pairKey, a: row.a, b: row.b, queue: row.queue, outcome: 'failed', archived: [], failure: { ...failure, code: 'row-changed', message: 'row changed before failure record' } } };
+    {
         await recordPair(io, home, {
             pairKey: row.pairKey,
             runId: row.runId ?? 'merge',

package/lib/types/runtime.d.ts

@@ -3,7 +3,7 @@
  * Plugin wiring supplies the channel, model and library; this module keeps the orchestration
  * out of apply() and makes the mutating verbs testable with fakes.
  */
-import { type EvolutionIoLike, type SkillLibrary } from '@lmzhen/dsh-evolution-core';
+import { SkillLibrary, type EvolutionIoLike, type UnitTransaction } from '@lmzhen/dsh-evolution-core';
 import { type MergeCandidate } from './contracts.ts';
 import type { MergeParams } from './params.ts';
 import type { SkillCard } from './skill-card.ts';
@@ -37,6 +37,9 @@ export interface MergeRuntimeDeps {
     /** Run-scoped engine screening. */
     readonly screeningForRun: (cards: readonly SkillCard[], runId: string, signal: AbortSignal) => Promise<readonly MergeCandidate[]>;
     readonly stage?: MergeStageBindingPort;
+    /** G2 transitional: when set, authoring commits through core UnitTransaction. */
+    readonly unit?: UnitTransaction;
 }
+export declare function unitFor(deps: MergeRuntimeDeps): UnitTransaction | undefined;
 export declare function createMergeRuntime(deps: MergeRuntimeDeps): MergeCommandService;
 //# sourceMappingURL=runtime.d.ts.map

package/lib/types/runtime.js

@@ -3,19 +3,22 @@
  * Plugin wiring supplies the channel, model and library; this module keeps the orchestration
  * out of apply() and makes the mutating verbs testable with fakes.
  */
-import { probeText } from '@lmzhen/dsh-evolution-core';
+import { probeText, SkillLibrary, UnitTransactions, skillLibraryUnitBackend } from '@lmzhen/dsh-evolution-core';
+import { targetClaimUnitPort } from "./unit-claim.js";
 import { canRetry, pairKey } from "./contracts.js";
 import { skippedPairKeys } from "./skipped.js";
 import { createReadOnlyMergeService } from "./merge-command.js";
+import { formatRunsView } from "./status.js";
+import { toRunsView } from "./wire-projection.js";
 import { handleReadOnlyMergeCommand } from "./read-commands.js";
 import { runScanCommand } from "./scan-command.js";
 import { runApproveCommand } from "./approve-command.js";
 import { runResumeCommand } from "./resume-command.js";
-import { dropRow, loadMergeState, upsertRow } from "./state.js";
-import { transition } from "./coordinator.js";
+import { dropRowV3, loadMergeState, transactRows } from "./state.js";
 import { readCommitReceipt } from "./commit-receipt.js";
 import { undoMergeReceipt } from "./undo-merge.js";
 import { recordPair } from "./domain/pair-index-store.js";
+import { readStagingIndex } from "./domain/staging-index.js";
 import { skillLibraryUndoPort } from "./adapters/undo.js";
 import { mergeDoctor } from "./doctor.js";
 import { createChannelScanPorts } from "./scan-ports.js";
@@ -28,6 +31,13 @@ function forcedDecisionFor(a, b) {
     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 unitFor(deps) {
+    if (deps.unit !== undefined)
+        return deps.unit;
+    if (!(deps.skills instanceof SkillLibrary))
+        return undefined;
+    return new UnitTransactions({ io: deps.io, home: deps.home, backend: skillLibraryUnitBackend(deps.skills), claim: targetClaimUnitPort(deps.io, deps.home, deps.now), now: deps.now });
+}
 export function createMergeRuntime(deps) {
     const readOnly = createReadOnlyMergeService(deps.io, deps.home);
     const timeout = deps.timeoutMinutes > 0 ? deps.timeoutMinutes : undefined;
@@ -66,7 +76,9 @@ export function createMergeRuntime(deps) {
                 const pair = [{ a: command.a, b: command.b }];
                 const existing = (await loadMergeState(deps.io, deps.home)).state.rows.find(row => row.pairKey === pairKey(command.a, command.b));
                 if (existing?.state === 'skipped') {
-                    await dropRow(deps.io, deps.home, deps.now, existing.id);
+                    const dropped = await dropRowV3(deps.io, deps.home, existing.id, 'superseded');
+                    if (!dropped)
+                        return { ok: false, text: 'row changed before cleanup: ' + existing.id };
                 }
                 if (existing?.state === 'pending') {
                     return { ok: false, text: '该 pair 已在待批准队列，先 approve/reject/discard: ' + existing.id };
@@ -88,7 +100,8 @@ export function createMergeRuntime(deps) {
                             ...(deps.cwd === undefined ? {} : { cwd: deps.cwd }),
                             timeoutMs: deps.params.mergePairTimeoutMinutes * 60_000,
                             approval,
-                            commitPort: skillLibraryPort(deps.skills), now: deps.now,
+                            commitPort: skillLibraryPort(deps.skills), now: deps.now, ...(unitFor(deps) === undefined ? {} : { unit: unitFor(deps) }),
+                            ...(deps.isBlocked === undefined ? {} : { isBlocked: deps.isBlocked }),
                             ...stageHooks,
                         });
                         return forced === undefined ? ports : { ...ports, round1: () => Promise.resolve({ kind: 'merge', decision: forced }) };
@@ -140,7 +153,8 @@ export function createMergeRuntime(deps) {
                         ...(deps.cwd === undefined ? {} : { cwd: deps.cwd }),
                         timeoutMs: deps.params.mergePairTimeoutMinutes * 60_000,
                         approval: deps.params.mergeApproval,
-                        commitPort: skillLibraryPort(deps.skills), now: deps.now,
+                        commitPort: skillLibraryPort(deps.skills), now: deps.now, ...(unitFor(deps) === undefined ? {} : { unit: unitFor(deps) }),
+                        ...(deps.isBlocked === undefined ? {} : { isBlocked: deps.isBlocked }),
                         ...stageHooks,
                     }),
                 });
@@ -157,10 +171,14 @@ export function createMergeRuntime(deps) {
                 const row = loaded.state.rows.find(item => item.id === command.id);
                 if (row === undefined)
                     return { ok: false, text: 'merge row not found: ' + command.id };
-                const next = transition(row, { type: 'reject', at: new Date(deps.now()).toISOString() });
-                if (!next.ok || next.row === null)
-                    return { ok: false, text: 'merge row is not pending: ' + command.id };
-                await upsertRow(deps.io, deps.home, deps.now, next.row);
+                const changed = await transactRows(deps.io, deps.home, tx => {
+                    const current = tx.rows().find(item => item.id === row.id);
+                    if (current === undefined || current.state !== 'pending')
+                        return false;
+                    return tx.transition(row.id, { type: 'skipped', reason: 'rejected', origin: 'human' }, current.version).ok;
+                });
+                if (!changed)
+                    return { ok: false, text: 'merge row is not pending or changed: ' + command.id };
                 return { ok: true, text: '已拒绝合并：' + command.id };
             }
             if (command.verb === 'doctor') {
@@ -171,7 +189,7 @@ export function createMergeRuntime(deps) {
                 const registry = deps.registry;
                 if (command.verb === 'runs') {
                     const mergeRuns = registry.runs('merge');
-                    return { ok: true, text: mergeRuns.length === 0 ? 'merge runs: empty' : ['merge runs: ' + String(mergeRuns.length)].concat(mergeRuns.map(run => '- ' + run.id + ' [' + run.state + ']' + (run.resultRef === undefined ? '' : ' ' + run.resultRef))).join('\n') };
+                    return { ok: true, text: formatRunsView(toRunsView(mergeRuns, deps.now())) };
                 }
                 if (command.verb === 'cancel') {
                     if (command.id !== undefined) {
@@ -200,7 +218,9 @@ export function createMergeRuntime(deps) {
                     return { ok: false, text: 'merge row not found: ' + command.id };
                 if (row.state !== 'pending' && row.state !== 'approved' && row.state !== 'fuse')
                     return { ok: false, text: 'merge row is not discardable: ' + command.id };
-                await dropRow(deps.io, deps.home, deps.now, row.id);
+                const dropped = await dropRowV3(deps.io, deps.home, row.id, 'superseded');
+                if (!dropped)
+                    return { ok: false, text: 'row changed before discard: ' + command.id };
                 return { ok: true, text: '已丢弃合并行：' + command.id };
             }
             if (command.verb === 'undo') {
@@ -220,7 +240,9 @@ export function createMergeRuntime(deps) {
                 const row = loaded.state.rows.find(item => item.id === command.restore);
                 if (row === undefined || row.state !== 'skipped')
                     return { ok: false, text: 'skipped row not found: ' + command.restore };
-                await dropRow(deps.io, deps.home, deps.now, row.id);
+                const dropped = await dropRowV3(deps.io, deps.home, row.id, 'restored');
+                if (!dropped)
+                    return { ok: false, text: 'row changed before restore: ' + row.id };
                 return { ok: true, text: '已恢复参与筛选：' + row.id };
             }
             if (command.verb === 'resume') {
@@ -228,7 +250,9 @@ export function createMergeRuntime(deps) {
                     const cleared = (await loadMergeState(deps.io, deps.home)).state.rows.find(item => item.id === command.clear);
                     if (cleared === undefined)
                         return { ok: false, text: 'merge row not found: ' + command.clear };
-                    await dropRow(deps.io, deps.home, deps.now, cleared.id);
+                    const dropped = await dropRowV3(deps.io, deps.home, cleared.id, 'superseded');
+                    if (!dropped)
+                        return { ok: false, text: 'row changed before clear: ' + cleared.id };
                     return { ok: true, text: '已清除合并行：' + cleared.id };
                 }
                 const loaded = await loadMergeState(deps.io, deps.home);
@@ -247,6 +271,15 @@ export function createMergeRuntime(deps) {
                     return { ok: false, text: 'merge row not found: ' + (command.id ?? '(auto)') };
                 const signal = new AbortController().signal;
                 const cards = await deps.cards(signal);
+                if ((row.state === 'fuse' || row.state === 'approved') && row.decision !== undefined && row.decision.mode !== 'create-umbrella') {
+                    const targetCard = cards.find(card => card.name === row.decision?.target);
+                    if (targetCard !== undefined && targetCard.managed !== true)
+                        return { ok: false, text: 'target 不是 family-managed：' + row.decision.target };
+                    if (targetCard !== undefined && (targetCard.protectionUnknown === true || targetCard.protectedBy != null))
+                        return { ok: false, text: 'target 受保护：' + row.decision.target };
+                    if (await deps.isBlocked?.(row.decision.target) === true)
+                        return { ok: false, text: 'target 被范围门拦下：' + row.decision.target };
+                }
                 const pair = () => Promise.resolve([{ a: row.a, b: row.b }]);
                 const failed = (stage, code, message) => Promise.resolve({
                     kind: 'failed',
@@ -259,19 +292,23 @@ export function createMergeRuntime(deps) {
                 };
                 const result = await runResumeCommand({
                     ...common, rowId: row.id, ports: basePorts,
+                    ...(detached ? { detached: true } : {}),
+                    pairTimeoutMinutes: deps.params.mergePairTimeoutMinutes,
                     ...(deps.isOwnerActive === undefined ? {} : { isOwnerActive: deps.isOwnerActive }),
                     makePorts: runId => createChannelScanPorts({
                         io: deps.io, home: deps.home, runId, cards, screening: pair,
                         channel: deps.channel, parent, allow: deps.allow,
                         ...(deps.cwd === undefined ? {} : { cwd: deps.cwd }),
                         timeoutMs: deps.params.mergePairTimeoutMinutes * 60_000,
-                        approval: deps.params.mergeApproval, commitPort: skillLibraryPort(deps.skills), now: deps.now,
+                        approval: deps.params.mergeApproval, commitPort: skillLibraryPort(deps.skills), now: deps.now, ...(unitFor(deps) === undefined ? {} : { unit: unitFor(deps) }),
+                        ...(deps.isBlocked === undefined ? {} : { isBlocked: deps.isBlocked }),
                     }),
                     round2WithRun: createNewChildRound2({
                         io: deps.io, home: deps.home, cards, channel: deps.channel, parent,
                         allow: deps.allow, ...(deps.cwd === undefined ? {} : { cwd: deps.cwd }),
                         timeoutMs: deps.params.mergePairTimeoutMinutes * 60_000,
-                        commitPort: skillLibraryPort(deps.skills), now: deps.now,
+                        commitPort: skillLibraryPort(deps.skills), now: deps.now, ...(unitFor(deps) === undefined ? {} : { unit: unitFor(deps) }),
+                        ...(deps.isBlocked === undefined ? {} : { isBlocked: deps.isBlocked }),
                         ...stageHooks,
                     }),
                 });
@@ -286,44 +323,75 @@ 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);
+                let candidate = (await loadMergeState(deps.io, deps.home)).state.rows.find(row => row.id === command.id);
+                if (candidate !== undefined && candidate.stagingRef === undefined) {
+                    const entry = await readStagingIndex(deps.io, deps.home, candidate.id, deps.now());
+                    if (entry !== null)
+                        candidate = { ...candidate, stagingRef: entry.ref, stagingExpiresAt: entry.expiresAt };
+                }
                 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);
+                        const dropped = await dropRowV3(deps.io, deps.home, candidate.id, 'superseded');
+                        if (!dropped)
+                            return { ok: false, text: 'source-gone 但 row 已变化，未清理：' + 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);
+                        const recorded = await transactRows(deps.io, deps.home, tx => {
+                            const current = tx.rows().find(item => item.id === candidate.id);
+                            return current === undefined ? false : tx.transition(candidate.id, { type: 'expired', kind: 'source-changed' }, current.version).ok;
+                        });
+                        if (!recorded)
+                            return { ok: false, text: 'row changed before source-changed record: ' + candidate.id };
                         return { ok: false, text: 'source-changed：源技能内容在决策后变化，拒绝照跑；出口：重新 merge pair，或 merge skipped --discard' };
                     }
                     const currentTargetRevision = targetRevisionOf(cards, candidate.decision.target);
                     if (candidate.targetRevision !== undefined && currentTargetRevision !== undefined
                         && currentTargetRevision !== candidate.targetRevision) {
-                        const taken = transition(candidate, { type: 'target-taken', at: new Date().toISOString() });
-                        if (taken.ok && taken.row !== null)
-                            await upsertRow(deps.io, deps.home, deps.now, taken.row);
+                        const recorded = await transactRows(deps.io, deps.home, tx => {
+                            const current = tx.rows().find(item => item.id === candidate.id);
+                            return current === undefined ? false : tx.transition(candidate.id, { type: 'expired', kind: 'target-taken' }, current.version).ok;
+                        });
+                        if (!recorded)
+                            return { ok: false, text: 'row changed before target-taken record: ' + candidate.id };
                         return { ok: false, text: 'target-taken：目标 ' + candidate.decision.target + ' 在决策后变化，拒绝照跑；可重新 merge pair 或 discard' };
                     }
+                    if (candidate.decision.mode !== 'create-umbrella') {
+                        const targetCard = cards.find(card => card.name === candidate.decision?.target);
+                        if (targetCard !== undefined && targetCard.managed !== true) {
+                            return { ok: false, text: 'target 不是 family-managed：' + candidate.decision.target };
+                        }
+                        if (targetCard !== undefined && (targetCard.protectionUnknown === true || targetCard.protectedBy != null)) {
+                            return { ok: false, text: 'target 受保护：' + candidate.decision.target };
+                        }
+                        if (await deps.isBlocked?.(candidate.decision.target) === true) {
+                            return { ok: false, text: 'target 被范围门拦下：' + candidate.decision.target };
+                        }
+                    }
                     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);
+                        const recorded = await transactRows(deps.io, deps.home, tx => {
+                            const current = tx.rows().find(item => item.id === candidate.id);
+                            return current === undefined ? false : tx.transition(candidate.id, { type: 'expired', kind: 'target-taken' }, current.version).ok;
+                        });
+                        if (!recorded)
+                            return { ok: false, text: 'row changed before target-taken record: ' + candidate.id };
                         return { ok: false, text: 'target-taken：目标 ' + candidate.decision.target + ' 已不存在，行保留 pending --expired；出口：重新 merge pair，或 merge skipped --discard' };
                     }
                 }
                 const result = await runApproveCommand({
                     ...common,
                     rowId: command.id,
+                    ...(detached ? { detached: true } : {}),
+                    pairTimeoutMinutes: deps.params.mergePairTimeoutMinutes,
                     ports: {
                         round2: createNewChildRound2({
                             io: deps.io, home: deps.home, cards, channel: deps.channel, parent,
                             allow: deps.allow, ...(deps.cwd === undefined ? {} : { cwd: deps.cwd }),
                             timeoutMs: deps.params.mergePairTimeoutMinutes * 60_000,
-                            commitPort: skillLibraryPort(deps.skills), now: deps.now,
+                            commitPort: skillLibraryPort(deps.skills), now: deps.now, ...(unitFor(deps) === undefined ? {} : { unit: unitFor(deps) }),
+                            ...(deps.isBlocked === undefined ? {} : { isBlocked: deps.isBlocked }),
                         }),
                     },
                 });
@@ -336,7 +404,9 @@ export function createMergeRuntime(deps) {
                 return { ok: true, text: 'merge approve 完成：merged ' + String(result.report.totals.merged) };
             }
             const cards = command.verb === 'pending' ? await deps.cards(new AbortController().signal) : undefined;
-            const text = await handleReadOnlyMergeCommand(command, deps.io, deps.home, cards);
+            const registry = deps.registry;
+            const runs = command.verb === 'status' ? registry.runs('merge') : undefined;
+            const text = await handleReadOnlyMergeCommand(command, deps.io, deps.home, cards, runs, deps.params.mergeApproval);
             if (text !== null)
                 return { ok: true, text };
             return readOnly.execute(command);

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

@@ -5,7 +5,7 @@
  * Approval on: round1 disposes the child immediately; the row waits in pending and the later
  * approve run must open a new child (not handled by this factory).
  */
-import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
+import type { EvolutionIoLike, UnitTransaction } from '@lmzhen/dsh-evolution-core';
 import type { SkillCard } from './skill-card.ts';
 import { type ConversationChannelLike } from './channel-port.ts';
 import type { CommitPort } from './commit-execute.ts';
@@ -24,7 +24,9 @@ export interface CreateScanPortsOptions {
     readonly timeoutMs: number;
     readonly approval: boolean;
     readonly commitPort: CommitPort;
+    readonly unit?: UnitTransaction | undefined;
     readonly now: () => number;
+    readonly isBlocked?: (name: string) => boolean | Promise<boolean>;
     readonly onChild?: (context: StageToolContext) => void;
     readonly onChildClosed?: (childId: string) => void;
 }

package/lib/types/scan-ports.js

@@ -72,7 +72,9 @@ export function createChannelScanPorts(options) {
                     mode: decision.mode,
                     cards: options.cards,
                     commitPort: options.commitPort,
+                    ...(options.unit === undefined ? {} : { unit: options.unit }),
                     now: options.now,
+                    ...(options.isBlocked === undefined ? {} : { isBlocked: options.isBlocked }),
                     summary: 'merge ' + row.a + ' + ' + row.b,
                     author: async () => {
                         await entry.result.author?.(row, decision, signal);