@telora/daemon 0.21.12 → 0.21.81

package/dist/delivery/delivery-lifecycle.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Delivery lifecycle - reusable functions for guard evaluation,
+ * stage transitions, and merge operations.
+ *
+ * Extracted from completion-handler.ts so that both the legacy
+ * per-delivery completion handler and the focus team lead
+ * can use the same logic.
+ *
+ * Key functions:
+ * - evaluateAndTransition(): evaluate guards and determine next stage
+ * - mergeDeliveryBranch(): merge a branch to integration
+ * - advanceDeliveryStage(): update delivery to its next workflow stage
+ */
+import type { DaemonConfig, Workflow, WorkflowTransition, PolicyFailureMode } from '../types/index.js';
+import { type DeliveryGateState } from '../queries/deliveries.js';
+import type { ReconcilerIssue } from './delivery-reconciler.js';
+export interface GuardEvalOutcome {
+    /** Whether the transition was blocked by a guard. */
+    blocked: boolean;
+    /** Whether to merge the agent's branch to integration. */
+    shouldMerge: boolean;
+    /** Whether to trigger a re-poll for next work. */
+    shouldTriggerRepoll: boolean;
+    /** Session status to record. */
+    sessionStatus: 'completed' | 'failed';
+    /** Human-readable exit reason. */
+    exitReason: string;
+    /** Structured gate state. Populated when blocked; null when all guards passed. */
+    gateState?: DeliveryGateState | null;
+}
+export interface MergeOutcome {
+    /** Whether the merge to integration succeeded. */
+    mergeSucceeded: boolean;
+    /** Updated exit reason string. */
+    exitReason: string;
+    /** If set, override the delivery status (e.g., back to queued on conflict). */
+    overrideDeliveryStatus?: string;
+    /** If set, override the delivery stage ID. */
+    overrideDeliveryStageId?: string | null;
+    /** The squash merge commit SHA (set on successful merge). */
+    commitSha?: string;
+}
+export interface StageAdvanceResult {
+    /** Whether the stage was advanced successfully. */
+    advanced: boolean;
+    /** The new delivery status. */
+    deliveryStatus: string;
+    /** The new delivery stage ID. */
+    deliveryStageId: string | null | undefined;
+    /** Whether guards blocked the transition. */
+    guardBlocked: boolean;
+    /** Whether to merge. */
+    shouldMerge: boolean;
+    /** Human-readable reason. */
+    exitReason: string;
+}
+export interface GuardEvalParams {
+    deliveryId: string;
+    organizationId: string;
+    workflowTransition: WorkflowTransition | null;
+    exitCode: number;
+    policyFailureMode: PolicyFailureMode;
+    deliveryName: string;
+    sessionId: string | null;
+}
+/**
+ * Evaluate guards at a stage transition for a delivery.
+ *
+ * This is the core guard evaluation logic extracted from completion-handler.ts.
+ * Can be called by:
+ * - The per-delivery completion handler (legacy)
+ * - The focus team lead (after detecting delivery issue completion)
+ */
+export declare function evaluateGuardsForDeliveryTransition(params: GuardEvalParams): Promise<GuardEvalOutcome>;
+export interface DeliveryStageAdvanceParams {
+    deliveryId: string;
+    deliveryName: string;
+    organizationId: string;
+    workflow: Workflow;
+    currentStageId: string;
+    /**
+     * The delivery's execution_status before this advance. Recorded as
+     * from_status on the delivery_transitions row. Optional for legacy callers;
+     * when omitted the transition is still logged with from_status = null.
+     */
+    fromStatus?: string | null;
+    exitCode: number;
+    openIssueCount: number;
+    /**
+     * The delivery's REAL issue list mapped to the reconciler's minimal shape
+     * ({ status, issueType }). The single-writer reconciler derives its decision
+     * from actual issue state through the shared predicate; this list must NEVER
+     * be synthesized from a count. A synthesized [{status:'Done',issueType:'Task'}]
+     * makes hasWorkIssues() unconditionally true, which silently defeats the
+     * queued-branch scoping gate (a zero-issue delivery would advance instead of
+     * holding in queued). Every caller passes the issues it already fetched.
+     */
+    reconcilerIssues: ReconcilerIssue[];
+    sessionCount: number;
+    policyFailureMode: PolicyFailureMode;
+    sessionId: string | null;
+    /**
+     * Focus owning this delivery. Used to look up the focus worktree when
+     * deriving `completion_artifacts` at terminal-stage advance.
+     */
+    focusId?: string;
+    /**
+     * Daemon config. Used to resolve the base ref (integration branch) when
+     * deriving `completion_artifacts` from the focus worktree.
+     */
+    config?: DaemonConfig;
+}
+/**
+ * Advance a delivery through its workflow stage.
+ *
+ * Given a delivery's current stage and workflow, determines the next stage,
+ * evaluates any guards on the transition, and updates the delivery status.
+ *
+ * Used by the focus team lead when all issues in a delivery are completed.
+ */
+export declare function advanceDeliveryStage(params: DeliveryStageAdvanceParams): Promise<StageAdvanceResult>;
+export interface DeliveryBranchMergeParams {
+    config: DaemonConfig;
+    branchName: string;
+    deliveryId: string;
+    deliveryName: string;
+    organizationId: string;
+    sessionId: string | null;
+    workflow: Workflow;
+    /** Focus ID for recording the merge in focus_merges. Optional for legacy per-delivery path. */
+    focusId?: string;
+}
+/**
+ * Merge a delivery's branch to the integration branch.
+ *
+ * Handles:
+ * - Merge to integration
+ * - Conflict escalation
+ * - Git state reporting
+ */
+export declare function mergeDeliveryBranch(params: DeliveryBranchMergeParams): Promise<MergeOutcome>;
+export { ADVANCE_BLOCK_ESCALATION_KIND, DEFAULT_AUTO_REMEDIATION_BUDGET, ensureWorktreeCommittedBeforeAdvance, __resetAutoRemediationAttempts, } from './delivery-advance-block.js';
+export type { EnsureWorktreeCommittedDeps } from './delivery-advance-block.js';
+//# sourceMappingURL=delivery-lifecycle.d.ts.map

