@pikku/core 0.12.38 → 0.12.39

package/CHANGELOG.md

@@ -1,3 +1,56 @@
+## 0.12.39
+
+### Patch Changes
+
+- 4be205f: Dedupe DSL step execution: extract a shared `invokeStepRpc` (step RPC + provenance wire, used by both the queue and inline executors) and a shared `runInlineRetryLoop` (the in-process running→result→retry scaffolding, used by inline RPC steps and inline function steps). No behavior change — the inline path stays straight-through O(K); the queue path keeps its suspend/replay model.
+- 061c717: fix(cli): log just the message for expected failures, keep the stack for uncaught errors
+
+  A deliberate, expected failure — e.g. `pikku all` aborting because a build gate
+  (blocking diagnostics) tripped — was dumping a full workflow stack trace, burying
+  the one line that matters. Errors are now classified: a `PikkuError` (or any error
+  carrying an `expected` marker) prints its message alone, while a genuinely uncaught
+  error still prints the full stack so it can be debugged.
+  - New `isExpectedError(error)` helper (exported from `@pikku/core`): true for a
+    `PikkuError` or an error flagged `expected`.
+  - The `expected` flag is threaded through `SerializedError` and the in-memory
+    workflow step store so it survives the step-boundary rehydration that strips the
+    error's class.
+  - The CLI runner's top-level catch, the `CLILogger`, and the workflow runner's
+    failure log all honour it.
+  - The blocking-diagnostics abort now throws a `PikkuError` subclass so it is
+    treated as expected.
+
+- 2c55e13: fix(queue): `InMemoryQueueService` redelivers failed jobs up to `options.attempts` with backoff
+
+  Previously the in-memory queue ran each job once and dropped it on failure, so a
+  transiently-failing workflow step dispatched via `inline: false` would stall the
+  run forever (the orchestrator was never resumed). It now honors the `attempts`
+  and `backoff` already produced by the workflow step job options, redelivering on
+  failure — matching pg-boss/bullmq semantics so local/dev runs recover from
+  transient step failures exactly as production does.
+
+- c745c26: fix(workflow): inline graph runs use the same transition planner as the queue
+
+  `continueGraphInline` had its own, weaker graph traversal that couldn't revisit a
+  node (no cycles) and never recorded `fromStepName`, so an inline-run graph stored
+  different step state than the same graph run through a queue. It now uses the
+  shared `planGraphTransitions` planner — inline graphs get joins, cycle revisits
+  (`node`, `node#1`, …) and step provenance identical to the queued path, and the
+  duplicate traversal logic is removed.
+
+- 57900b5: Add workflow run time-travel. A run's durable history (`getRunHistory`) is one row per step attempt with lifecycle timestamps; `buildRunTimeline(history)` explodes those into a flat, chronologically-ordered event stream and `reconstructStateAt(timeline, at)` folds it up to any point — a seq index or a `Date` — to recover what the run "knew" then: per-step status, the accumulated step-result cache, the walked path (via `fromStepName`), and a derived phase. These are pure, transport-independent functions (same fold for Redis/Kysely/in-memory), exported from `@pikku/core/workflow` alongside `reconstructFinalState`. `PikkuWorkflowService` gains `getRunTimeline(id)` and `reconstructRunStateAt(id, at?)` that wrap them over a run's history, inherited by every backend. Correctly handles retries (a retry's created event reopens the step and clears the prior outcome) and graph cycles (revisit ordinals are distinct path entries).
+- 72694f6: feat(workflow): expose per-step attempt count + record running/succeeded/failed timestamps
+
+  `getRunStatus` now returns `attempts` (the latest attempt count) per step, so
+  consumers can show retry counts without a second history query. It already
+  computed `duration` from `runningAt`/`succeededAt`, but the kysely and mongodb
+  workflow stores only stamped those timestamps on the _insert_ path — the
+  `running` / `succeeded` / `failed` status transitions updated the history row's
+  status without setting `runningAt` / `succeededAt` / `failedAt`, so `duration`
+  was always undefined. The transitions now stamp the matching timestamp, so step
+  duration is populated for kysely- and mongodb-backed runs. (Redis already
+  stamped on transition.) A shared service-suite test guards both behaviours.
+
 ## 0.12.38
 
 ### Patch Changes

package/dist/errors/error-handler.d.ts

@@ -9,6 +9,14 @@ export declare class PikkuError extends Error {
      */
     constructor(message?: string);
 }
+/**
+ * Whether an error is a deliberate, expected failure rather than an uncaught
+ * bug. A `PikkuError` always counts; so does any error carrying `expected:
+ * true` — used to keep the marker alive when an error is serialized across a
+ * workflow step boundary and rehydrated as a plain `Error`. Callers log the
+ * message alone for expected errors and the full stack for everything else.
+ */
+export declare const isExpectedError: (error: unknown) => boolean;
 /**
  * Interface for error details.
  */

package/dist/errors/error-handler.js

@@ -14,6 +14,14 @@ export class PikkuError extends Error {
         this.name = new.target.name;
     }
 }
