@pikku/core 0.12.37 → 0.12.39

package/CHANGELOG.md

@@ -1,3 +1,116 @@
+## 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
+
+- 92cd5b1: feat(workflow): workflow-owned step retries + stable invocationId
+
+  The workflow — not the queue — now owns step retry policy, and each step
+  invocation gets a stable idempotency key.
+  - **Default `retries: 5` with exponential backoff.** A step with no `retries`
+    previously inherited the queue's bare default (e.g. pg-boss `retry_limit 2`,
+    no backoff) so retries fired instantly and couldn't outlast a transient
+    outage. Retries now default to 5 with backoff, resolved at the workflow layer.
+  - **`retries: 0` is honored.** Dispatch previously passed `undefined` options
+    for `retries: 0`, letting the queue re-run a non-idempotent step up to its own
+    default. The resolved policy now always sets `attempts` (`retries: 0` →
+    `attempts: 1`), so the queue never second-guesses the workflow. The persisted
+    step retries and the dispatched `attempts` are resolved together so
+    "retries exhausted" and "no more redeliveries" are the same event.
+  - **`workflowStep.invocationId`** — a deterministic, dependency-free
+    `uuidv5(runId:stepName)` handed to every step. Unlike `stepId` (minted per
+    attempt), it is identical across retries, so a step can dedupe on it
+    (`ON CONFLICT (invocationId)`, Stripe idempotency keys, etc.).
+  - **queue-bullmq**: `mapPikkuJobToBull` now maps `backoff` (previously dropped,
+    so a step's backoff silently never applied on Redis), and `registerQueues`
+    throws a clear error when no logger is available (matching queue-pg-boss).
+  - **Dispatch failures are recoverable, not fatal.** A step is now marked
+    `scheduled` only _after_ it is successfully handed to its transport (queue or
+    scheduler) — a failed hand-off leaves it `pending` so a replay re-dispatches
+    it, instead of stranding it in `scheduled` (replay would pause forever on a
+    job that was never enqueued). A transport outage (e.g. pg-boss momentarily
+    down) is surfaced as a new `WorkflowDispatchException`, which the orchestrator
+    treats as transient: the run is left running and the orchestrator job is
+    rethrown for redelivery (it replays idempotently from the snapshot) rather
+    than the whole run being marked `failed`. The orchestrator job now also
+    carries its own retry policy, so this holds even when the orchestrator queue
+    is configured `retry_limit 0`. A genuine step error still fails the run.
+  - **Same step name can be invoked multiple times in one run.** Step rows are now
+    keyed per _invocation_: the Nth reach of a step name in a replay resolves to a
+    physical key (`name` for the first, `name#N` for repeats), so a literal
+    duplicate name no longer clobbers the earlier step's state. The first reach
+    keeps the bare name, so existing rows, graph-node matching and `invocationId`s
+    are unchanged. Ordinals are derived deterministically from DSL execution order
+    and reset each replay.
+  - **Step provenance (`fromStepName`) + graph cycles.** Every step now records
+    the predecessor it was scheduled from (`fromStepName`; entry steps have none),
+    persisted on the step row across all stores (in-memory, kysely, redis,
+    mongodb, cloudflare DO) and carried in the queued payload. The DSL wire
+    exposes the derived `fromInvocationId` (`uuidv5(runId:fromStepName)`) so
+    consumers get the stable predecessor key without a second persisted id —
+    `fromStepName` is the source of truth (it is replay-deterministic; `stepId`,
+    minted per row, is not). This makes the walked path reconstructable even when
+    a node is reached more than once: in `a → b → a → c` the second `a` is a
+    distinct ordinal instance (`a#1`) whose `fromStepName` is `b`.
+    The graph runner now supports **cycles**: a forward edge into an
+    already-started node still collapses to a single run (joins/diamonds are
+    unchanged), but a _back-edge_ — one whose target can reach its source — fires
+    a fresh ordinal instance, so a node can loop back to itself. Termination is
+    the graph's responsibility (branch routing must converge); the engine enforces
+    no visit cap.
+
 ## 0.12.37
 
 ### 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.d.ts

@@ -1,6 +1,6 @@
 import { PikkuWorkflowService } from '../wirings/workflow/pikku-workflow-service.js';
 import type { SerializedError } from '../types/core.types.js';
-import type { WorkflowPlannedStep, WorkflowRun, WorkflowRunService, WorkflowRunWire, StepState, WorkflowStatus, WorkflowVersionStatus, WorkflowStepOptions } from '../wirings/workflow/workflow.types.js';
+import type { WorkflowPlannedStep, WorkflowRun, WorkflowRunService, WorkflowRunWire, StepState, StepStatus, WorkflowStatus, WorkflowVersionStatus, WorkflowStepOptions } from '../wirings/workflow/workflow.types.js';
 /**
  * In-memory implementation of WorkflowService for inline-only execution
  *
@@ -35,7 +35,7 @@ export declare class InMemoryWorkflowService extends PikkuWorkflowService implem
         stepName: string;
     }>>;
     protected updateRunStatusImpl(id: string, status: WorkflowStatus, output?: any, error?: SerializedError): Promise<void>;
-    protected insertStepStateImpl(runId: string, stepName: string, rpcName: string | null, data: any, stepOptions?: WorkflowStepOptions): Promise<StepState>;
+    protected insertStepStateImpl(runId: string, stepName: string, rpcName: string | null, data: any, stepOptions?: WorkflowStepOptions, fromStepName?: string): Promise<StepState>;
     getStepState(runId: string, stepName: string): Promise<StepState>;
     protected setStepRunningImpl(stepId: string): Promise<void>;
     protected setStepScheduledImpl(stepId: string): Promise<void>;
@@ -65,6 +65,11 @@ export declare class InMemoryWorkflowService extends PikkuWorkflowService implem
         branchKeys: Record<string, string>;
     }>;
     getNodesWithoutSteps(runId: string, nodeIds: string[]): Promise<string[]>;
+    getStepInstances(runId: string): Promise<Array<{
+        stepName: string;
+        status: StepStatus;
+        fromStepName?: string;
+    }>>;
     getNodeResults(runId: string, nodeIds: string[]): Promise<Record<string, any>>;
     setBranchKey(runId: string, nodeId: string, branchKey: string): Promise<void>;
     protected setBranchTakenImpl(stepId: string, branchKey: string): Promise<void>;

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
  *
@@ -78,7 +79,7 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
                 run.error = error;
         }
     }
-    async insertStepStateImpl(runId, stepName, rpcName, data, stepOptions) {
+    async insertStepStateImpl(runId, stepName, rpcName, data, stepOptions, fromStepName) {
         const stepId = randomUUID();
         const now = new Date();
         const step = {
@@ -87,6 +88,7 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
             attemptCount: 1,
             retries: stepOptions?.retries,
             retryDelay: stepOptions?.retryDelay,
+            fromStepName,
             createdAt: now,
             updatedAt: now,
             stepName,
@@ -147,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();
@@ -189,6 +192,7 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
             attemptCount: failedStep.attemptCount + 1,
             retries: failedStep.retries,
             retryDelay: failedStep.retryDelay,
+            fromStepName: failedStep.fromStepName,
             createdAt: now,
             updatedAt: now,
             stepName: stepName,
@@ -317,6 +321,20 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
         }
         return nodeIds.filter((id) => !existingSteps.has(id));
     }
+    async getStepInstances(runId) {
+        const prefix = `${runId}:`;
+        const instances = [];
+        for (const [key, step] of this.steps.entries()) {
+            if (!key.startsWith(prefix))
+                continue;
+            instances.push({
+                stepName: key.substring(prefix.length),
+                status: step.status,
+                fromStepName: step.fromStepName,
+            });
+        }
+        return instances;
+    }
     async getNodeResults(runId, nodeIds) {
         const results = {};
         for (const nodeId of nodeIds) {

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/dsl/workflow-dsl.types.d.ts

@@ -271,10 +271,28 @@ export type WorkflowStepMeta = RpcStepMeta | BranchStepMeta | ParallelGroupStepM
 export interface WorkflowStepWire {
     /** The workflow run ID */
     runId: string;
-    /** The unique step ID */
+    /**
+     * The step row ID. Whether it stays the same or is minted fresh per attempt is
+     * STORE-SPECIFIC (in-memory mints a new one each attempt; the SQL store reuses
+     * the row) — do NOT use it as a dedupe key. Use `invocationId`.
+     */
     stepId: string;
+    /**
+     * Stable identity of this step invocation — the idempotency / dedupe key.
+     * Identical across every retry of the same call (derived from runId + step
+     * name) regardless of storage backend, so a step can `ON CONFLICT (invocationId)`
+     * or pass it as an external idempotency key and have retries collapse onto the
+     * first attempt.
+     */
+    invocationId: string;
     /** Current attempt number (1-indexed, increments on retry) */
     attemptCount: number;
+    /**
+     * Invocation ID of the predecessor step this one was reached from (the walked
+     * transition/edge). Undefined for entry steps. Lets a step know its origin —
+     * e.g. in a cyclic graph `a → b → a → c`, the second `a` carries `b`'s id.
+     */
+    fromInvocationId?: string;
 }
 /**
  * Workflow wire object for DSL workflows