reqon-dsl 0.3.0 → 0.4.0

package/dist/interpreter/executor.js

@@ -16,24 +16,33 @@
  */
 import { isParallelStage } from '../ast/nodes.js';
 import { createContext, childContext, setVariable } from './context.js';
+import { createHash } from 'node:crypto';
 import { evaluate } from './evaluator.js';
 import { SourceManager } from './source-manager.js';
 import { StoreManager } from './store-manager.js';
 import { AdaptiveRateLimiter } from '../auth/rate-limiter.js';
 import { CircuitBreaker } from '../auth/circuit-breaker.js';
 import { createExecutionState, findResumePoint, FileExecutionStore, } from '../execution/index.js';
-import { FileSyncStore } from '../sync/index.js';
+import { FileSyncStore, LogBackedSyncStore } from '../sync/index.js';
 import { FetchHandler } from './fetch-handler.js';
 import { ForHandler, MapHandler, ValidateHandler, StoreHandler, MatchHandler, ApplyHandler, WebhookHandler, PauseHandler, SkipSignal, AbortError, RetrySignal, JumpSignal, QueueSignal, } from './step-handlers/index.js';
 import { createStructuredLogger } from '../observability/index.js';
 import { PauseSignal } from './signals.js';
 import { FileTraceStore, createTraceRecorder, } from '../trace/index.js';
