@lmzhen/dsh-evolution-merge 0.30.18 → 0.30.19

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

@@ -19,6 +19,7 @@ export interface RunScanCommandOptions {
     readonly detached?: boolean;
     readonly notes?: readonly string[];
     readonly isOwnerActive?: (runId: string) => boolean | Promise<boolean>;
+    readonly cards?: readonly import('./skill-card.ts').SkillCard[];
 }
 export declare function runScanCommand(options: RunScanCommandOptions): Promise<WithMergeRunResult>;
 //# sourceMappingURL=scan-command.d.ts.map

package/lib/types/scan-command.js

@@ -9,6 +9,7 @@ export async function runScanCommand(options) {
         approval: { platformWrite: options.platformWrite, mergeApproval: options.approval },
         now: options.now,
         ...(options.detached === undefined ? {} : { detached: options.detached }),
+        ...(options.timeoutMinutes === undefined ? {} : { timeoutMinutes: options.timeoutMinutes }),
         async body(ctx) {
             const ports = options.makePorts === undefined ? options.ports : options.makePorts(ctx.runId);
             if (ports === undefined)
@@ -26,6 +27,7 @@ export async function runScanCommand(options) {
                 ...(options.timeoutMinutes === undefined ? {} : { timeoutMinutes: options.timeoutMinutes }),
                 ...(options.notes === undefined ? {} : { notes: options.notes }),
                 ...(options.isOwnerActive === undefined ? {} : { isOwnerActive: options.isOwnerActive }),
+                ...(options.cards === undefined ? {} : { cards: options.cards }),
             });
         },
     });

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

@@ -6,10 +6,12 @@
  * approve run must open a new child (not handled by this factory).
  */
 import type { EvolutionIoLike, UnitTransaction } from '@lmzhen/dsh-evolution-core';
+import type { MergeDecision, MergeRow } from './contracts.ts';
 import type { SkillCard } from './skill-card.ts';
 import { type ConversationChannelLike } from './channel-port.ts';
 import type { CommitPort } from './commit-execute.ts';
 import type { StageToolContext } from './stage-tool.ts';
