@lmzhen/dsh-evolution-merge 0.30.18 → 0.30.19

package/lib/types/run-shell.js

@@ -1,4 +1,5 @@
 import { writeMergeReport } from "./report.js";
+import { writeRunMeta } from "./domain/run-coordinator.js";
 function emptyDraft(reason) {
     return {
         stopReason: 'failed',
@@ -8,23 +9,45 @@ function emptyDraft(reason) {
         notes: [reason],
     };
 }
+export async function retryMergeReport(io, home, report) {
+    return await writeMergeReport(io, home, report);
+}
 export async function withMergeRun(options) {
     const handle = await options.registry.begin('merge', {
         command: options.command,
-        mergeStatus: 'running',
         ...(options.total === undefined ? {} : { total: options.total }),
+        ...(options.parentRunId === undefined ? {} : { parentRunId: options.parentRunId }),
     });
     const startedAt = handle.startedAt;
     const stage = (name, progress) => options.registry.stage(handle.id, name, progress);
     await stage('screening', options.total === undefined ? undefined : { done: 0, total: options.total });
+    await writeRunMeta(options.io, options.home, { version: 1, runId: handle.id, ...(options.parentRunId === undefined ? {} : { parentRunId: options.parentRunId }), ...(options.pairKey === undefined ? {} : { pairKey: options.pairKey }), pairCount: options.pairCount ?? (options.pairKey === undefined ? 0 : 1), phase: 'running', approval: options.approval.mergeApproval ? 'pending' : 'approved', createdAt: new Date(startedAt).toISOString(), updatedAt: new Date(options.now()).toISOString() });
     const finish = async () => {
         let draft;
+        const runController = new AbortController();
+        const onAbort = () => { runController.abort(); };
+        handle.signal.addEventListener('abort', onAbort, { once: true });
+        let timer;
+        const timeoutMinutes = options.timeoutMinutes;
+        const timeout = timeoutMinutes === undefined || timeoutMinutes <= 0 ? undefined : new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                runController.abort();
+                reject(new Error('merge run timed out after ' + String(timeoutMinutes) + ' minutes'));
+            }, timeoutMinutes * 60_000);
+        });
         try {
-            draft = await options.body({ runId: handle.id, startedAt, signal: handle.signal, stage });
+            draft = timeout === undefined
+                ? await options.body({ runId: handle.id, startedAt, signal: runController.signal, stage })
+                : await Promise.race([options.body({ runId: handle.id, startedAt, signal: runController.signal, stage }), timeout]);
         }
         catch (error) {
             draft = emptyDraft('run body failed: ' + (error instanceof Error ? error.message : String(error)));
         }
+        finally {
+            if (timer !== undefined)
+                clearTimeout(timer);
+            handle.signal.removeEventListener('abort', onAbort);
+        }
         const report = {
             schemaVersion: 2,
             runId: handle.id,
@@ -39,6 +62,13 @@ export async function withMergeRun(options) {
             totals: draft.totals,
             notes: draft.notes,
             ...(draft.remaining === undefined ? {} : { remaining: draft.remaining }),
+            ...(draft.reportOnly === undefined ? {} : { reportOnly: draft.reportOnly }),
+            ...(draft.validationFailures === undefined ? {} : { validationFailures: draft.validationFailures }),
+            ...(draft.archived === undefined ? {} : { archived: draft.archived }),
+            ...(draft.commit === undefined ? {} : { commit: draft.commit }),
+            ...(draft.usage === undefined ? {} : { usage: draft.usage }),
+            ...(draft.timing === undefined ? {} : { timing: draft.timing }),
+            ...(draft.criteria === undefined ? {} : { criteria: draft.criteria }),
         };
         let reportPath;
         try {
@@ -48,14 +78,28 @@ export async function withMergeRun(options) {
             await options.registry.settle(handle.id, { state: 'failed', failure: 'report write failed: ' + (error instanceof Error ? error.message : String(error)) });
             return { ok: false, runId: handle.id, message: 'report write failed' };
         }
+        try {
+            await draft.finalize?.();
+        }
+        catch (error) {
+            await options.registry.settle(handle.id, { state: 'failed', resultRef: reportPath, failure: 'post-report finalize failed: ' + (error instanceof Error ? error.message : String(error)) });
+            return { ok: false, runId: handle.id, message: 'post-report finalize failed', reportPath };
+        }
         const runState = report.stopReason === 'completed'
             ? 'succeeded'
             : report.stopReason === 'cancelled'
                 ? 'cancelled'
                 : 'failed';
-        const awaiting = report.pairs.some(pair => pair.outcome === 'pending');
-        const mergeStatus = awaiting ? 'awaiting-approval' : runState;
-        await options.registry.settle(handle.id, { state: runState, resultRef: reportPath, mergeStatus, ...(runState === 'failed' ? { failure: 'merge ' + report.stopReason } : {}) });
+        await options.registry.settle(handle.id, { state: runState, resultRef: reportPath, ...(runState === 'failed' ? { failure: 'merge ' + report.stopReason } : {}) });
+        // FR-RUN-04: awaiting-approval is a fact about THIS run, not about the approval mode.
+        // Only a completed scan/pair that actually left pending rows is waiting for a human;
+        // a failed/cancelled run (or one that produced nothing to approve) settled long ago,
+        // and approve/resume are themselves the answer to a pending window.
+        const awaiting = options.approval.mergeApproval
+            && (options.command === 'scan' || options.command === 'pair')
+            && report.stopReason === 'completed'
+            && report.totals.pending > 0;
+        await writeRunMeta(options.io, options.home, { version: 1, runId: handle.id, ...(options.parentRunId === undefined ? {} : { parentRunId: options.parentRunId }), ...(options.pairKey === undefined ? {} : { pairKey: options.pairKey }), pairCount: options.pairCount ?? (options.pairKey === undefined ? 0 : 1), phase: awaiting ? 'awaiting-approval' : 'settled', approval: awaiting ? 'pending' : 'approved', stopReason: report.stopReason, reportRef: reportPath, createdAt: new Date(startedAt).toISOString(), updatedAt: new Date(options.now()).toISOString() });
         if (report.stopReason === 'completed')
             return { ok: true, runId: handle.id, reportPath, report };
         return { ok: false, runId: handle.id, message: 'merge ' + report.stopReason, reportPath };

package/lib/types/runtime.d.ts

@@ -1,8 +1,3 @@
-/**
- * The merge command runtime: cards -> screening -> channel ports -> scan/approve.
- * 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 { SkillLibrary, type EvolutionIoLike, type UnitTransaction } from '@lmzhen/dsh-evolution-core';
 import { type MergeCandidate } from './contracts.ts';
 import type { MergeParams } from './params.ts';