-import { FilePauseStore, createPauseManager, } from '../pause/index.js';
+import { FilePauseStore, LogBackedPauseStore, createPauseManager, } from '../pause/index.js';
+import { sleep } from '../utils/async.js';
+import { redactNamedValue } from '../utils/redact.js';
+import { effectId, loadState } from '../execution-log/index.js';
+import { generateExecutionId } from '../execution/index.js';
+/** Max parallel-stage actions running concurrently (bounds fan-out). */
+const MAX_PARALLEL_ACTIONS = 8;
 export class MissionExecutor {
     config;
     ctx;
     errors = [];
     actionsRun = [];
+    /** Monotonic key generator for queued values lacking an id. */
+    queueCounter = 0;
     transforms = new Map();
     rateLimiter;
     circuitBreaker;
@@ -45,7 +54,15 @@ export class MissionExecutor {
     missionName;
     eventEmitter;
     logger;
-    stepIndex = 0;
+    executionLog;
+    /** Stable id used for the execution event log (independent of persistState). */
+    logExecutionId;
+    /** Effect ids already applied (from the log) — replay skips these. */
+    appliedEffects = new Set();
+    /** Backfill page progress per step id (from the log) — resumes pagination. */
+    pageProgress = new Map();
+    /** The pause being resumed on this run — its step replays past, not into, a pause. */
+    resumingPause;
     debugController;
     traceRecorder;
     traceStore;
@@ -121,6 +138,7 @@ export class MissionExecutor {
         }
         // Initialize event emitter if provided
         this.eventEmitter = config.eventEmitter;
+        this.executionLog = config.executionLog;
         // Initialize logger if verbose or provided
         if (config.logger) {
             this.logger = config.logger;
@@ -145,9 +163,15 @@ export class MissionExecutor {
         // Initialize trace store
         this.traceStore =
             config.traceStore ?? new FileTraceStore(`${config.dataDir ?? '.reqon-data'}/traces`);
-        // Initialize pause store and manager
+        // Initialize pause store and manager. In durable mode the execution log is
+        // the single source of truth — pause state (deadline, triggers, checkpoint)
+        // is recorded as pause events and folded back, rather than kept in a
+        // separate pause file.
         this.pauseStore =
-            config.pauseStore ?? new FilePauseStore(`${config.dataDir ?? '.reqon-data'}/pauses`);
+            config.pauseStore ??
+                (config.executionLog
+                    ? new LogBackedPauseStore(config.executionLog)
+                    : new FilePauseStore(`${config.dataDir ?? '.reqon-data'}/pauses`));
         this.pauseManager =
             config.pauseManager ??
                 createPauseManager({
@@ -171,6 +195,42 @@ export class MissionExecutor {
         }
         // Initialize or resume execution state
         await this.initializeExecutionState(mission);
+        // Establish a stable id for the execution log. On resume we reuse the prior
+        // id (so replay reads the same log); otherwise a fresh id.
+        this.logExecutionId =
+            this.executionState?.id ?? this.config.resumeFrom ?? generateExecutionId();
+        // Load already-applied effects from the log so replay skips them, and note
+        // a pending pause so we can record its resumption below.
+        let pendingPauseId;
+        let alreadyResumedPauseId;
+        if (this.executionLog) {
+            const prior = await loadState(this.executionLog, this.logExecutionId);
+            this.appliedEffects = new Set(prior.appliedEffects);
+            this.pageProgress = prior.pageProgress;
+            pendingPauseId = prior.pendingPauseId;
+            // A resume trigger may have recorded `pause.resumed` already; if the run
+            // didn't finish, we still need to replay past that pause.
+            alreadyResumedPauseId = prior.pendingPauseId ? undefined : prior.resumedPauseId;
+        }
+        await this.logEvent({ type: 'mission.started', mission: mission.name });
+        // If the prior log ended paused, this run is resuming that pause. Record it
+        // so the log's folded status leaves 'paused' before replay continues, and
+        // load the pause's checkpoint so the replayed pause step resumes past it
+        // (restoring captured state) rather than pausing again.
+        if (pendingPauseId) {
+            await this.logEvent({
+                type: 'pause.resumed',
+                pauseId: pendingPauseId,
+                resumedBy: this.config.resumeFrom ? 'resume' : 'replay',
+            });
+            this.resumingPause = await this.loadResumingPause(pendingPauseId);
+        }
+        else if (alreadyResumedPauseId) {
+            // The pause was already marked resumed out of band (by a webhook/timeout
+            // trigger) but the run didn't continue past it. Replay past it now without
+            // recording a second `pause.resumed` — otherwise the step re-pauses forever.
+            this.resumingPause = await this.loadResumingPause(alreadyResumedPauseId);
+        }
         // Initialize trace recorder if tracing is enabled
         if (mission.trace && this.traceStore && this.executionState) {
             this.traceRecorder = createTraceRecorder({
@@ -192,6 +252,7 @@ export class MissionExecutor {
                 this.executionState.duration = Date.now() - startTime;
                 await this.saveExecutionState();
             }
+            await this.logEvent({ type: 'mission.completed' });
         }
         catch (error) {
             // PauseSignal is not an error - execution was intentionally paused
@@ -199,7 +260,15 @@ export class MissionExecutor {
                 this.log('Execution paused');
                 this.currentPauseId = error.pauseId;
                 // State is already set to 'paused' in checkPause() or pause handler
-                // Don't record as error, just let execution end
+                // Don't record as error, just let execution end.
+                //
+                // A LogBackedPauseStore already appended pause.created (with the full
+                // pause payload) when the pause manager saved it, so only emit the bare
+                // event here when the pause store is *not* the log itself — otherwise
+                // we'd record the pause twice.
+                if (error.pauseId && !(this.pauseStore instanceof LogBackedPauseStore)) {
+                    await this.logEvent({ type: 'pause.created', pauseId: error.pauseId });
+                }
             }
             else {
                 this.errors.push({
@@ -215,6 +284,7 @@ export class MissionExecutor {
                     this.executionState.duration = Date.now() - startTime;
                     await this.saveExecutionState();
                 }
+                await this.logEvent({ type: 'mission.failed', error: error.message });
             }
         }
         const duration = Date.now() - startTime;
@@ -273,7 +343,7 @@ export class MissionExecutor {
             actionsRun: this.actionsRun,
             errors: this.errors,
             stores: this.ctx.stores,
-            executionId: this.executionState?.id,
+            executionId: this.executionState?.id ?? this.logExecutionId,
             state: this.executionState,
             traceId: this.traceRecorder ? this.executionState?.id : undefined,
             pauseId: this.currentPauseId,
@@ -360,10 +430,14 @@ export class MissionExecutor {
     async executeMission(mission) {
         this.log(`Executing mission: ${mission.name}`);
         this.missionName = mission.name;
-        // Initialize sync store
+        // Initialize sync store. In durable mode the execution log is the single
+        // source of truth, so sync checkpoints are read back as a view over the log
+        // rather than from a separate sync file.
         this.syncStore =
             this.config.syncStore ??
-                new FileSyncStore(mission.name, `${this.config.dataDir ?? '.reqon-data'}/sync`);
+                (this.executionLog
+                    ? new LogBackedSyncStore(this.executionLog, mission.name)
+                    : new FileSyncStore(mission.name, `${this.config.dataDir ?? '.reqon-data'}/sync`));
         // Initialize sources using SourceManager
         await this.sourceManager.initializeSources(mission.sources, this.ctx);
         // Initialize stores using StoreManager
@@ -414,11 +488,27 @@ export class MissionExecutor {
             // Track current stage index for pause handler
             this.currentStageIndex = i;
             // Execute stage (parallel or sequential)
-            if (isParallelStage(stage)) {
-                await this.executeParallelStage(i, stage, actions, mission);
+            try {
+                if (isParallelStage(stage)) {
+                    await this.executeParallelStage(i, stage, actions, mission);
+                }
+                else if (stage.action) {
+                    await this.executeSequentialStage(i, stage.action, actions, mission);
+                }
             }
-            else if (stage.action) {
-                await this.executeSequentialStage(i, stage.action, actions, mission);
+            catch (error) {
+                // A jump directive redirects the pipeline to a named action's stage.
+                if (error instanceof JumpSignal) {
+                    const targetIndex = mission.pipeline.stages.findIndex((s) => !isParallelStage(s) && s.action === error.action);
+                    if (targetIndex === -1) {
+                        throw new Error(`Jump target action not found in pipeline: ${error.action}`);
+                    }
+                    this.log(`Jump to action '${error.action}' (stage ${targetIndex})`);
+                    i = targetIndex - 1; // loop's i++ lands on the target stage
+                    this.updateControlServerState();
+                    continue;
+                }
+                throw error;
             }
             // Update control server with latest state after each stage
             this.updateControlServerState();
@@ -478,6 +568,11 @@ export class MissionExecutor {
             });
         }
         catch (error) {
+            // A jump directive is flow control, not a stage failure — let it bubble
+            // to the mission loop without polluting stage state.
+            if (error instanceof JumpSignal) {
+                throw error;
+            }
             // Mark stage as failed
             this.updateStageState(stageIndex, {
                 status: 'failed',
@@ -505,6 +600,39 @@ export class MissionExecutor {
             throw error; // Re-throw to stop execution
         }
     }
+    /**
+     * Run all settled-style tasks with a bounded number in flight at once,
+     * preserving result order. Caps fan-out so a wide `run [...]` can't open an
+     * unbounded number of concurrent HTTP/store operations.
+     */
+    async settleWithLimit(tasks, limit) {
+        const results = new Array(tasks.length);
+        let next = 0;
+        const worker = async () => {
+            for (let i = next++; i < tasks.length; i = next++) {
+                try {
+                    results[i] = { status: 'fulfilled', value: await tasks[i]() };
+                }
+                catch (reason) {
+                    results[i] = { status: 'rejected', reason };
+                }
+            }
+        };
+        const workerCount = Math.min(Math.max(1, limit), tasks.length);
+        await Promise.all(Array.from({ length: workerCount }, () => worker()));
+        return results;
+    }
+    /**
+     * Execute a `run [A, B, ...]` stage.
+     *
+     * Failure semantics are **complete-then-fail**: every branch runs to
+     * completion (bounded by MAX_PARALLEL_ACTIONS in flight), then the stage
+     * fails if any branch failed. There is no cancellation of siblings and no
+     * rollback — a branch that committed store writes keeps them even if another
+     * branch failed. Each branch gets its own action scope (step counter +
+     * checkpoints); stores/sources/schemas are shared, so parallel branches that
+     * write the same key get last-writer-wins and should target disjoint keys.
+     */
     async executeParallelStage(stageIndex, stage, actions, mission) {
         const actionNames = stage.actions;
         const stageName = `[${actionNames.join(', ')}]`;
@@ -539,8 +667,9 @@ export class MissionExecutor {
         });
         this.log(`Executing parallel stage: ${stageName}`);
         try {
-            // Execute all actions in parallel
-            const results = await Promise.allSettled(actionDefs.map((action) => this.executeAction(action)));
+            // Execute all actions in parallel, bounded to MAX_PARALLEL_ACTIONS in
+            // flight. allSettled semantics: every started branch runs to completion.
+            const results = await this.settleWithLimit(actionDefs.map((action) => () => this.executeAction(action)), MAX_PARALLEL_ACTIONS);
             // Check for failures
             const failures = [];
             for (let i = 0; i < results.length; i++) {
@@ -606,27 +735,115 @@ export class MissionExecutor {
     }
     async executeAction(action) {
         this.log(`Executing action: ${action.name}`);
-        // Create a child context for this action with its own response scope
-        // This allows parallel actions to have independent response values
-        const actionCtx = childContext(this.ctx);
-        for (const step of action.steps) {
-            await this.executeStep(step, action.name, actionCtx);
+        // Flow-control directives surface as thrown signals from a step (typically
+        // a `match` arm). Handle them at the action boundary: skip stops the rest
+        // of the action, queue stashes a value and stops, retry re-runs the whole
+        // action with backoff. Jump/Pause propagate to the mission loop.
+        const MAX_RETRY_FALLBACK = 3;
+        let attempt = 0;
+        for (;;) {
+            // Create a child context for this action with its own response scope and
+            // its own action scope (step counter + deferred checkpoints). Each attempt
+            // gets a fresh scope, so a retry's fetch doesn't double-record and so
+            // parallel actions never share a counter or checkpoint list.
+            const actionCtx = childContext(this.ctx);
+            actionCtx.actionScope = { stepIndex: 0, attempt, pendingCheckpoints: [] };
+            try {
+                for (const step of action.steps) {
+                    await this.executeStep(step, action.name, actionCtx);
+                }
+                // Flush checkpoints for fetches that completed without a later store.
+                await this.flushPendingCheckpoints(actionCtx);
+                return;
+            }
+            catch (error) {
+                if (error instanceof SkipSignal) {
+                    this.log(`Action ${action.name}: skip — remaining steps skipped`);
+                    await this.flushPendingCheckpoints(actionCtx);
+                    return;
+                }
+                if (error instanceof QueueSignal) {
+                    await this.handleQueue(error);
+                    await this.flushPendingCheckpoints(actionCtx);
+                    return;
+                }
+                if (error instanceof RetrySignal) {
+                    const maxAttempts = error.backoff?.maxAttempts ?? MAX_RETRY_FALLBACK;
+                    attempt++;
+                    if (attempt >= maxAttempts) {
+                        throw new Error(`Action ${action.name} exhausted ${maxAttempts} retry attempt(s)`);
+                    }
+                    const delay = this.computeRetryDelay(error.backoff, attempt);
+                    this.log(`Action ${action.name}: retry ${attempt}/${maxAttempts} in ${delay}ms`);
+                    if (delay > 0)
+                        await sleep(delay);
+                    continue;
+                }
+                // JumpSignal, PauseSignal, and real errors propagate. The action's
+                // checkpoints live on actionCtx and are simply discarded (never flushed)
+                // since the data was not durably stored.
+                throw error;
+            }
+        }
+    }
+    /** Compute a retry backoff delay from a RetrySignal's backoff config. */
+    computeRetryDelay(backoff, attempt) {
+        const initial = backoff?.initialDelay ?? 0;
+        switch (backoff?.backoff) {
+            case 'exponential':
+                return initial * Math.pow(2, attempt - 1);
+            case 'linear':
+                return initial * attempt;
+            default:
+                return initial;
+        }
+    }
+    /** Push a queued value to its target store (queue directive). */
+    async handleQueue(signal) {
+        const target = signal.target;
+        if (!target) {
+            this.log('Queue directive without target — value discarded');
+            return;
         }
+        const store = this.ctx.stores.get(target);
+        if (!store) {
+            throw new Error(`Queue target store not found: ${target}`);
+        }
+        const value = signal.value;
+        const record = value && typeof value === 'object' && !Array.isArray(value)
+            ? value
+            : { value };
+        const key = typeof record.id === 'string' || typeof record.id === 'number'
+            ? String(record.id)
+            : `queued-${this.queueCounter++}`;
+        await store.set(key, record);
+        this.log(`Queued value to store '${target}' (key=${key})`);
     }
     async executeStep(step, actionName, ctx) {
         // Use provided context or default to this.ctx
         // NOTE: ctx is used for action-scoped operations (response, variables)
         // this.ctx is still used for mission-level resources (stores, sources)
         const execCtx = ctx ?? this.ctx;
-        // Track step index for events
-        const currentStepIndex = this.stepIndex++;
+        // Track step index per-action so parallel actions don't share a counter.
+        const scope = this.scopeFor(execCtx);
+        const currentStepIndex = scope.stepIndex++;
         const stepType = this.getStepType(step.type);
+        // Stable step identity for the execution log: action + per-action index.
+        const stepId = `${actionName}#${currentStepIndex}`;
         // Emit step.start event
         this.eventEmitter?.emit('step.start', {
             actionName,
             stepIndex: currentStepIndex,
             stepType,
         });
+        // Append step.started to the durable execution log.
+        await this.logEvent({
+            type: 'step.started',
+            stepId,
+            action: actionName,
+            stepType,
+            attempt: scope.attempt,
+        });
         const stepStartTime = Date.now();
         // Record trace snapshot before step
         if (this.traceRecorder) {
@@ -648,7 +865,7 @@ export class MissionExecutor {
         try {
             switch (step.type) {
                 case 'FetchStep':
-                    await this.executeFetch(step, execCtx);
+                    await this.executeFetch(step, execCtx, stepId);
                     break;
                 case 'ForStep':
                     await this.executeFor(step, actionName, execCtx);
@@ -660,7 +877,7 @@ export class MissionExecutor {
                     await this.executeValidate(step, execCtx);
                     break;
                 case 'StoreStep':
-                    await this.executeStore(step, execCtx);
+                    await this.executeStore(step, execCtx, stepId);
                     break;
                 case 'MatchStep':
                     await this.executeMatch(step, actionName, execCtx);
@@ -692,6 +909,8 @@ export class MissionExecutor {
                 stepType,
                 success: true,
             });
+            // Append step.completed to the durable execution log.
+            await this.logEvent({ type: 'step.completed', stepId, attempt: scope.attempt });
         }
         catch (error) {
             // Re-throw flow control signals without recording as errors
@@ -727,7 +946,7 @@ export class MissionExecutor {
             throw error;
         }
     }
-    async executeFetch(step, ctx) {
+    async executeFetch(step, ctx, stepId) {
         const fetchHandler = new FetchHandler({
             ctx,
             oasSources: this.sourceManager.getAllOASSources(),
@@ -740,12 +959,82 @@ export class MissionExecutor {
             emit: this.eventEmitter
                 ? (type, payload) => this.eventEmitter.emit(type, payload)
                 : undefined,
+            // Durable mode: mutating fetches carry a stable Idempotency-Key.
+            idempotency: this.executionLog && this.logExecutionId && stepId
+                ? { executionId: this.logExecutionId, stepId }
+                : undefined,
+            // Resumable backfill: seed pagination from the log and record each page.
+            pagination: step.backfill && this.executionLog && this.logExecutionId && stepId
+                ? {
+                    resume: this.pageProgress.get(stepId),
+                    maxItemsPerRun: this.config.backfillMaxItemsPerRun,
+                    onPage: async (progress) => {
+                        await this.logEvent({
+                            type: 'page.completed',
+                            stepId,
+                            page: progress.page,
+                            cursor: progress.cursor,
+                            recordCount: progress.recordCount,
+                            done: progress.done,
+                        });
+                    },
+                }
+                : undefined,
         });
+        // Capture when the request began; used as the checkpoint fallback time so
+        // a sync without an explicit update field never advances past records
+        // written during the fetch.
+        const fetchStartedAt = new Date();
         const result = await fetchHandler.execute(step);
         ctx.response = result.data;
-        // Update sync checkpoint after successful fetch
+        // Defer the sync checkpoint until the fetched data is durably stored.
         if (result.checkpointKey && this.syncStore) {
-            await fetchHandler.recordCheckpoint(result.checkpointKey, step, result.data);
+            const key = result.checkpointKey;
+            const data = result.data;
+            this.scopeFor(ctx).pendingCheckpoints.push(async () => {
+                const syncedAt = await fetchHandler.recordCheckpoint(key, step, data, fetchStartedAt);
+                if (syncedAt) {
+                    await this.logEvent({
+                        type: 'checkpoint.advanced',
+                        key,
+                        syncedAt: syncedAt.toISOString(),
+                        recordCount: Array.isArray(data) ? data.length : undefined,
+                        mission: this.missionName,
+                    });
+                }
+            });
+        }
+    }
+    /**
+     * Per-action mutable scope (step counter + deferred checkpoints). Lazily
+     * created so a step run with the bare mission context still works; normally
+     * executeAction installs a fresh scope that nested scopes inherit.
+     */
+    scopeFor(ctx) {
+        if (!ctx.actionScope) {
+            ctx.actionScope = { stepIndex: 0, attempt: 0, pendingCheckpoints: [] };
+        }
+        return ctx.actionScope;
+    }
+    /**
+     * Append an event to the execution log. No-op (zero cost) when no log is
+     * configured. The executionId is supplied from this run's stable log id.
+     */
+    async logEvent(event) {
+        if (!this.executionLog || !this.logExecutionId)
+            return;
+        await this.executionLog.append({
+            ...event,
+            executionId: this.logExecutionId,
+        });
+    }
+    /** Flush deferred sync checkpoints (called after a successful store / action). */
+    async flushPendingCheckpoints(ctx) {
+        const scope = this.scopeFor(ctx);
+        const pending = scope.pendingCheckpoints;
+        scope.pendingCheckpoints = [];
+        for (const record of pending) {
+            await record();
         }
     }
     async executeFor(step, actionName, ctx) {
@@ -765,6 +1054,7 @@ export class MissionExecutor {
                 ? (cmd) => this.handleDebugCommand(cmd)
                 : undefined,
             checkPause: this.config.controlServer ? () => this.checkPause() : undefined,
+            handleQueue: (signal) => this.handleQueue(signal),
         });
         await handler.execute(step);
     }
@@ -788,7 +1078,36 @@ export class MissionExecutor {
         });
         await handler.execute(step);
     }
-    async executeStore(step, ctx) {
+    async executeStore(step, ctx, stepId) {
+        // Dry runs use synthetic fetch data that has no real keys; persisting it
+        // would both write garbage and trip key validation. Skip the write but
+        // still advance checkpoints so the dry run exercises the sync path.
+        if (this.config.dryRun) {
+            this.log(`[dry run] skipping store to ${step.target}`);
+            await this.flushPendingCheckpoints(ctx);
+            return;
+        }
+        // Step-level effect identity (attempt-independent): a store effect already
+        // applied in the log — whether by a prior run we are resuming or an earlier
+        // action attempt — must not be re-applied. This is the exactly-once-on-replay
+        // guarantee for store writes.
+        //
+        // The identity is keyed on the *content* being written, not just the target.
+        // A resumable backfill re-runs the same step (same stepId) once per run, each
+        // run storing a different page; keying on target alone made every run after
+        // the first collide on one id and skip the write, silently dropping every
+        // page but the first. Hashing the resolved payload keeps re-storing the same
+        // data idempotent (the upsert is a no-op anyway) while a different page is a
+        // distinct effect that applies.
+        const discriminator = `${step.target}::${this.storeContentHash(step, ctx)}`;
+        const fx = stepId && this.logExecutionId
+            ? effectId(this.logExecutionId, stepId, 0, 'store', discriminator)
+            : undefined;
+        if (fx && this.appliedEffects.has(fx)) {
+            this.log(`Skipping already-applied store to ${step.target} (resume)`);
+            await this.flushPendingCheckpoints(ctx);
+            return;
+        }
         const handler = new StoreHandler({
             ctx,
             log: (msg) => this.log(msg),
@@ -797,6 +1116,44 @@ export class MissionExecutor {
                 : undefined,
         });
         await handler.execute(step);
+        // Record the effect as applied so replay/retry skips it.
+        if (fx) {
+            this.appliedEffects.add(fx);
+            await this.logEvent({
+                type: 'effect.applied',
+                stepId: stepId,
+                attempt: 0,
+                effectType: 'store',
+                effectId: fx,
+            });
+        }
+        // Data is now durably stored — safe to advance any pending sync checkpoint.
+        await this.flushPendingCheckpoints(ctx);
+    }
+    /**
+     * A stable hash of the payload a store step will write, used to make the
+     * store-effect identity content-aware. Resolving the source is a pure read of
+     * the context (the same value the handler stores); on any evaluation failure we
+     * fall back to a constant so behaviour matches the old target-only identity
+     * rather than throwing inside the dedup path.
+     */
+    /** Load a pause's checkpoint into the shape the pause step uses to resume. */
+    async loadResumingPause(pauseId) {
+        const resumed = await this.pauseStore?.load(pauseId);
+        return resumed
+            ? { pauseId, checkpoint: resumed.checkpoint, payload: resumed.webhookPayload }
+            : undefined;
+    }
+    storeContentHash(step, ctx) {
+        try {
+            const source = evaluate(step.source, ctx);
+            return createHash('sha1')
+                .update(JSON.stringify(source) ?? 'null')
+                .digest('hex');
+        }
+        catch {
+            return 'unhashable';
+        }
     }
     async executeMatch(step, actionName, ctx) {
         const handler = new MatchHandler({
@@ -821,7 +1178,8 @@ export class MissionExecutor {
     async executeLet(step, ctx) {
         const value = evaluate(step.value, ctx);
         setVariable(ctx, step.name, value);
-        this.log(`Set variable '${step.name}' = ${JSON.stringify(value)}`);
+        // Redact before logging: the value (or a nested field) may be a secret.
+        this.log(`Set variable '${step.name}' = ${JSON.stringify(redactNamedValue(step.name, value))}`);
     }
     async executeApply(step, ctx) {
         const transform = this.transforms.get(step.transform);
@@ -854,6 +1212,21 @@ export class MissionExecutor {
         if (!this.pauseManager) {
             throw new Error('Pause manager not configured');
         }
+        // Resuming this very pause: don't pause again. Restore the captured
+        // checkpoint (variables + response, plus any webhook payload) and fall
+        // through so the steps after the pause run to completion.
+        const resuming = this.resumingPause;
+        if (resuming &&
+            resuming.checkpoint.action === actionName &&
+            resuming.checkpoint.stepIndex === stepIndex + 1) {
+            this.resumingPause = undefined;
+            for (const [key, value] of Object.entries(resuming.checkpoint.variables ?? {})) {
+                ctx.variables.set(key, value);
+            }
+            ctx.response = resuming.payload ?? resuming.checkpoint.response;
+            this.log(`Resuming past pause ${resuming.pauseId}`);
+            return;
+        }
         // Mark execution state as paused before creating pause
         if (this.executionState) {
             this.executionState.status = 'paused';
@@ -866,7 +1239,10 @@ export class MissionExecutor {
                 ? (type, payload) => this.eventEmitter.emit(type, payload)
                 : undefined,
             pauseManager: this.pauseManager,
-            executionId: this.executionState?.id ?? 'ephemeral',
+            // Anchor the pause to the durable log id so its pause.created lands under
+            // the same execution the log replays on resume (executionState may be
+            // absent when running without an execution store).
+            executionId: this.logExecutionId ?? this.executionState?.id ?? 'ephemeral',
             mission: this.missionName ?? 'unknown',
             actionName,
             stageIndex: this.currentStageIndex,