package/dist/delivery/delivery-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delivery-lifecycle.d.ts","sourceRoot":"","sources":["../../src/delivery/delivery-lifecycle.ts"],"names":[],"mappings":"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"}

package/dist/delivery/delivery-lifecycle.js

@@ -0,0 +1,498 @@
+/**
+ * Delivery lifecycle - reusable functions for guard evaluation,
+ * stage transitions, and merge operations.
+ *
+ * Extracted from completion-handler.ts so that both the legacy
+ * per-delivery completion handler and the focus team lead
+ * can use the same logic.
+ *
+ * Key functions:
+ * - evaluateAndTransition(): evaluate guards and determine next stage
+ * - mergeDeliveryBranch(): merge a branch to integration
+ * - advanceDeliveryStage(): update delivery to its next workflow stage
+ */
+import { updateDeliveryStatus, updateDeliveryMergeCommitSha } from '../queries/deliveries.js';
+import { createEscalation } from '../queries/issues.js';
+import { createTransitionEvaluation } from '../queries/guards.js';
+import { mergeToIntegration } from '../git/exec.js';
+import { runGitSync, getMergeWorktreePath } from '../git/index.js';
+import { getStageByName, determineTransition } from '../workflow/workflow-engine.js';
+import { evaluateGuardsAtTransition, GuardEvaluationError } from '../guard/guard-evaluator.js';
+import { executeTriggers } from '../guard/trigger-executor.js';
+import { withRetry, ESCALATION_REASONS, ESCALATION_DISPOSITIONS, DELIVERY_STATUS } from '@telora/daemon-core';
+import { resolveReconciledWrite } from './delivery-reconciler-apply.js';
+import { recordFocusMerge } from '../queries/deliveries.js';
+import { getFocusWorktree } from '../focus/focus-worktree-state.js';
+import { deriveCompletionArtifactsFromWorktree } from './delivery-artifacts.js';
+import { createLogger } from '../shell/log.js';
+const log = createLogger({ module: 'guard' });
+// ── Guard evaluation (unified workflow system) ──────────────────────
+/**
+ * Evaluate guards at a stage transition for a delivery.
+ *
+ * This is the core guard evaluation logic extracted from completion-handler.ts.
+ * Can be called by:
+ * - The per-delivery completion handler (legacy)
+ * - The focus team lead (after detecting delivery issue completion)
+ */
+export async function evaluateGuardsForDeliveryTransition(params) {
+    const { deliveryId, organizationId, workflowTransition, exitCode, policyFailureMode, deliveryName, sessionId, } = params;
+    const baseOutcome = {
+        blocked: false,
+        shouldMerge: false,
+        shouldTriggerRepoll: false,
+        sessionStatus: 'completed',
+        exitReason: '',
+    };
+    if (!workflowTransition) {
+        return baseOutcome;
+    }
+    try {
+        const guardResult = await evaluateGuardsAtTransition(deliveryId, organizationId, workflowTransition.id, exitCode);
+        // Log warnings (soft enforcement failures)
+        for (const warning of guardResult.warnings) {
+            log.warn(`[guard] Soft warning on "${deliveryName}": ` +
+                `guard "${warning.guard_name}" conditions not met`);
+        }
+        if (!guardResult.should_proceed) {
+            // Hard guard blocked the transition
+            log.info(`[guard] Transition blocked for "${deliveryName}": ` +
+                `${guardResult.blocks.length} hard guard(s) failed`);
+            // Execute blocking triggers
+            const triggerResult = await executeTriggers(deliveryId, organizationId, workflowTransition.id, guardResult.triggers_to_execute);
+            let exitReason = `Guard blocked: ${guardResult.blocks.map(b => b.guard_name).join(', ')}.`;
+            if (triggerResult.spawnedSessionIds.length > 0) {
+                exitReason += ` Spawned ${triggerResult.spawnedSessionIds.length} guard agent(s).`;
+            }
+            const gateState = {
+                blocking: guardResult.blocks.map(b => ({ guardName: b.guard_name, passed: b.passed })),
+                warnings: guardResult.warnings.map(w => ({ guardName: w.guard_name, passed: w.passed })),
+                evaluatedAt: new Date().toISOString(),
+            };
+            return {
+                blocked: true,
+                shouldMerge: false,
+                shouldTriggerRepoll: false,
+                sessionStatus: 'completed',
+                exitReason,
+                gateState,
+            };
+        }
+        // All guards passed or only soft warnings -- execute pass/enter triggers
+        if (guardResult.triggers_to_execute.length > 0) {
+            await executeTriggers(deliveryId, organizationId, workflowTransition.id, guardResult.triggers_to_execute);
+        }
+    }
+    catch (err) {
+        const guardError = err instanceof GuardEvaluationError ? err : null;
+        const effectiveMode = resolveGuardFailureMode(policyFailureMode, guardError);
+        // Record evaluation error in audit trail
+        await recordGuardEvaluationError(err, guardError, deliveryId, organizationId, workflowTransition.id, effectiveMode);
+        if (effectiveMode === 'fail-closed') {
+            return await handleGuardFailClosed({
+                err: err,
+                guardError,
+                deliveryId,
+                deliveryName,
+                organizationId,
+                sessionId,
+                transitionId: workflowTransition.id,
+            });
+        }
+        // Fail-open: log and proceed
+        log.error(`[guard] GUARD EVALUATION FAILED for "${deliveryName}": ` +
+            `${err.message}. Proceeding without guard checks (fail-open).`);
+        return {
+            ...baseOutcome,
+            exitReason: `Warning: guard evaluation skipped due to error.`,
+        };
+    }
+    return baseOutcome;
+}
+// ── Stage advancement ───────────────────────────────────────────────
+/**
+ * Advance a delivery through its workflow stage.
+ *
+ * Given a delivery's current stage and workflow, determines the next stage,
+ * evaluates any guards on the transition, and updates the delivery status.
+ *
+ * Used by the focus team lead when all issues in a delivery are completed.
+ */
+export async function advanceDeliveryStage(params) {
+    const { deliveryId, deliveryName, organizationId, workflow, currentStageId, exitCode, openIssueCount, reconcilerIssues, sessionCount, policyFailureMode, sessionId, focusId, config, fromStatus, } = params;
+    // Determine transition via workflow engine
+    const transition = determineTransition({
+        workflow,
+        currentStageId,
+        exitCode,
+        openIssueCount,
+        attemptCount: sessionCount,
+        maxRetries: 5,
+    });
+    // Evaluate guards if there's a transition to a new stage
+    let guardOutcome = null;
+    if (transition.nextStage && transition.workflowTransition) {
+        guardOutcome = await evaluateGuardsForDeliveryTransition({
+            deliveryId,
+            organizationId,
+            workflowTransition: transition.workflowTransition,
+            exitCode,
+            policyFailureMode,
+            deliveryName,
+            sessionId,
+        });
+    }
+    // Determine final delivery status
+    let deliveryStatus;
+    let deliveryStageId;
+    let exitReason = transition.exitReason;
+    const guardBlocked = guardOutcome?.blocked ?? false;
+    if (guardBlocked) {
+        deliveryStatus = DELIVERY_STATUS.PAUSED;
+        deliveryStageId = currentStageId;
+        exitReason = guardOutcome.exitReason;
+    }
+    else if (transition.nextStage) {
+        deliveryStatus = transition.nextStage.name;
+        deliveryStageId = transition.nextStage.id;
+    }
+    else {
+        // Staying on current stage means re-queuing
+        const queuedStage = getStageByName(workflow, DELIVERY_STATUS.QUEUED);
+        deliveryStatus = queuedStage?.name ?? DELIVERY_STATUS.QUEUED;
+        deliveryStageId = queuedStage?.id;
+    }
+    // Single-writer reconciler self-check + authority. advanceDeliveryStage is the
+    // guarded graph writer for coding -> verify/paused (and the re-queue fallback);
+    // the reconciler models exactly this from (currentStatus, all-done, committed,
+    // guardVerdict). We run it for the reconciler-driven from-statuses, log any
+    // [reconciler-divergence], and (flag-gated, default-ON) write the reconciler's
+    // target. In parity the target equals the legacy decision, so this is a no-op;
+    // worktree-commit safety still ran on the daemon path before this call. The
+    // verify -> done routing is owned by the review-exit path, not advanceDeliveryStage,
+    // so verify is intentionally excluded here.
+    const RECONCILER_FROM = new Set([
+        DELIVERY_STATUS.CODING, DELIVERY_STATUS.QUEUED, DELIVERY_STATUS.VERIFY_FAILED,
+    ]);
+    if (fromStatus && RECONCILER_FROM.has(fromStatus)) {
+        // Feed the reconciler the delivery's REAL issue state (supplied by the
+        // caller), never a count-derived synthesis. This is what keeps the
+        // queued-branch scoping gate reachable: a zero-issue queued delivery
+        // arrives here with an empty list and the reconciler holds it in queued.
+        const decision = resolveReconciledWrite({
+            site: 'advance-stage',
+            deliveryId,
+            deliveryName,
+            legacyTarget: deliveryStatus,
+            input: {
+                currentStatus: fromStatus,
+                issues: reconcilerIssues,
+                // Worktree-commit safety is enforced by ensureWorktreeCommittedBeforeAdvance
+                // before this call; by here the worktree is committed.
+                gitState: { worktreeCommitted: true },
+                guardVerdict: { blocked: guardBlocked },
+                reviewState: null,
+            },
+        });
+        if (decision.target !== deliveryStatus) {
+            deliveryStatus = decision.target;
+            deliveryStageId = decision.target === DELIVERY_STATUS.PAUSED
+                ? currentStageId
+                : getStageByName(workflow, decision.target)?.id ?? deliveryStageId;
+        }
+    }
+    // Surface the gate state: populate when guards blocked so the UI can
+    // explain "waiting on" without an escalation; clear (null) on successful
+    // advance so stale entries don't haunt the row.
+    const gateStateForUpdate = guardBlocked
+        ? guardOutcome?.gateState ?? null
+        : null;
+    // Derive completion_artifacts at the terminal-stage advance so the drift
+    // evaluator has file references for the daemon-closed path -- the dialog
+    // that previously prompted the operator is gone. Best-effort: skip when
+    // the focus worktree isn't registered (legacy callers, teamless cleanup)
+    // or when the diff is empty / git fails.
+    let completionArtifactsForUpdate;
+    if (!guardBlocked && deliveryStatus === DELIVERY_STATUS.DONE && focusId && config) {
+        const worktree = getFocusWorktree(focusId);
+        if (worktree) {
+            const derived = deriveCompletionArtifactsFromWorktree(worktree.worktreePath, config.integrationBranch);
+            if (derived) {
+                completionArtifactsForUpdate = derived;
+            }
+        }
+    }
+    // Update delivery status. When the target status differs from the prior
+    // status, attach a transition record so the stage-transition log captures
+    // the move (queued->coding, coding->verify, verify->done, the guard-blocked
+    // ->paused exit, and the re-queue back-path).
+    const transitionRecord = fromStatus !== deliveryStatus
+        ? { organizationId, fromStatus: fromStatus ?? null }
+        : undefined;
+    try {
+        await updateDeliveryStatus(deliveryId, deliveryStatus, deliveryStageId, gateStateForUpdate, completionArtifactsForUpdate, transitionRecord);
+        log.info(`Delivery "${deliveryName}" set to ${deliveryStatus}`);
+    }
+    catch (err) {
+        log.warn(`Failed to set delivery "${deliveryName}" to ${deliveryStatus}:`, err.message);
+    }
+    return {
+        advanced: transition.nextStage !== null && !guardBlocked,
+        deliveryStatus,
+        deliveryStageId,
+        guardBlocked,
+        shouldMerge: guardBlocked ? false : transition.shouldMerge,
+        exitReason,
+    };
+}
+// ── Merge operations ────────────────────────────────────────────────
+/**
+ * Merge a delivery's branch to the integration branch.
+ *
+ * Handles:
+ * - Merge to integration
+ * - Conflict escalation
+ * - Git state reporting
+ */
+export async function mergeDeliveryBranch(params) {
+    const { config, branchName, deliveryId, deliveryName, organizationId, sessionId, workflow, focusId } = params;
+    log.info(`Attempting to merge ${branchName} into ${config.integrationBranch}...`);
+    const onRollbackFailure = (details) => {
+        withRetry(() => createEscalation({
+            organizationId,
+            sessionId: sessionId ?? '',
+            issueId: null,
+            reasonType: ESCALATION_REASONS.ERROR_ENCOUNTERED,
+            disposition: ESCALATION_DISPOSITIONS.NEEDS_OPERATOR,
+            anchor: { deliveryId, focusId, branch: branchName },
+            description: `CRITICAL: Push failed AND rollback failed. Integration branch is corrupt.\n\n` +
+                `**Delivery:** ${deliveryName}\n` +
+                `**Branch:** ${details.branch}\n` +
+                `**Attempted rollback to:** ${details.attemptedRollbackRef}\n` +
+                `**Current HEAD:** ${details.currentHead}\n\n` +
+                `All merge operations are blocked until manual recovery.`,
+            whatWasTried: `Push to origin failed for ${details.branch}. Attempted rollback to ${details.attemptedRollbackRef} also failed.`,
+            helpNeeded: `Manually reset the branch: git reset --hard origin/${details.branch}. Then restart the daemon.`,
+        }), { maxAttempts: 3, label: 'escalation-rollback-failure' }).catch((escErr) => {
+            log.error(`CRITICAL: Failed to create escalation for rollback failure: ${escErr.message}`);
+        });
+    };
+    const mergeResult = await mergeToIntegration({ config, branchName, deliveryName, deliveryId, onRollbackFailure });
+    if (mergeResult.success) {
+        const exitReason = `Merged to ${config.integrationBranch}.`;
+        log.info(`Successfully merged ${branchName} to ${config.integrationBranch}`);
+        // Note: merged_to_integration git state is reported by the caller
+        // (mergeFocusBranch) for all deliveries in the focus to avoid duplicates.
+        // Persist the merge commit SHA on the delivery record (fire-and-forget)
+        if (mergeResult.commitSha) {
+            updateDeliveryMergeCommitSha(deliveryId, mergeResult.commitSha).catch(err => log.warn(`[mergeCommitSha] Failed to record merge commit SHA:`, err.message));
+        }
+        // Record focus merge with constituent commits (fire-and-forget)
+        if (focusId && mergeResult.commitSha) {
+            const commitShas = extractConstituentCommits(config, branchName, mergeResult.preMergeRef);
+            recordFocusMerge({
+                organizationId,
+                focusId,
+                mergeCommitSha: mergeResult.commitSha,
+                commitShas,
+                branchName,
+                // The pre-merge boundary bounds the merged contribution even when the
+                // merge-back fast-forwarded (no merge commit) -- see the fast-forward-safe
+                // source in resolveDeliveryDiffSource.
+                ...(mergeResult.preMergeRef ? { preMergeRef: mergeResult.preMergeRef } : {}),
+            }).catch(err => log.warn(`[focusMerge] Failed to record focus merge:`, err.message));
+        }
+        // A merge that recorded NO bookkeeping (its sha could not be observed) is a
+        // fault, not a silent skip. merge.ts already emitted the loud RECORDED-NOTHING
+        // FAULT at merge time; surface it here too so the write-site's silence -- the
+        // exact place the ~19-minute-later gate blindness originates -- is broken.
+        if (mergeResult.shaUnobserved) {
+            log.warn(`[focusMerge] delivery ${deliveryId} on branch ${branchName} merged to ` +
+                `${config.integrationBranch} but recorded NO bookkeeping (merge sha unobserved) -- ` +
+                `verify evidence for this delivery will be unrecoverable from the focus_merges record.`);
+        }
+        return { mergeSucceeded: true, exitReason, commitSha: mergeResult.commitSha };
+    }
+    // Handle merge conflicts
+    const conflictedFiles = mergeResult.conflictedFiles;
+    if (conflictedFiles && conflictedFiles.length > 0) {
+        const exitReason = `Agent completed but merge had conflicts in ${conflictedFiles.length} file(s). Escalated for resolution.`;
+        log.warn(`Merge conflict: ${conflictedFiles.join(', ')}`);
+        try {
+            await withRetry(() => createEscalation({
+                organizationId,
+                sessionId: sessionId ?? '',
+                issueId: null,
+                reasonType: ESCALATION_REASONS.ERROR_ENCOUNTERED,
+                disposition: ESCALATION_DISPOSITIONS.NEEDS_OPERATOR,
+                anchor: { deliveryId, focusId, branch: branchName },
+                description: `Merge conflict merging agent branch into integration.\n\n` +
+                    `**Delivery:** ${deliveryName}\n` +
+                    `**Source branch:** ${mergeResult.sourceBranch}\n` +
+                    `**Target branch:** ${mergeResult.targetBranch}\n` +
+                    `**Conflicted files:**\n${conflictedFiles.map(f => `- ${f}`).join('\n')}`,
+                whatWasTried: `Attempted automatic merge of ${branchName} into ${config.integrationBranch} after agent completed successfully.`,
+                helpNeeded: `Resolve the merge conflicts between ${mergeResult.sourceBranch} and ${mergeResult.targetBranch}, then re-queue the delivery.`,
+            }), { maxAttempts: 3, label: 'escalation-merge-conflict' });
+            log.info(`Created escalation for merge conflict`);
+        }
+        catch (escErr) {
+            log.error(`CRITICAL: Failed to create escalation for merge conflict after retries: ${escErr.message}. Delivery: "${deliveryName}"`);
+        }
+        const queuedStage = getStageByName(workflow, DELIVERY_STATUS.QUEUED);
+        return {
+            mergeSucceeded: false,
+            exitReason,
+            overrideDeliveryStatus: queuedStage?.name ?? DELIVERY_STATUS.QUEUED,
+            overrideDeliveryStageId: queuedStage?.id,
+        };
+    }
+    // General merge failure
+    const exitReason = `Merge failed: ${mergeResult.error}. Branch ${branchName} preserved for manual merge.`;
+    log.warn(`Merge to integration failed: ${mergeResult.error}`);
+    return { mergeSucceeded: false, exitReason };
+}
+// ── Constituent commit extraction ───────────────────────────────────
+/**
+ * Extract the list of commit SHAs that were merged from a branch.
+ *
+ * Uses `git log --format=%H <preMergeRef>..<branchName>` in the merge worktree
+ * to list all commits on the branch that were not already on the target branch
+ * before the merge.
+ *
+ * Returns an empty array if extraction fails (best-effort).
+ */
+function extractConstituentCommits(config, branchName, preMergeRef) {
+    if (!preMergeRef) {
+        return [];
+    }
+    try {
+        const mwt = getMergeWorktreePath(config);
+        const result = runGitSync(['log', '--format=%H', `${preMergeRef}..${branchName}`], mwt);
+        if (result.success && result.output) {
+            return result.output.split('\n').filter(Boolean);
+        }
+    }
+    catch (err) {
+        log.warn(`[focusMerge] Failed to extract constituent commits:`, err.message);
+    }
+    return [];
+}
+// ── Guard failure helpers ───────────────────────────────────────────
+/**
+ * Resolve the effective failure mode for a guard evaluation error.
+ */
+function resolveGuardFailureMode(daemonMode, guardError) {
+    if (guardError?.hasHardEnforcementGuards) {
+        return 'fail-closed';
+    }
+    if (guardError?.fetchedGuards !== null && guardError?.fetchedGuards !== undefined) {
+        return 'fail-open';
+    }
+    return daemonMode;
+}
+/**
+ * Handle fail-closed for guard evaluation errors.
+ */
+async function handleGuardFailClosed(params) {
+    const { err, guardError, deliveryId, deliveryName, organizationId, sessionId, transitionId } = params;
+    const guardNames = guardError?.guardNames ?? [];
+    const guardInfo = guardNames.length > 0
+        ? ` Guards: ${guardNames.join(', ')}.`
+        : '';
+    log.error(`[guard] GUARD EVALUATION FAILED for "${deliveryName}": ` +
+        `${err.message}. Transition blocked per fail-closed configuration.${guardInfo}`);
+    const exitReason = `Guard evaluation failed, transition blocked per fail-closed configuration.${guardInfo}`;
+    // NOTE: this handler does NOT write the paused status. It returns blocked:true
+    // and the CALLER performs the single paused write -- advanceDeliveryStage
+    // (delivery-lifecycle.ts) writes it with the correct from_status + transition
+    // record, and the legacy handleAgentCompletion path writes it too. Writing
+    // here as well produced two delivery_transitions rows per pause (one with a
+    // null from_status from here, one with the real from_status from the caller),
+    // so the audit trail read as two moves. Single-writer: one decision, one write.
+    try {
+        await withRetry(() => createEscalation({
+            organizationId,
+            sessionId: sessionId ?? '',
+            issueId: null,
+            reasonType: ESCALATION_REASONS.ERROR_ENCOUNTERED,
+            disposition: ESCALATION_DISPOSITIONS.NEEDS_OPERATOR,
+            anchor: { deliveryId },
+            description: `Guard evaluation failed (fail-closed). Transition blocked.\n\n` +
+                `**Delivery:** ${deliveryName}\n` +
+                `**Transition:** ${transitionId}\n` +
+                `**Error:** ${err.message}\n` +
+                (guardNames.length > 0 ? `**Affected guards:** ${guardNames.join(', ')}\n` : '') +
+                `\nThe delivery has been paused. Review the error and re-queue when resolved.`,
+            whatWasTried: `Guard evaluation at stage transition failed after retries. ` +
+                `Fail-closed mode is active${guardError?.hasHardEnforcementGuards ? ' (hard enforcement guards detected)' : ''}.`,
+            helpNeeded: `Investigate the guard evaluation failure, resolve the underlying issue, then re-queue the delivery.`,
+        }), { maxAttempts: 3, label: 'escalation-guard-fail-closed' });
+        log.info(`Created escalation for guard evaluation failure (fail-closed)`);
+    }
+    catch (escErr) {
+        log.error(`CRITICAL: Failed to create escalation for guard fail-closed after retries: ${escErr.message}. ` +
+            `Delivery: "${deliveryName}"`);
+    }
+    return {
+        blocked: true,
+        shouldMerge: false,
+        shouldTriggerRepoll: false,
+        sessionStatus: 'completed',
+        exitReason,
+    };
+}
+/**
+ * Record guard evaluation errors in the audit trail (best-effort).
+ */
+async function recordGuardEvaluationError(err, guardError, deliveryId, organizationId, transitionId, effectiveMode) {
+    const errorDetails = {
+        error: err.message,
+        failure_mode: effectiveMode,
+    };
+    if (guardError?.fetchedGuards && guardError.fetchedGuards.length > 0) {
+        for (const guard of guardError.fetchedGuards) {
+            try {
+                await createTransitionEvaluation({
+                    organization_id: organizationId,
+                    entity_type: 'delivery',
+                    entity_id: deliveryId,
+                    transition_id: transitionId,
+                    guard_id: guard.id,
+                    result: 'error',
+                    blocked: effectiveMode === 'fail-closed',
+                    enforcement_level: guard.enforcement,
+                    evaluation_details: errorDetails,
+                });
+            }
+            catch (auditErr) {
+                log.warn(`[guard] Failed to record evaluation error for "${guard.name}":`, auditErr.message);
+            }
+        }
+    }
+    else {
+        try {
+            await createTransitionEvaluation({
+                organization_id: organizationId,
+                entity_type: 'delivery',
+                entity_id: deliveryId,
+                transition_id: transitionId,
+                guard_id: null,
+                result: 'error',
+                blocked: effectiveMode === 'fail-closed',
+                enforcement_level: null,
+                evaluation_details: errorDetails,
+            });
+        }
+        catch (auditErr) {
+            log.warn(`Failed to record evaluation error in audit trail:`, auditErr.message);
+        }
+    }
+}
+// ── Pre-advance precondition: worktree must be committed ─────────────
+// The advance-block precondition + its dedup-aware escalation live in
+// delivery-advance-block.ts (kept under the daemon file-size limit). Re-exported
+// here so existing importers (listener-auto-advance, completion/*, tests) keep
+// their import path.
+export { ADVANCE_BLOCK_ESCALATION_KIND, DEFAULT_AUTO_REMEDIATION_BUDGET, ensureWorktreeCommittedBeforeAdvance, __resetAutoRemediationAttempts, } from './delivery-advance-block.js';
+//# sourceMappingURL=delivery-lifecycle.js.map