+import { type StageEntry } from './domain/stage-aggregate.ts';
 import type { ScanPorts } from './scan-run.ts';
 export interface CreateScanPortsOptions {
     readonly io: EvolutionIoLike;
@@ -17,6 +19,7 @@ export interface CreateScanPortsOptions {
     readonly runId: string;
     readonly cards: readonly SkillCard[];
     readonly screening: ScanPorts['screening'];
+    readonly resolve?: ScanPorts['resolve'];
     readonly channel: ConversationChannelLike;
     readonly parent: unknown;
     readonly allow: readonly string[];
@@ -25,10 +28,25 @@ export interface CreateScanPortsOptions {
     readonly approval: boolean;
     readonly commitPort: CommitPort;
     readonly unit?: UnitTransaction | undefined;
+    readonly limits?: import('@lmzhen/dsh-evolution-core').SkillLimits | undefined;
     readonly now: () => number;
     readonly isBlocked?: (name: string) => boolean | Promise<boolean>;
     readonly onChild?: (context: StageToolContext) => void;
     readonly onChildClosed?: (childId: string) => void;
 }
+export interface StageForCardsOptions {
+    readonly io: EvolutionIoLike;
+    readonly home: string;
+    readonly runId: string;
+    readonly cards: readonly SkillCard[];
+    readonly now: () => number;
+}
+export declare function createStageForCards(options: StageForCardsOptions): (row: MergeRow, decision: MergeDecision) => Promise<{
+    readonly ok: true;
+    readonly entry: StageEntry;
+} | {
+    readonly ok: false;
+    readonly message: string;
+}>;
 export declare function createChannelScanPorts(options: CreateScanPortsOptions): ScanPorts;
 //# sourceMappingURL=scan-ports.d.ts.map

package/lib/types/scan-ports.js

@@ -1,39 +1,49 @@
 import { pairKey } from "./contracts.js";
+function classifyCommitFailure(message) {
+    if (message.includes('目标技能') && (message.includes('被改过') || message.includes('不存在')))
+        return message.includes('被改过') ? 'target-changed' : 'target-taken';
+    if (message.includes('来源技能') && message.includes('被改过'))
+        return 'source-changed';
+    if (message.includes('来源技能') && message.includes('不存在'))
+        return 'source-gone';
+    return 'authoring-failed';
+}
 import { runRound1OverChannel } from "./channel-port.js";
 import { runAuthoring } from "./authoring-flow.js";
-import { dropStaging, ensureStaging, stageKeyOf, stagingRoot } from "./staging.js";
+import { buildRound2Prompt, MERGE_PROMPT_VERSION, promptHashOf } from "./prompts.js";
+import { stageKeyOf } from "./staging.js";
+import { createStageTree, reserveStage } from "./domain/stage-aggregate.js";
 import { sourceRevisionOf, targetRevisionOf } from "./revision.js";
+export function createStageForCards(options) {
+    return async (row, decision) => {
+        const stageKey = stageKeyOf(options.runId, pairKey(row.a, row.b));
+        const entry = { version: 1, rowId: row.id, pairKey: row.pairKey, runId: options.runId, ref: stageKey, state: 'reserved', createdAt: options.now(), expiresAt: options.now() + 7 * 86_400_000, updatedAt: options.now() };
+        await reserveStage(options.io, options.home, entry);
+        const staged = await createStageTree(options.io, options.home, {
+            runId: stageKey, target: decision.target,
+            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,
+        });
+        return staged.ok ? { ok: true, entry } : { ok: false, message: staged.message };
+    };
+}
 export function createChannelScanPorts(options) {
     const sessions = new Map();
     return {
         screening: options.screening,
+        ...(options.resolve === undefined ? {} : { resolve: options.resolve }),
         async round1(candidate, signal) {
             const stageKey = stageKeyOf(options.runId, pairKey(candidate.a, candidate.b));
-            const staged = await ensureStaging(options.io, options.home, {
-                runId: stageKey,
-                target: candidate.a + '-' + candidate.b,
-                sources: options.cards
-                    .filter(card => card.name === candidate.a || card.name === candidate.b)
-                    .map(card => ({ name: card.name, body: card.body, files: card.files ?? [] })),
-                promptVersion: 'merge-b/v1',
-                ttlDays: 7,
-                now: options.now,
-            });
-            if (!staged.ok)
-                return { kind: 'failed', failure: { stage: 'decide', code: 'staging-create', message: staged.message, retryable: true, retryFrom: 'agent1' } };
             const result = await runRound1OverChannel({
                 channel: options.channel,
                 parent: options.parent,
                 cards: options.cards,
                 allow: options.allow,
-                cwd: stagingRoot(options.home, stageKey),
+                cwd: options.cwd ?? options.home,
                 timeoutMs: options.timeoutMs,
                 onChildOpened: childId => options.onChild?.({ runId: stageKey, childId, expectedChildId: childId, phase: 'decide' }),
             }, candidate, signal);
-            if (result.outcome.kind !== 'merge') {
-                await dropStaging(options.io, options.home, stageKey);
-            }
-            else {
+            if (result.outcome.kind === 'merge') {
                 if (options.approval)
                     await result.dispose();
                 else {
@@ -43,6 +53,7 @@ export function createChannelScanPorts(options) {
                     }
                 }
             }
+            const round1Usage = result.usage?.();
             const sourceRevision = result.outcome.kind === 'merge' ? sourceRevisionOf(options.cards, candidate.a, candidate.b) : undefined;
             const target = result.outcome.kind === 'merge' ? result.outcome.decision?.target : undefined;
             const targetRevision = target === undefined ? undefined : targetRevisionOf(options.cards, target);
@@ -51,9 +62,13 @@ export function createChannelScanPorts(options) {
                     ...result.outcome, stagingRef: stageKey, stagingExpiresAt: options.now() + 7 * 86_400_000,
                     ...(sourceRevision === undefined ? {} : { sourceRevision }),
                     ...(targetRevision === undefined ? {} : { targetRevision }),
+                    ...(round1Usage === undefined ? {} : { usage: round1Usage }),
                 }
-                : result.outcome;
+                : result.outcome.kind === 'failed'
+                    ? { ...result.outcome, degraded: ['round1 child failed: ' + (result.outcome.failure?.code ?? 'unknown')], ...(round1Usage === undefined ? {} : { usage: round1Usage }) }
+                    : { ...result.outcome, ...(round1Usage === undefined ? {} : { usage: round1Usage }) };
         },
+        stage: createStageForCards({ io: options.io, home: options.home, runId: options.runId, cards: options.cards, now: options.now }),
         async round2(row, decision, signal) {
             const key = pairKey(row.a, row.b);
             const entry = sessions.get(key);
@@ -76,18 +91,29 @@ export function createChannelScanPorts(options) {
                     now: options.now,
                     ...(options.isBlocked === undefined ? {} : { isBlocked: options.isBlocked }),
                     summary: 'merge ' + row.a + ' + ' + row.b,
-                    author: async () => {
-                        await entry.result.author?.(row, decision, signal);
-                        return 'authored';
+                    ...(options.limits === undefined ? {} : { limits: options.limits }),
+                    promptVersion: MERGE_PROMPT_VERSION,
+                    promptHash: promptHashOf(buildRound2Prompt(row, decision)),
+                    revisions: {
+                        ...(decision.targetRevisionRef === undefined ? {} : { targetRevision: decision.targetRevisionRef }),
+                        ...(decision.sourceRevisions === undefined ? {} : { sourceRevisions: decision.sourceRevisions }),
+                        ...(decision.supportDigest === undefined ? {} : { supportDigest: decision.supportDigest }),
                     },
+                    author: async () => (await entry.result.author?.(row, decision, signal)) ?? 'authored',
                 });
+                const usage = entry.result.usage?.();
                 if (!authored.ok) {
-                    return { kind: 'failed', failure: { stage: 'author', code: 'authoring-failed', message: authored.message, retryable: true, retryFrom: 'agent2' } };
+                    const limit = authored.findings?.some(finding => finding.rule === 'limit') === true;
+                    const code = authored.code ?? (limit ? 'merge-over-limit' : authored.findings === undefined ? classifyCommitFailure(authored.message) : 'merge-validation');
+                    return { kind: 'failed', failure: { stage: 'author', code, message: authored.message, retryable: code !== 'target-changed' && code !== 'source-changed' && code !== 'support-changed', retryFrom: code === 'target-changed' || code === 'source-changed' || code === 'support-changed' ? 'none' : 'agent2', ...(authored.lengths === undefined ? {} : { lengths: authored.lengths }), ...(usage === undefined ? {} : { usage }) }, };
                 }
                 const receipt = authored.commit.receipt;
                 return {
                     kind: 'merged',
                     ...(receipt?.unitId === undefined ? {} : { unitId: receipt.unitId }),
+                    ...(receipt?.evidenceSha256 === undefined ? {} : { evidenceSha256: receipt.evidenceSha256 }),
+                    ...(receipt?.validationPlan === undefined ? {} : { validationPlan: receipt.validationPlan }),
+                    ...(usage === undefined ? {} : { usage }),
                     archived: receipt?.archived ?? [],
                     target: { requested: decision.target, actual: authored.commit.plan.target, created: receipt?.create ?? false },
                 };

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

@@ -3,7 +3,9 @@
  * candidate → round1 → pending/fuse → commit transitions and returns the report draft.
  */
 import { type MergeCandidate, type MergeDecision, type MergeFailure, type MergeRow } from './contracts.ts';
+import { type StageEntry } from './domain/stage-aggregate.ts';
 import type { EvolutionIoLike, RunStage } from '@lmzhen/dsh-evolution-core';
+import type { SkillCard } from './skill-card.ts';
 import type { MergeRunReportDraft } from './run-shell.ts';
 export interface ScanRound1Outcome {
     readonly kind: 'keep' | 'merge' | 'failed';
@@ -13,10 +15,14 @@ export interface ScanRound1Outcome {
     readonly stagingExpiresAt?: number;
     readonly sourceRevision?: string;
     readonly targetRevision?: string;
+    readonly degraded?: readonly string[];
+    readonly usage?: import('./contracts.ts').MergeUsage;
 }
 export interface ScanRound2Outcome {
     readonly kind: 'merged' | 'failed';
     readonly unitId?: string;
+    readonly evidenceSha256?: string;
+    readonly validationPlan?: import('./contracts.ts').MergeValidationPlanRef;
     readonly archived?: readonly string[];
     readonly target?: {
         readonly requested: string;
@@ -24,10 +30,20 @@ export interface ScanRound2Outcome {
         readonly created: boolean;
     };
     readonly failure?: MergeFailure;
+    readonly usage?: import('./contracts.ts').MergeUsage;
+    readonly lengths?: Readonly<Record<string, number>>;
 }
 export interface ScanPorts {
     screening(signal: AbortSignal): Promise<readonly MergeCandidate[]>;
+    resolve?(candidate: MergeCandidate): Promise<boolean>;
     round1(candidate: MergeCandidate, signal: AbortSignal): Promise<ScanRound1Outcome>;
+    stage?(row: MergeRow, decision: MergeDecision): Promise<{
+        readonly ok: true;
+        readonly entry: StageEntry;
+    } | {
+        readonly ok: false;
+        readonly message: string;
+    }>;
     round2(row: MergeRow, decision: MergeDecision, signal: AbortSignal): Promise<ScanRound2Outcome>;
 }
 export interface RunScanOptions {
@@ -46,6 +62,7 @@ export interface RunScanOptions {
     readonly notes?: readonly string[];
     readonly runId?: string;
     readonly isOwnerActive?: (runId: string) => boolean | Promise<boolean>;
+    readonly cards?: readonly SkillCard[];
 }
 export declare function runScan(options: RunScanOptions): Promise<MergeRunReportDraft>;
 //# sourceMappingURL=scan-run.d.ts.map

package/lib/types/scan-run.js

@@ -3,10 +3,13 @@
  * candidate → round1 → pending/fuse → commit transitions and returns the report draft.
  */
 import { pairKey, rowIdOf, } from "./contracts.js";
-import { dropRowV3, loadMergeState, transactRows } from "./state.js";
-import { recordPair } from "./domain/pair-index-store.js";
-import { writeStagingIndex } from "./domain/staging-index.js";
-import { v3ToLegacy } from "./domain/row-v3-bridge.js";
+import { loadMergeState } from "./state.js";
+import { pairLedger } from "./domain/pair-ledger.js";
+import { presentStage, dropStage } from "./domain/stage-aggregate.js";
+import { recordPair } from "./domain/run-coordinator.js";
+import { v4ToLegacy } from "./domain/row-v4.js";
+import { criteriaFrom } from "./domain/engine-criteria.js";
+import { withDecisionRevisions } from "./revision.js";
 const isAborted = (signal) => signal.aborted;
 function at(now) {
     return new Date(now()).toISOString();
@@ -46,8 +49,10 @@ export async function runScan(options) {
     const startedAt = options.startedAt ?? options.now();
     const timeoutMs = (options.timeoutMinutes ?? 0) > 0 ? options.timeoutMinutes * 60_000 : 0;
     const pairs = [];
+    const degradedNotes = [];
     const totals = { merged: 0, kept: 0, pending: 0, failed: 0 };
     const remaining = [];
+    const finalizeRows = [];
     let stopReason = 'completed';
     for (let index = 0; index < candidates.length; index += 1) {
         if (isAborted(options.signal)) {
@@ -72,7 +77,7 @@ export async function runScan(options) {
                 && (await options.isOwnerActive?.(before.runId)) === true) {
                 continue;
             }
-            const status = await transactRows(options.io, options.home, tx => {
+            const status = await pairLedger(options.io, options.home).transact(tx => {
                 const current = tx.rows().find(item => item.pairKey === row.pairKey);
                 if (current !== undefined && current.state !== 'verify' && current.state !== 'skipped')
                     return 'conflict:' + current.state;
@@ -104,6 +109,15 @@ export async function runScan(options) {
             });
             continue;
         }
+        if (options.ports.resolve !== undefined && !(await options.ports.resolve(candidate))) {
+            await pairLedger(options.io, options.home).transact(tx => {
+                const current = tx.rows().find(item => item.id === row.id);
+                return current === undefined ? false : tx.remove(row.id, 'superseded', undefined, current.version).ok;
+            });
+            pairs.push(pairOf(row, candidate, 'failed', { failure: { stage: 'decide', code: 'source-gone', message: 'source skill disappeared before round1', retryable: false, retryFrom: 'none' } }));
+            totals.failed += 1;
+            continue;
+        }
         let round1;
         try {
             round1 = await options.ports.round1(candidate, options.signal);
@@ -117,13 +131,15 @@ export async function runScan(options) {
             break;
         }
         if (round1.kind === 'failed') {
+            if (round1.degraded !== undefined)
+                degradedNotes.push(...round1.degraded);
             const failure = round1.failure ?? failureOf('decide', 'round1 failed');
-            const projected = await transactRows(options.io, options.home, tx => {
+            const projected = await pairLedger(options.io, options.home).transact(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;
+                return moved.ok && moved.row !== null ? v4ToLegacy(moved.row) : null;
             });
             if (projected === null) {
                 pairs.push(pairOf(row, candidate, 'failed', { failure: failureOf('decide', 'row changed before failure record') }));
@@ -136,12 +152,13 @@ export async function runScan(options) {
             continue;
         }
         if (round1.kind === 'keep') {
-            const projected = await transactRows(options.io, options.home, tx => {
+            const projected = await pairLedger(options.io, options.home).transact(tx => {
                 const current = tx.rows().find(item => item.id === row.id);
                 if (current === undefined)
                     return null;
-                const moved = tx.transition(row.id, { type: 'skipped', reason: 'kept' }, current.version);
-                return moved.ok && moved.row !== null ? v3ToLegacy(moved.row) : null;
+                const keepReason = round1.decision?.rationale?.trim();
+                const moved = tx.transition(row.id, { type: 'skipped', ...(keepReason === undefined || keepReason === '' ? { reason: 'kept' } : { reason: keepReason }), origin: 'agent' }, current.version);
+                return moved.ok && moved.row !== null ? v4ToLegacy(moved.row) : null;
             });
             if (projected === null) {
                 pairs.push(pairOf(row, candidate, 'failed', { failure: failureOf('decide', 'row changed before keep record') }));
@@ -150,7 +167,7 @@ export async function runScan(options) {
             }
             row = projected;
             await recordPair(options.io, options.home, { pairKey: row.pairKey, runId: row.runId ?? 'merge', result: 'kept' });
-            pairs.push(pairOf(row, candidate, 'kept', round1.decision === undefined ? {} : { decision: round1.decision }));
+            pairs.push(pairOf(row, candidate, 'kept', { ...(round1.decision === undefined ? {} : { decision: round1.decision }), ...(round1.usage === undefined ? {} : { usage: round1.usage }) }));
             totals.kept += 1;
             continue;
         }
@@ -159,52 +176,71 @@ export async function runScan(options) {
             totals.failed += 1;
             continue;
         }
+        const mergeDecision = options.cards !== undefined ? withDecisionRevisions(round1.decision, options.cards, row.a, row.b) : round1.decision;
         if (options.approval) {
-            const event = { type: 'verify-passed', decision: round1.decision, target: round1.decision.target, ...(round1.sourceRevision === undefined ? {} : { sourceRevision: round1.sourceRevision }) };
-            const projected = await transactRows(options.io, options.home, tx => {
+            const event = { type: 'verify-passed', decision: mergeDecision, target: mergeDecision.target, ...(round1.sourceRevision === undefined ? {} : { sourceRevision: round1.sourceRevision }), ...(mergeDecision.promptVersion === undefined ? {} : { promptVersion: mergeDecision.promptVersion }), ...(mergeDecision.promptHash === undefined ? {} : { promptHash: mergeDecision.promptHash }) };
+            const projected = await pairLedger(options.io, options.home).transact(tx => {
                 const current = tx.rows().find(item => item.id === row.id);
                 if (current === undefined)
                     return null;
                 const moved = tx.transition(row.id, event, current.version);
-                return moved.ok && moved.row !== null ? v3ToLegacy(moved.row) : null;
+                return moved.ok && moved.row !== null ? v4ToLegacy(moved.row) : null;
             });
             if (projected === null) {
-                pairs.push(pairOf(row, candidate, 'failed', { decision: round1.decision, failure: failureOf('decide', 'row changed before pending record') }));
+                pairs.push(pairOf(row, candidate, 'failed', { decision: mergeDecision, failure: failureOf('decide', 'row changed before pending record') }));
                 totals.failed += 1;
                 continue;
             }
             row = projected;
-            pairs.push(pairOf(row, candidate, 'pending', { decision: round1.decision }));
+            pairs.push(pairOf(row, candidate, 'pending', { decision: mergeDecision }));
             totals.pending += 1;
             continue;
         }
-        const staged = await transactRows(options.io, options.home, tx => {
+        const approved = await pairLedger(options.io, options.home).transact(tx => {
             const current = tx.rows().find(item => item.id === row.id);
             if (current === undefined)
                 return null;
-            const approved = tx.transition(row.id, { type: 'auto-approved', decision: round1.decision, target: round1.decision.target, ...(row.runId === undefined ? {} : { runId: row.runId }) }, current.version);
-            if (!approved.ok || approved.row === null)
-                return null;
-            const moved = tx.transition(row.id, { type: 'staged', ...(round1.stagingRef === undefined ? {} : { ref: round1.stagingRef }), ...(round1.stagingExpiresAt === undefined ? {} : { expiresAt: round1.stagingExpiresAt }) }, approved.row.version);
-            return moved.ok && moved.row !== null ? v3ToLegacy(moved.row) : null;
+            const moved = tx.transition(row.id, { type: 'auto-approved', decision: mergeDecision, target: mergeDecision.target, ...(row.runId === undefined ? {} : { runId: row.runId }) }, current.version);
+            return moved.ok && moved.row !== null ? v4ToLegacy(moved.row) : null;
         });
-        if (staged === null) {
-            pairs.push(pairOf(row, candidate, 'failed', { decision: round1.decision, failure: failureOf('author', 'row changed before staging record') }));
+        if (approved === null) {
+            pairs.push(pairOf(row, candidate, 'failed', { decision: mergeDecision, failure: failureOf('author', 'row changed before approve record') }));
             totals.failed += 1;
             continue;
         }
-        row = staged;
-        if (round1.stagingRef !== undefined) {
-            const expiresAt = round1.stagingExpiresAt ?? options.now() + 7 * 86_400_000;
-            await writeStagingIndex(options.io, options.home, { rowId: row.id, pairKey: row.pairKey, ref: round1.stagingRef, expiresAt, ...(row.runId === undefined ? {} : { runId: row.runId }), createdAt: options.now() });
+        row = approved;
+        let stageEntry;
+        if (options.ports.stage !== undefined) {
+            const staged = await options.ports.stage(row, mergeDecision);
+            if (!staged.ok) {
+                pairs.push(pairOf(row, candidate, 'failed', { decision: mergeDecision, failure: failureOf('author', staged.message) }));
+                totals.failed += 1;
+                continue;
+            }
+            stageEntry = staged.entry;
+        }
+        const fused = await pairLedger(options.io, options.home).transact(tx => {
+            const current = tx.rows().find(item => item.id === row.id);
+            if (current === undefined)
+                return null;
+            const moved = tx.transition(row.id, { type: 'staged' }, current.version);
+            return moved.ok && moved.row !== null ? v4ToLegacy(moved.row) : null;
+        });
+        if (fused === null) {
+            pairs.push(pairOf(row, candidate, 'failed', { decision: mergeDecision, failure: failureOf('author', 'row changed before staging record') }));
+            totals.failed += 1;
+            continue;
         }
+        row = fused;
+        if (stageEntry !== undefined)
+            await presentStage(options.io, options.home, stageEntry);
         if (isAborted(options.signal)) {
-            const projected = await transactRows(options.io, options.home, tx => {
+            const projected = await pairLedger(options.io, options.home).transact(tx => {
                 const current = tx.rows().find(item => item.id === row.id);
                 if (current === undefined)
                     return null;
                 const moved = tx.transition(row.id, { type: 'skipped', reason: 'cancelled' }, current.version);
-                return moved.ok && moved.row !== null ? v3ToLegacy(moved.row) : null;
+                return moved.ok && moved.row !== null ? v4ToLegacy(moved.row) : null;
             });
             if (projected !== null)
                 row = projected;
@@ -215,44 +251,85 @@ export async function runScan(options) {
         await stage('author', { done: index, total: candidates.length });
         let round2;
         try {
-            round2 = await options.ports.round2(row, round1.decision, options.signal);
+            round2 = await options.ports.round2(row, mergeDecision, options.signal);
         }
         catch (error) {
             round2 = { kind: 'failed', failure: failureOf('author', error) };
         }
         if (round2.kind === 'merged') {
-            const dropped = await dropRowV3(options.io, options.home, row.id, 'committed', round2.unitId ?? 'unknown');
-            if (!dropped) {
-                pairs.push(pairOf(row, candidate, 'failed', { decision: round1.decision, failure: failureOf('commit', 'row changed before commit record') }));
-                totals.failed += 1;
-                continue;
-            }
-            pairs.push(pairOf(row, candidate, 'merged', {
-                decision: round1.decision,
-                ...(round2.unitId === undefined ? {} : { unitId: round2.unitId }),
-                ...(round2.target === undefined ? {} : { target: round2.target }),
-                archived: round2.archived ?? [],
-            }));
+            finalizeRows.push({ id: row.id, unitId: round2.unitId ?? 'unknown', evidenceSha256: round2.evidenceSha256 ?? 'unknown' });
+            pairs.push({ ...pairOf(row, candidate, 'merged', {
+                    decision: mergeDecision,
+                    ...(round2.unitId === undefined ? {} : { unitId: round2.unitId }),
+                    ...(round2.target === undefined ? {} : { target: round2.target }),
+                    ...(round2.usage === undefined ? {} : { usage: round2.usage }),
+                    ...(round2.lengths === undefined ? {} : { lengths: round2.lengths }),
+                    archived: round2.archived ?? [],
+                }), ...(round2.validationPlan === undefined ? {} : { validationPlan: round2.validationPlan }) });
             totals.merged += 1;
             continue;
         }
         const failed = round2.failure ?? failureOf('author', 'round2 failed');
-        const projected = await transactRows(options.io, options.home, tx => {
+        if (failed.code === 'merge-over-limit' || failed.code === 'limit' || failed.code === 'merge-validation') {
+            const reason = failed.code === 'merge-validation' ? 'validation-failed' : 'merge-over-limit';
+            const skipped = await pairLedger(options.io, options.home).transact(tx => {
+                const current = tx.rows().find(item => item.id === row.id);
+                return current === undefined ? false : tx.transition(row.id, { type: 'skipped', reason, origin: 'system', skipSource: 'system' }, current.version).ok;
+            });
+            if (skipped)
+                await dropStage(options.io, options.home, row.id);
+            pairs.push(pairOf(row, candidate, 'failed', { decision: mergeDecision, failure: failed }));
+            totals.failed += 1;
+            continue;
+        }
+        if (failed.code === 'target-changed' || failed.code === 'target-taken' || failed.code === 'source-changed' || failed.code === 'support-changed' || failed.code === 'source-gone') {
+            const code = failed.code === 'target-changed' ? 'target-taken' : failed.code === 'support-changed' ? 'source-changed' : failed.code;
+            await pairLedger(options.io, options.home).transact(tx => {
+                const current = tx.rows().find(item => item.id === row.id);
+                if (current === undefined)
+                    return false;
+                if (code === 'source-gone')
+                    return tx.remove(row.id, 'superseded', undefined, current.version).ok;
+                return tx.transition(row.id, { type: 'skipped', reason: code, origin: 'system', skipSource: 'system' }, current.version).ok;
+            });
+            await dropStage(options.io, options.home, row.id);
+            pairs.push(pairOf(row, candidate, 'failed', { decision: mergeDecision, failure: { ...failed, code, retryable: false, retryFrom: 'none' } }));
+            totals.failed += 1;
+            continue;
+        }
+        const terminal = failed.code === 'commit-failed' || failed.code === 'validation-failed' || failed.code === 'merge-validation';
+        const projected = terminal ? null : await pairLedger(options.io, options.home).transact(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: failed }, current.version);
-            return moved.ok && moved.row !== null ? v3ToLegacy(moved.row) : null;
+            return moved.ok && moved.row !== null ? v4ToLegacy(moved.row) : null;
         });
+        if (projected === null && terminal) {
+            await pairLedger(options.io, options.home).transact(tx => {
+                const current = tx.rows().find(item => item.id === row.id);
+                return current === undefined ? false : tx.remove(row.id, 'superseded', undefined, current.version).ok;
+            });
+            pairs.push(pairOf(row, candidate, 'failed', { decision: mergeDecision, failure: failed }));
+            totals.failed += 1;
+            continue;
+        }
         if (projected === null) {
-            pairs.push(pairOf(row, candidate, 'failed', { decision: round1.decision, failure: failureOf('author', 'row changed before failure record') }));
+            pairs.push(pairOf(row, candidate, 'failed', { decision: mergeDecision, failure: failureOf('author', 'row changed before failure record') }));
             totals.failed += 1;
             continue;
         }
         row = projected;
-        pairs.push(pairOf(row, candidate, 'failed', { decision: round1.decision, failure: failed }));
+        pairs.push(pairOf(row, candidate, 'failed', { decision: mergeDecision, failure: failed }));
         totals.failed += 1;
     }
+    const selectionReportOnly = candidates.reportOnly ?? [];
+    const selectionReportOnlyPairs = selectionReportOnly.flatMap(raw => {
+        const value = raw;
+        if (typeof value.a !== 'string' || typeof value.b !== 'string')
+            return [];
+        return [{ id: '', pairKey: typeof value.pairKey === 'string' ? value.pairKey : pairKey(value.a, value.b), a: value.a, b: value.b, queue: 'verify', candidate: { a: value.a, b: value.b }, outcome: 'kept', archived: [], ...(value.gate === undefined ? {} : { gate: value.gate }) }];
+    });
     return {
         stopReason,
         scope: {
@@ -261,8 +338,26 @@ export async function runScan(options) {
         },
         pairs,
         totals,
-        notes: [...(options.notes ?? [])],
+        notes: [...(options.notes ?? []), ...degradedNotes],
+        reportOnly: [...pairs.filter(pair => pair.outcome === 'kept' || pair.gate?.level === 'L0' || pair.gate?.level === 'L1'), ...selectionReportOnlyPairs],
+        validationFailures: pairs.filter(pair => pair.failure !== undefined && (pair.failure.stage === 'validate' || pair.failure.code === 'merge-validation' || pair.failure.code === 'merge-over-limit')),
+        archived: [...new Set(pairs.flatMap(pair => pair.archived))],
+        ...(pairs.find(pair => pair.outcome === 'merged' && pair.unitId !== undefined) === undefined ? {} : { commit: (() => { const pair = pairs.find(item => item.outcome === 'merged' && item.unitId !== undefined); return { ...(pair.unitId === undefined ? {} : { unitId: pair.unitId }), ...(pair.target === undefined ? {} : { target: pair.target.actual ?? pair.target.requested }), ...(pair.target === undefined ? {} : { created: pair.target.created }) }; })() }),
+        ...(pairs.every(pair => pair.usage === undefined) ? {} : { usage: { inputTokens: pairs.reduce((sum, pair) => sum + (pair.usage?.inputTokens ?? 0), 0), outputTokens: pairs.reduce((sum, pair) => sum + (pair.usage?.outputTokens ?? 0), 0), totalTokens: pairs.reduce((sum, pair) => sum + (pair.usage?.totalTokens ?? 0), 0), costCny: pairs.reduce((sum, pair) => sum + (pair.usage?.costCny ?? 0), 0) } }),
+        timing: { screeningMs: 0, gateMs: 0, agentMs: Math.max(0, options.now() - startedAt), commitMs: 0 },
+        criteria: pairs.map(pair => pair.criteria ?? criteriaFrom(pair.gate?.level ?? 'L2', pair.gate?.verdict ?? 0, pair.decision?.shouldMerge === true ? 'merge' : 'keep')),
         ...(remaining.length === 0 ? {} : { remaining }),
+        ...(finalizeRows.length === 0 ? {} : { finalize: async () => {
+                for (const item of finalizeRows) {
+                    const removed = await pairLedger(options.io, options.home).transact(tx => {
+                        const current = tx.rows().find(entry => entry.id === item.id);
+                        return current === undefined ? true : tx.remove(item.id, 'committed', { unitId: item.unitId, evidenceSha256: item.evidenceSha256 }, current.version).ok;
+                    });
+                    if (!removed)
+                        throw new Error('row changed before commit record: ' + item.id);
+                    await dropStage(options.io, options.home, item.id);
+                }
+            } })
     };
 }
 //# sourceMappingURL=scan-run.js.map

package/lib/types/stage-tool-registry.d.ts

@@ -9,6 +9,13 @@ export declare class StageToolRegistry {
     bind(childId: string, context: StageToolContext): void;
     unbind(childId: string): void;
     clear(): void;
+    /** Diagnostic view for a refused tool call; names only, no content. */
+    snapshot(exec: unknown): {
+        readonly childId?: string;
+        readonly bound: number;
+        readonly authors: number;
+        readonly keys: readonly string[];
+    };
     resolve(exec: unknown): StageToolContext | undefined;
 }
 //# sourceMappingURL=stage-tool-registry.d.ts.map

package/lib/types/stage-tool-registry.js

@@ -9,9 +9,20 @@ export class StageToolRegistry {
     clear() {
         this.bindings.clear();
     }
+    /** Diagnostic view for a refused tool call; names only, no content. */
+    snapshot(exec) {
+        const childId = childIdOf(exec);
+        return { ...(childId === undefined ? {} : { childId }), bound: this.bindings.size, authors: [...this.bindings.values()].filter(context => context.phase === 'author').length, keys: [...this.bindings.keys()] };
+    }
     resolve(exec) {
         const childId = childIdOf(exec);
-        return childId === undefined ? undefined : this.bindings.get(childId);
+        const direct = childId === undefined ? undefined : this.bindings.get(childId);
+        if (direct !== undefined)
+            return direct;
+        // New-child sessions may expose a session id that differs from the channel's childId.
+        // Only a single author-phase binding is unambiguous; never guess with concurrent bindings.
+        const authors = [...this.bindings.values()].filter(context => context.phase === 'author');
+        return authors.length === 1 ? authors[0] : undefined;
     }
 }
 function childIdOf(exec) {