+/**
+ * Whether an error is a deliberate, expected failure rather than an uncaught
+ * bug. A `PikkuError` always counts; so does any error carrying `expected:
+ * true` — used to keep the marker alive when an error is serialized across a
+ * workflow step boundary and rehydrated as a plain `Error`. Callers log the
+ * message alone for expected errors and the full stack for everything else.
+ */
+export const isExpectedError = (error) => error instanceof PikkuError || error?.expected === true;
 /**
  * Adds an error to the API errors map.
  * @param error - The error to add.

package/dist/index.d.ts

@@ -19,6 +19,7 @@ export type { MCPToolResponse, MCPResourceResponse, MCPPromptResponse, } from '.
 export { runQueueJob } from './wirings/queue/queue-runner.js';
 export { runScheduledTask } from './wirings/scheduler/scheduler-runner.js';
 export { NotFoundError } from './errors/errors.js';
+export { PikkuError, isExpectedError } from './errors/error-handler.js';
 export type { EventHubService } from './wirings/channel/eventhub-service.js';
 export type { QueueService } from './wirings/queue/queue.types.js';
 export type { JWTService } from './services/jwt-service.js';

package/dist/index.js

@@ -11,6 +11,7 @@ export { runMCPTool, runMCPResource, runMCPPrompt, } from './wirings/mcp/mcp-run
 export { runQueueJob } from './wirings/queue/queue-runner.js';
 export { runScheduledTask } from './wirings/scheduler/scheduler-runner.js';
 export { NotFoundError } from './errors/errors.js';
+export { PikkuError, isExpectedError } from './errors/error-handler.js';
 export { NoopAuditService, createInvocationAudit, resolveAuditActorFromWire, resolveAuditConfig, } from './services/audit-service.js';
 export { createGraph } from './wirings/workflow/graph/graph-node.js';
 export { wireAddon } from './wirings/rpc/wire-addon.js';

package/dist/services/in-memory-queue-service.d.ts

@@ -1,7 +1,16 @@
 import type { QueueService, JobOptions } from '../wirings/queue/queue.types.js';
+/**
+ * In-process queue for local/dev runs. Schedules jobs on the macrotask queue
+ * (setTimeout) so dispatch is genuinely asynchronous — the same timing shape as
+ * a real queue — and redelivers a failed job up to `options.attempts` times with
+ * backoff, so a transiently-failing workflow step recovers exactly as it would
+ * on pg-boss/bullmq instead of being silently dropped on its first error.
+ */
 export declare class InMemoryQueueService implements QueueService {
     readonly supportsResults = false;
     private jobCounter;
     add<T>(queueName: string, data: T, options?: JobOptions): Promise<string>;
+    /** Delay before the next redelivery, honoring the job's backoff policy. */
+    private backoffDelay;
     getJob(): Promise<null>;
 }

package/dist/services/in-memory-queue-service.js

