@lmzhen/dsh-evolution-merge 0.30.17 → 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

@@ -5,11 +5,13 @@
  * 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 { 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[];
@@ -24,9 +27,26 @@ export interface CreateScanPortsOptions {
     readonly timeoutMs: number;
     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);
@@ -72,20 +87,33 @@ 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);
-                        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