chore(core): address serialize-evented-wflows PR #17836 review follow-ups (#18385)

## Summary

Follow-up to #17836. Picks up three reviewer comments that landed after
the merge:

- **`Mastra` TTL sweep warning** — When the run-scoped workflow TTL
sweep evicts a registration that was still live, log a warning with
`runId` / `ageMs` / `ttlMs` so abandoned suspended runs are visible in
operator logs instead of disappearing silently. (Comment: P3 follow-up.)
- **`codec.ts` regex-injection suppression** — The `//
lgtm[js/regex-injection]` comment in `decodeRegExpEnvelope` now spells
out the three structural gates that justify the suppression —
`isEnvelope`'s source-length cap + flag whitelist, the local
re-narrowing in `decodeRegExpEnvelope`, and the `try/catch` fallback —
plus an explicit "do not 'fix' by escaping" warning. A future reader
looking only at that screen no longer has to scroll back up to
`isEnvelope` to understand why this is safe.
(#17836 (comment))
- **`evented-unix-pubsub` scenario test** — Allocates the
`UnixSocketPubSub` socket under a short `/tmp/aim-*` directory instead
of `os.tmpdir()`, so the path stays under macOS's 104-byte `sun_path`
limit. (Nit follow-up.)

The three other reviewer comments (`DefaultStepResult` codec
registration, `MAX_REGEXP_SOURCE_LENGTH` constant use,
`hydrate-run-scope` skip-list comment, and the `__m_codec__` reservation
doc) were already handled in the merged PR.

## Test plan

- `pnpm --filter ./packages/core exec vitest run
src/mastra/run-scope.test.ts
src/loop/test-utils/aimock/scenarios/evented-unix-pubsub.scenario.test.ts
src/events/codec` → 70 passed, no type errors
- `pnpm --filter ./packages/core check` → clean

🤖 Generated with [Mastra Code](https://mastra.ai)

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## ELI5

This PR adds three improvements to Mastra's workflow system: (1) it now
tells operators when old workflow runs are automatically cleaned up
instead of silently disappearing, (2) it adds better documentation
explaining why certain security-risky code patterns are actually safe,
and (3) it fixes socket file paths to work properly on macOS where
there's a strict limit on how long paths can be.

---

## Changes

### TTL Sweep Logging Enhancement
Added warning log messages to `Mastra#sweepStaleRunScopedWorkflows` that
are emitted when the TTL sweep evicts stale run-scoped workflow
registrations. The warning includes the `runId`, computed `ageMs`, and
`ttlMs` value, making abandoned suspended runs visible in operator logs.
A corresponding test case was added to verify this logging behavior.

### Regex-Injection Suppression Documentation
Expanded the inline documentation in `decodeRegExpEnvelope` within
`codec.ts` to explicitly document the three structural safety gates that
justify the `// lgtm[js/regex-injection]` suppression:
- `isEnvelope`'s source-length cap and flag whitelist
- Local re-narrowing of `source` and `flags` within
`decodeRegExpEnvelope`
- The `try/catch` fallback mechanism

The documentation also includes an explicit warning against attempting
to fix the issue by escaping characters.

### Unix Socket Path Adjustment
Modified the `evented-unix-pubsub` scenario test to allocate Unix
sockets under a short `/tmp/aim-*` directory created at test time,
instead of using `os.tmpdir()`. This ensures socket paths stay within
macOS's 104-byte `sun_path` limit. The test now uses `mkdtempSync` and
`rmSync` to manage temporary directories, with cleanup occurring in
`afterEach`.

### Changeset Documentation
Added a patch-level changeset for `@mastra/core` documenting all three
follow-up items.

---

## Testing
- 70 tests passed with no type errors
- Package check completed cleanly
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

---------

Co-authored-by: Mastra Code (anthropic/claude-opus-4-7) <noreply@mastra.ai>

Author: taofeeq-deru

.changeset/serialize-evented-wflows-followup.md

@@ -0,0 +1,9 @@
+---
+'@mastra/core': patch
+---
+
+Address post-merge review follow-ups from the evented-workflow serialization work:
+
+- `Mastra` now logs a warning when the TTL sweep evicts a run-scoped workflow that was still registered, surfacing abandoned suspended runs instead of dropping them silently.
+- The `RegExp` codec's `// lgtm[js/regex-injection]` suppression now spells out all three structural gates (`isEnvelope` length cap + flag whitelist, local re-narrowing in `decodeRegExpEnvelope`, `try/catch` fallback) at the suppression site so future readers don't reintroduce escaping.
+- The `evented-unix-pubsub` scenario test now allocates its Unix socket under a short `/tmp/aim-*` directory instead of `os.tmpdir()` so it stays under the macOS 104-byte `sun_path` limit.

packages/core/src/events/codec/codec.ts

@@ -147,8 +147,15 @@ function decodeRegExpEnvelope(v: unknown): RegExp {
   if (!/^[dgimsuvy]*$/.test(flags)) return /(?:)/;
   if (new Set(flags).size !== flags.length) return /(?:)/;
   try {
-    // lgtm[js/regex-injection] -- payload is narrowed (length cap, flag whitelist,
-    // try/catch); see helper docstring for why escaping `source` would be wrong.
+    // lgtm[js/regex-injection] -- safe because of three structural gates that
+    // run before this line: (1) `isEnvelope` rejects payloads whose `source`
+    // exceeds `MAX_REGEXP_SOURCE_LENGTH` and whose `flags` fall outside the
+    // spec flag whitelist `[dgimsuvy]` (no duplicates); (2) the local checks
+    // above re-narrow `source`/`flags` so the constructor input is bounded at
+    // this single call site; (3) this `try/catch` swallows any constructor
+    // failure and returns the empty regex. Do NOT "fix" this by escaping
+    // `source` — see the helper docstring above for why that would break the
+    // round-trip contract.
     return new RegExp(candidate.source, flags);
   } catch {
     return /(?:)/;

packages/core/src/loop/test-utils/aimock/scenarios/evented-unix-pubsub.scenario.test.ts

@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto';
-import { tmpdir } from 'node:os';
+import { mkdtempSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { stepCountIs } from '@internal/ai-sdk-v5';
 import { afterEach, describe, expect, it } from 'vitest';
@@ -24,13 +24,23 @@ import { runLoopScenario, useLoopScenarioAimock } from '../aimock-scenario';
 describe('AIMock loop scenario: evented + UnixSocketPubSub', () => {
   const getMock = useLoopScenarioAimock();
   const pubsubs: UnixSocketPubSub[] = [];
+  const socketDirs: string[] = [];
 
   afterEach(async () => {
     await Promise.allSettled(pubsubs.splice(0).map(p => p.close()));
+    for (const dir of socketDirs.splice(0)) {
+      rmSync(dir, { recursive: true, force: true });
+    }
   });
 
   it('round-trips a tool result containing Date/Map/Error across the evented pubsub', async () => {
-    const socketPath = join(tmpdir(), `aimock-evented-${randomUUID()}.sock`);
+    // Keep this path short. macOS caps `sun_path` at 104 bytes — the default
+    // `os.tmpdir()` on macOS (`/var/folders/...`) already burns ~50 chars
+    // before we add a UUID + suffix, so we anchor under `/tmp` and trim the
+    // UUID to make the test portable on every host.
+    const socketDir = mkdtempSync('/tmp/aim-');
+    socketDirs.push(socketDir);
+    const socketPath = join(socketDir, `${randomUUID().slice(0, 8)}.sock`);
     const pubsub = new UnixSocketPubSub(socketPath);
     pubsubs.push(pubsub);
 

packages/core/src/mastra/index.ts

@@ -2771,6 +2771,15 @@ export class Mastra<
         // time — never parse it back out of the composite key, since callers
         // can pass runIds that contain ':'.
         this.#releaseRunScope(entry.runId);
+        // Surface the eviction so operators can investigate long-suspended
+        // runs that never resumed. The refcounted lifecycle in
+        // `__createRunScope`/`__releaseRunScope` covers the happy path; this
+        // branch only fires when a registration was abandoned past the TTL.
+        this.#logger.warn('Evicted stale run-scoped workflow after TTL expired', {
+          runId: entry.runId,
+          ageMs: now - entry.registeredAt,
+          ttlMs: Mastra.INTERNAL_WORKFLOW_TTL_MS,
+        });
       }
     }
   }

packages/core/src/mastra/run-scope.test.ts

@@ -216,6 +216,26 @@ describe('Mastra runScope lifecycle', () => {
       expect(m.__getRunScope('fresh-run')).toBeDefined();
     });
 
+    it('emits a warning when the sweep evicts a still-registered run', () => {
+      const warn = vi.fn();
+      const m = new Mastra({
+        logger: { warn, info: vi.fn(), debug: vi.fn(), error: vi.fn(), trackException: vi.fn() } as any,
+      });
+      m.__registerInternalWorkflow(makeWorkflow('agentic-loop'), 'abandoned-run');
+
+      vi.setSystemTime(Date.now() + Mastra.INTERNAL_WORKFLOW_TTL_MS + 1000);
+      m.__registerInternalWorkflow(makeWorkflow('agentic-loop'), 'fresh-run');
+
+      expect(warn).toHaveBeenCalledWith(
+        'Evicted stale run-scoped workflow after TTL expired',
+        expect.objectContaining({
+          runId: 'abandoned-run',
+          ttlMs: Mastra.INTERNAL_WORKFLOW_TTL_MS,
+          ageMs: expect.any(Number),
+        }),
+      );
+    });
+
     it('releases the correct scope when the runId contains a colon', () => {
       const m = makeMastra();
       // runIds are caller-controlled; nothing prevents a custom id from