@@ -1,27 +1,58 @@
 import { runQueueJob } from '../wirings/queue/queue-runner.js';
+/**
+ * In-process queue for local/dev runs. Schedules jobs on the macrotask queue
+ * (setTimeout) so dispatch is genuinely asynchronous — the same timing shape as
+ * a real queue — and redelivers a failed job up to `options.attempts` times with
+ * backoff, so a transiently-failing workflow step recovers exactly as it would
+ * on pg-boss/bullmq instead of being silently dropped on its first error.
+ */
 export class InMemoryQueueService {
     supportsResults = false;
     jobCounter = 0;
     async add(queueName, data, options) {
         const jobId = `inmem-${++this.jobCounter}`;
-        const job = {
-            id: jobId,
-            queueName,
-            data,
-            status: () => 'active',
-            pikkuUserId: options?.pikkuUserId,
-        };
-        const delay = options?.delay ?? 100 + Math.floor(Math.random() * 201);
-        setTimeout(async () => {
+        const maxAttempts = Math.max(1, options?.attempts ?? 1);
+        let attemptsMade = 0;
+        const createdAt = new Date();
+        const runAttempt = async () => {
+            attemptsMade++;
+            const job = {
+                id: jobId,
+                queueName,
+                data,
+                status: () => 'active',
+                metadata: () => ({ attemptsMade, maxAttempts, createdAt }),
+                pikkuUserId: options?.pikkuUserId,
+            };
             try {
                 await runQueueJob({ job });
             }
             catch (e) {
-                console.error(`[InMemoryQueue] Job ${jobId} on ${queueName} failed:`, e.message);
+                if (attemptsMade < maxAttempts) {
+                    // Transient failure — redeliver with backoff, mirroring a real queue.
+                    setTimeout(runAttempt, this.backoffDelay(options?.backoff, attemptsMade));
+                }
+                else {
+                    console.error(`[InMemoryQueue] Job ${jobId} on ${queueName} failed after ${attemptsMade} attempt(s):`, e.message);
+                }
             }
-        }, delay);
+        };
+        const delay = options?.delay ?? 100 + Math.floor(Math.random() * 201);
+        setTimeout(runAttempt, delay);
         return jobId;
     }
+    /** Delay before the next redelivery, honoring the job's backoff policy. */
+    backoffDelay(backoff, attemptsMade) {
+        const baseDelay = typeof backoff === 'object' ? (backoff.delay ?? 50) : 50;
+        if (backoff === 'exponential' ||
+            (typeof backoff === 'object' && backoff?.type === 'exponential')) {
+            return Math.min(2 ** (attemptsMade - 1) * baseDelay, 2000);
+        }
+        if (typeof backoff === 'object' && backoff?.type === 'fixed') {
+            return backoff.delay ?? 50;
+        }
+        return 50;
+    }
     async getJob() {
         return null;
     }

package/dist/services/in-memory-workflow-service.js

@@ -1,5 +1,6 @@
 import { randomUUID } from 'crypto';
 import { PikkuWorkflowService } from '../wirings/workflow/pikku-workflow-service.js';
+import { isExpectedError } from '../errors/error-handler.js';
 /**
  * In-memory implementation of WorkflowService for inline-only execution
  *
@@ -148,6 +149,7 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
                     name: error.name,
                     message: error.message,
                     stack: error.stack,
+                    expected: isExpectedError(error),
                 };
                 step.failedAt = new Date();
                 step.updatedAt = new Date();

package/dist/services/workflow-service.d.ts

@@ -1,5 +1,6 @@
 import type { SerializedError } from '../types/core.types.js';
 import type { WorkflowRun, WorkflowPlannedStep, WorkflowRunWire, WorkflowRunStatus, StepState, WorkflowStatus, WorkflowVersionStatus } from '../wirings/workflow/workflow.types.js';
+import type { RunTimeline, ReconstructedRunState } from '../wirings/workflow/run-timeline.js';
 /**
  * Interface for workflow orchestration
  * Handles workflow execution, replay, orchestration logic, and run-level state
@@ -14,6 +15,8 @@ export interface WorkflowService {
     getRunHistory(runId: string): Promise<Array<StepState & {
         stepName: string;
     }>>;
+    getRunTimeline(id: string): Promise<RunTimeline | null>;
+    reconstructRunStateAt(id: string, at?: number | Date): Promise<ReconstructedRunState | null>;
     updateRunStatus(id: string, status: WorkflowStatus, output?: any, error?: SerializedError): Promise<void>;
     withRunLock<T>(id: string, fn: () => Promise<T>): Promise<T>;
     close(): Promise<void>;

package/dist/testing/service-tests.js

@@ -175,6 +175,41 @@ export function defineServiceTests(config) {
                 assert.equal(retried.error, undefined);
                 assert.equal(retried.result, undefined);
             });
+            test('getRunStatus reports per-step duration and attempts', async () => {
+                const runId = await service.createRun('status-timing-workflow', {}, false, 'hash-timing', wire);
+                const step = await service.insertStepState(runId, 'timed-step', 'myRpc', {});
+                await service.setStepRunning(step.stepId);
+                await service.setStepResult(step.stepId, { ok: true });
+                const status = await service.getRunStatus(runId);
+                assert.ok(status);
+                const timed = status.steps.find((s) => s.name === 'timed-step');
+                assert.ok(timed, 'step appears in run status');
+                // running→succeeded must stamp runningAt/succeededAt so a duration is
+                // computable. Regression guard: the kysely store previously updated
+                // only the status on transitions, leaving the timestamps null and
+                // duration permanently undefined.
+                assert.ok(timed.duration !== undefined, 'duration is computed from stamped transition timestamps');
+                assert.ok(timed.duration >= 0, 'duration is non-negative');
+                assert.equal(timed.attempts, 1, 'single attempt');
+            });
+            test('getRunStatus surfaces retried attempt count', async () => {
+                const runId = await service.createRun('status-retry-workflow', {}, false, 'hash-retry-status', wire);
+                const step = await service.insertStepState(runId, 'flaky-step', 'myRpc', {}, { retries: 2 });
+                await service.setStepRunning(step.stepId);
+                await service.setStepError(step.stepId, new Error('first try'));
+                // Guarantee the retry's history row sorts after the failed attempt so
+                // getRunStatus picks the latest attempt (it tie-breaks on timestamps).
+                await new Promise((resolve) => setTimeout(resolve, 5));
+                const retry = await service.createRetryAttempt(step.stepId, 'pending');
+                await service.setStepRunning(retry.stepId);
+                await service.setStepResult(retry.stepId, { ok: true });
+                const status = await service.getRunStatus(runId);
+                assert.ok(status);
+                const flaky = status.steps.find((s) => s.name === 'flaky-step');
+                assert.ok(flaky, 'retried step collapses to a single status entry');
+                assert.equal(flaky.status, 'succeeded', 'latest attempt wins');
+                assert.equal(flaky.attempts, 2, 'attempt count surfaces in status');
+            });
             test('getNodesWithoutSteps', async () => {
                 const runId = await service.createRun('graph-workflow', {}, false, 'hash-7', wire);
                 await service.insertStepState(runId, 'existing-node', 'rpc', {});

package/dist/types/core.types.d.ts

@@ -378,5 +378,6 @@ export interface SerializedError {
     message: string;
     stack?: string;
     code?: string;
+    expected?: boolean;
     [key: string]: any;
 }

package/dist/wirings/cli/cli-runner.js

@@ -1,4 +1,5 @@
 import { NotFoundError } from '../../errors/errors.js';
+import { isExpectedError } from '../../errors/error-handler.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { pikkuState } from '../../pikku-state.js';
 import { PikkuSessionService, createMiddlewareSessionWireProps, } from '../../services/user-session-service.js';
@@ -361,9 +362,17 @@ export async function executeCLI({ programName, args, createConfig, createSingle
         if (error instanceof CLIError) {
             throw error;
         }
-        // Wrap other errors in CLIError
-        console.error('Error:', error);
-        // Show stack trace in verbose mode
+        // An expected failure (a deliberate PikkuError, e.g. a build gate
+        // tripping) — its message says everything, so print that alone (no
+        // `Error:` prefix). Anything else is an uncaught error: log the object so
+        // its stack shows.
+        if (isExpectedError(error)) {
+            console.error(error.message);
+        }
+        else {
+            console.error('Error:', error);
+        }
+        // Show stack trace in verbose mode (even for expected errors).
         if (args.includes('--verbose') || args.includes('-v')) {
             console.error('Stack trace:', error.stack);
         }

package/dist/wirings/workflow/graph/graph-runner.js

@@ -409,7 +409,14 @@ export async function continueGraph(workflowService, runId, graphName, overrideM
         await queueGraphNode(workflowService, runId, graphName, fire.instanceKey, node.rpcName, resolvedInput, node, fire.fromStepName);
     }
 }
-export async function executeGraphStep(workflowService, rpcService, runId, stepId, nodeId, rpcName, data, graphName) {
+/**
+ * Invoke a graph node's RPC with the graph + workflow wires, capturing any
+ * branch the node selects and persisting it. Shared by the queued
+ * (executeGraphStep) and inline (executeGraphNodeInline) executors so both build
+ * the wire and record the branch identically — only their child-workflow and
+ * onError handling differs around this call.
+ */
+async function invokeGraphNodeRpc(workflowService, rpcService, runId, stepId, nodeId, rpcName, input, graphName) {
     const wireState = {};
     const graphWire = {
         runId,
@@ -421,6 +428,16 @@ export async function executeGraphStep(workflowService, rpcService, runId, stepI
         setState: (name, value) => workflowService.updateRunState(runId, name, value),
         getState: () => workflowService.getRunState(runId),
     };
+    const result = await rpcService.rpcWithWire(rpcName, input, {
+        graph: graphWire,
+        workflow: workflowService.createWorkflowWire(graphName, runId, rpcService),
+    });
+    if (wireState.branchKey) {
+        await workflowService.setBranchTaken(stepId, wireState.branchKey);
+    }
+    return result;
+}
+export async function executeGraphStep(workflowService, rpcService, runId, stepId, nodeId, rpcName, data, graphName) {
     try {
         let result;
         const subWorkflowMeta = pikkuState(null, 'workflows', 'meta')[rpcName];
@@ -449,13 +466,7 @@ export async function executeGraphStep(workflowService, rpcService, runId, stepI
             }
         }
         else {
-            result = await rpcService.rpcWithWire(rpcName, data, {
-                graph: graphWire,
-                workflow: workflowService.createWorkflowWire(graphName, runId, rpcService),
-            });
-        }
-        if (wireState.branchKey) {
-            await workflowService.setBranchTaken(stepId, wireState.branchKey);
+            result = await invokeGraphNodeRpc(workflowService, rpcService, runId, stepId, nodeId, rpcName, data, graphName);
         }
         return result;
     }
@@ -499,24 +510,16 @@ export async function onGraphNodeComplete(workflowService, runId, graphName) {
 export async function runFromMeta(workflowService, runId, meta, _rpcService) {
     await continueGraph(workflowService, runId, meta.name, meta);
 }
-async function executeGraphNodeInline(workflowService, rpcService, runId, graphName, nodeId, input, nodes) {
+async function executeGraphNodeInline(workflowService, rpcService, runId, graphName, nodeId, instanceKey, input, nodes, fromStepName) {
     const node = nodes[nodeId];
     if (!node)
         return;
     const rpcName = node.rpcName;
-    const stepState = await workflowService.insertStepState(runId, nodeId, rpcName, input, { retries: node.retries ?? 0, retryDelay: node.retryDelay });
+    // Persist under the physical instance key (node, node#1 … for revisits) and
+    // record the predecessor — same as the queued path (queueGraphNode), so an
+    // inline graph run stores identical step rows + provenance.
+    const stepState = await workflowService.insertStepState(runId, instanceKey, rpcName, input, { retries: node.retries ?? 0, retryDelay: node.retryDelay }, fromStepName);
     await workflowService.setStepRunning(stepState.stepId);
-    const wireState = {};
-    const graphWire = {
-        runId,
-        graphName,
-        nodeId,
-        branch: (key) => {
-            wireState.branchKey = key;
-        },
-        setState: (name, value) => workflowService.updateRunState(runId, name, value),
-        getState: () => workflowService.getRunState(runId),
-    };
     try {
         let result;
         const subWorkflowMeta = pikkuState(null, 'workflows', 'meta')[rpcName];
@@ -539,13 +542,7 @@ async function executeGraphNodeInline(workflowService, rpcService, runId, graphN
             result = childRun?.output;
         }
         else {
-            result = await rpcService.rpcWithWire(rpcName, input, {
-                graph: graphWire,
-                workflow: workflowService.createWorkflowWire(graphName, runId, rpcService),
-            });
-        }
-        if (wireState.branchKey) {
-            await workflowService.setBranchTaken(stepState.stepId, wireState.branchKey);
+            result = await invokeGraphNodeRpc(workflowService, rpcService, runId, stepState.stepId, nodeId, rpcName, input, graphName);
         }
         await workflowService.setStepResult(stepState.stepId, result);
     }
@@ -567,19 +564,25 @@ async function executeGraphNodeInline(workflowService, rpcService, runId, graphN
             const errorNodes = Array.isArray(node.onError)
                 ? node.onError
                 : [node.onError];
-            await Promise.all(errorNodes.map((errorNodeId) => executeGraphNodeInline(workflowService, rpcService, runId, graphName, errorNodeId, { error: { message: error.message } }, nodes)));
+            await Promise.all(errorNodes.map((errorNodeId) => executeGraphNodeInline(workflowService, rpcService, runId, graphName, errorNodeId, errorNodeId, { error: { message: error.message } }, nodes, nodeId)));
             return;
         }
         throw error;
     }
 }
 async function continueGraphInline(workflowService, rpcService, runId, graphName, nodes, triggerInput, entryNodeIds) {
+    // Drive the run to completion in-process using the SAME planner as the queued
+    // path (continueGraph): each loop plans the next wave of transitions, executes
+    // them inline (vs queueGraphNode dispatch), then re-plans. Sharing the planner
+    // gives the inline path joins, cycle revisits and fromStepName provenance
+    // identical to the queue — instead of a second, weaker traversal.
     while (true) {
-        const { completedNodeIds: rawCompleted, failedNodeIds: rawFailed, branchKeys: rawBranch, } = await workflowService.getCompletedGraphState(runId);
-        const completedNodeIds = remapStepNamesToNodeIds(rawCompleted, nodes, graphName);
-        const completedNodeIdSet = new Set(completedNodeIds);
+        const { failedNodeIds: rawFailed, branchKeys: branchByStep, completedNodeIds: rawCompleted, } = await workflowService.getCompletedGraphState(runId);
+        // Validate step/branch names map to unambiguous nodes (planning keys
+        // physically; these calls only surface ambiguous template configs).
+        remapStepNamesToNodeIds(rawCompleted, nodes, graphName);
+        remapBranchKeys(branchByStep, nodes, graphName);
         const failedNodeIds = remapStepNamesToNodeIds(rawFailed, nodes, graphName);
-        const branchKeys = remapBranchKeys(rawBranch, nodes, graphName);
         if (failedNodeIds.length > 0) {
             const failedNode = failedNodeIds[0];
             await workflowService.updateRunStatus(runId, 'failed', undefined, {
@@ -589,46 +592,33 @@ async function continueGraphInline(workflowService, rpcService, runId, graphName
             });
             return;
         }
-        const candidateNodes = new Set();
-        for (const nodeId of completedNodeIds) {
-            const node = nodes[nodeId];
-            if (!node?.next)
-                continue;
-            const nextNodes = resolveNextFromConfig(node.next, branchKeys[nodeId]);
-            for (const nextNode of nextNodes) {
-                candidateNodes.add(nextNode);
-            }
-        }
-        for (const entryId of entryNodeIds) {
-            candidateNodes.add(entryId);
-        }
-        if (candidateNodes.size === 0 && completedNodeIds.length > 0) {
-            await workflowService.updateRunStatus(runId, 'completed');
+        const run = await workflowService.getRun(runId);
+        if (run?.status === 'suspended') {
             return;
         }
-        const unstartedNodes = await workflowService.getNodesWithoutSteps(runId, [
-            ...candidateNodes,
-        ]);
-        const nodesToExecute = unstartedNodes.filter((nodeId) => {
-            const node = nodes[nodeId];
-            return node && areDependenciesSatisfied(node, completedNodeIdSet);
-        });
-        if (nodesToExecute.length === 0) {
-            if (completedNodeIds.length > 0 && unstartedNodes.length === 0) {
+        const instances = await workflowService.getStepInstances(runId);
+        const plan = planGraphTransitions(nodes, instances, branchByStep, entryNodeIds, graphName);
+        if (plan.toFire.length === 0) {
+            if (!plan.hasInFlight && !plan.blockedWaiting) {
                 await workflowService.updateRunStatus(runId, 'completed');
             }
             return;
         }
-        await Promise.all(nodesToExecute.map(async (nodeId) => {
-            const node = nodes[nodeId];
+        let executed = 0;
+        await Promise.all(plan.toFire.map(async (fire) => {
+            const node = nodes[fire.logical];
             if (!node?.rpcName)
                 return;
             const referencedNodeIds = extractReferencedNodeIds(node.input).filter((id) => !IGNORED_REFS.has(id));
             const fetchedResults = await workflowService.getNodeResults(runId, referencedNodeIds);
             const nodeResults = { trigger: triggerInput, ...fetchedResults };
             const resolvedInput = resolveSerializedInput(node.input, nodeResults);
-            await executeGraphNodeInline(workflowService, rpcService, runId, graphName, nodeId, resolvedInput, nodes);
+            executed++;
+            await executeGraphNodeInline(workflowService, rpcService, runId, graphName, fire.logical, fire.instanceKey, resolvedInput, nodes, fire.fromStepName);
         }));
+        // Nothing executable fired (e.g. nodes without an rpcName) → can't progress.
+        if (executed === 0)
+            return;
     }
 }
 export async function runWorkflowGraph(workflowService, graphName, triggerInput, rpcService, inline, startNode, wire, overrideMeta) {
@@ -672,7 +662,7 @@ export async function runWorkflowGraph(workflowService, graphName, triggerInput,
                     const resolvedInput = node.input && Object.keys(node.input).length > 0
                         ? resolveSerializedInput(node.input, triggerNodeResults)
                         : triggerInput;
-                    await executeGraphNodeInline(workflowService, rpcService, runId, graphName, nodeId, resolvedInput, nodes);
+                    await executeGraphNodeInline(workflowService, rpcService, runId, graphName, nodeId, nodeId, resolvedInput, nodes);
                 }));
                 await continueGraphInline(workflowService, rpcService, runId, graphName, nodes, triggerInput, entryNodes);
             }

package/dist/wirings/workflow/index.d.ts

@@ -3,6 +3,8 @@
  */
 export { PikkuWorkflowService, WorkflowCancelledException, WorkflowSuspendedException, WorkflowDispatchException, WorkflowNotFoundError, WorkflowRunNotFoundError, DEFAULT_STEP_RETRIES, } from './pikku-workflow-service.js';
 export { deriveInvocationId, uuidv5 } from './workflow-invocation-id.js';
+export { buildRunTimeline, reconstructStateAt, reconstructFinalState, } from './run-timeline.js';
+export type { RunTimeline, RunTimelineEvent, ReconstructedRunState, ReconstructedStep, RunPhase, } from './run-timeline.js';
 export { addWorkflow } from './dsl/workflow-runner.js';
 export { template, type TemplateString } from './graph/template.js';
 export { pikkuWorkflowGraph, type PikkuWorkflowGraphConfig, type PikkuWorkflowGraphResult, } from './graph/wire-workflow-graph.js';

package/dist/wirings/workflow/index.js

@@ -3,6 +3,8 @@
  */
 export { PikkuWorkflowService, WorkflowCancelledException, WorkflowSuspendedException, WorkflowDispatchException, WorkflowNotFoundError, WorkflowRunNotFoundError, DEFAULT_STEP_RETRIES, } from './pikku-workflow-service.js';
 export { deriveInvocationId, uuidv5 } from './workflow-invocation-id.js';
+// Time-travel: reconstruct run state at any point from durable history
+export { buildRunTimeline, reconstructStateAt, reconstructFinalState, } from './run-timeline.js';
 // Internal registration functions (used by generated code)
 export { addWorkflow } from './dsl/workflow-runner.js';
 // Graph helpers (template, pikkuWorkflowGraph)

package/dist/wirings/workflow/pikku-workflow-service.d.ts

@@ -2,6 +2,7 @@ import type { SerializedError } from '../../types/core.types.js';
 import type { PikkuWorkflowWire, StepState, StepStatus, WorkflowPlannedStep, WorkflowRun, WorkflowRunMirror, WorkflowRunStatus, WorkflowRunWire, WorkflowStatus, WorkflowVersionStatus, WorkflowStepOptions } from './workflow.types.js';
 import type { WorkflowService } from '../../services/workflow-service.js';
 import { PikkuError } from '../../errors/error-handler.js';
+import { type RunTimeline, type ReconstructedRunState } from './run-timeline.js';
 import type { JobOptions } from '../queue/queue.types.js';
 /**
  * Default number of retries for a workflow step when none is specified. The
@@ -123,6 +124,20 @@ export declare abstract class PikkuWorkflowService implements WorkflowService {
      * Used by the public API — the console addon provides the full verbose view.
      */
     getRunStatus(id: string): Promise<WorkflowRunStatus | null>;
+    /**
+     * Build the run's time-travel event stream from durable history.
+     * @param id - Run ID
+     * @returns Ordered timeline, or null if the run doesn't exist
+     */
+    getRunTimeline(id: string): Promise<RunTimeline | null>;
+    /**
+     * Reconstruct the run's state at a point in its timeline.
+     * @param id - Run ID
+     * @param at - A seq index (inclusive) or a Date (inclusive); omit for the
+     *             final state.
+     * @returns Reconstructed state, or null if the run doesn't exist
+     */
+    reconstructRunStateAt(id: string, at?: number | Date): Promise<ReconstructedRunState | null>;
     /**
      * Get workflow run history (all step attempts in chronological order)
      * @param runId - Run ID
@@ -390,6 +405,23 @@ export declare abstract class PikkuWorkflowService implements WorkflowService {
      */
     orchestrateWorkflow(runId: string, rpcService: any): Promise<void>;
     private verifyQueueService;
+    /**
+     * Invoke a step's RPC with the workflow-step wire (step identity + provenance).
+     * Identical for the queue executor and the inline executor — the only thing
+     * that differs between transports is who calls it, not the call itself.
+     */
+    private invokeStepRpc;
+    /**
+     * Inline (straight-through) step execution with an in-process retry loop —
+     * shared by inline RPC steps and inline function steps. Same scaffolding
+     * (running → result, or fail → retry-attempt → backoff → retry) wrapped
+     * around a step-specific `doWork` body. Stays O(K): no suspend/replay.
+     *
+     * `onError` is an optional hook for terminal errors that must NOT retry
+     * (e.g. RPC-not-found → suspend the run for redeploy). If it throws, the
+     * loop exits immediately without recording a step error or retrying.
+     */
+    private runInlineRetryLoop;
     private rpcStep;
     private inlineStep;
     private sleepStep;