test: nightly parser fuzz lane — parser input fails as typed AppErrors, never hangs (#1414)

[devin-ai-integration]

Summary

Closes #1414 (Track A of #1412). Parsers are the front door for agent-authored input; nothing asserted they fail well. This adds a fuzz lane over the five parser entry points and enforces exactly one invariant:

checkCase(target, input):
  try { target.run(input) } catch (e) {
    e instanceof AppError                       || FAIL untyped-throw
    normalizeError(e).hint is non-empty         || FAIL empty-hint
  }
  case must terminate                           || FAIL hang   (watchdog, see below)

Targets (scripts/fuzz/targets.ts): parseArgs (strict flags), parseSelectorChain, parseReplayScriptDetailed, readCliBatchStepsJson, parseMaestroProgram. Adding a parser to the lane is one entry in that array.

It already caught a real bug. readQuotedReplayToken scans for the closing quote and then hands the literal to JSON.parse, so a .ad line like fill @e1 --text "hello wor\ld" (invalid escape, raw tab, or \u0000) escaped as a bare SyntaxError. Now a typed INVALID_ARGS with a hint naming the escaping rule; three of those inputs are pinned in the corpus and in src/replay/__tests__/script.test.ts.

Hang detection is real, not elapsed-time bookkeeping. A synchronous parser cannot be interrupted from inside its own tick, so cases run in a worker thread that publishes its case index into a SharedArrayBuffer before each case; the runner watchdogs that cursor and, when it stops advancing past --case-timeout-ms, reports the exact input and terminates the thread. The worker posts ready before the first case so startup (type stripping, parser imports) is not charged to a case budget.

The harness is tested against itself. scripts/fuzz/self-check-targets.ts holds three broken-on-purpose targets (bare Error, AppError with a blank hint, for(;;){}) that only registry.ts resolves, so a normal run never sees them. pnpm fuzz:parsers --self-check (nightly step) and scripts/fuzz/harness.test.ts (unit lane) require each failure kind to be reported — otherwise a regressed classifier or watchdog would leave every test green.

No new dependency. #1413 will bring fast-check; this lane only needs reproducible cases it can print as a repro command, so it uses a seeded mulberry32 PRNG over a seed corpus + mutators (hostile chunks, truncation, slice duplication, long runs). Same seed = same cases everywhere.

Envelope, promotion, lanes.

• Every run — pass or fail — writes <artifact-dir>/run-envelope.json (schemaVersion, commit/ref/run provenance, seed + config, per-target cases/failures/durations, result, repro commands); the nightly uploads it with if: always() and echoes it into the step summary, so a green scheduled run is auditable. obs: scheduled-lane health, freshness telemetry, and standard artifact envelope #1430 is standardizing this shape; when it lands this module becomes the mapping onto its shared writer.
• A nightly discovery reaches the unit lane by promotion, not hand-editing: each failure prints repro: and promote: … --append-corpus, and --input-file --append-corpus appends the downloaded artifact to scripts/fuzz/corpus/regressions.json (sorted, deduped).
• scripts/fuzz/corpus-replay.test.ts replays the whole corpus plus every target's seeds in the unit lane (~40ms).
• The nightly job Parser Fuzz Lane rides replays-nightly.yml (device-free, ubuntu, 50k cases/target, seeded by github.run_number).

Verification, locally:

• 8 seeds × 8,000 cases/target green (the pre-fix run is what found the replay-script bug); --self-check and the fuzz unit tests stable across repeat runs.
• Deliberate throw new Error(...) / for(;;){} injected into a parseSelectorChain branch are reported as untyped-throw / hang: case N did not finish within …ms with working repro commands (both reverted).
• pnpm format:check, pnpm lint, pnpm typecheck, pnpm check:fallow --base origin/main, pnpm check:layering, pnpm check:affected:test, and pnpm test:unit (518 files / 4578 tests) green.

Link to Devin session: https://app.devin.ai/sessions/45070ada3381444c89ac3bb95b79a611
Requested by: @thymikee

[devin-ai-integration]

🤖 Devin AI Engineer

I'll be helping with this pull request! Here's what you should know:

✅ I will automatically:

• Address comments on this PR. Add '(aside)' to your comment to have me ignore it.
• Look at CI failures and help fix them

Note: I can only respond to comments from users who have write access to this repository.

⚙️ Control Options:

• Disable automatic comment, CI, and merge conflict monitoring

[github-actions]

Size Report

Metric	Base	Current	Diff
JS raw	1.87 MB	1.87 MB	+226 B
JS gzip	598.4 kB	598.5 kB	+87 B
npm tarball	713.2 kB	713.4 kB	+161 B
npm unpacked	2.49 MB	2.49 MB	+461 B

Startup median (7 runs, lower is better):

Scenario	Base	Current	Diff
CLI --version	26.2 ms	27.2 ms	+1.0 ms
CLI --help	57.0 ms	56.4 ms	-0.6 ms

Top changed chunks: no changes in the largest emitted chunks.

[github-actions]

PR Preview Action v1.8.1
🚀 View preview at https://callstack.github.io/agent-device/pr-preview/pr-1438/
Built to branch gh-pages at 2026-07-27 18:21 UTC. Preview will be ready when the GitHub Pages deployment is complete.

[devin-ai-integration]

Runtime verification — parser fuzz lane ✅

Tested end-to-end from the shell on this branch (Node 22, no UI).

Failure detection actually works (the key claim)

Temporarily injected faults into parseSelectorChain and reverted each:

throw new Error('x')      -> [selector] untyped-throw: Error: x (at parseSelectorChain ...:133:33)
                             repro:  pnpm fuzz:parsers --input-file .tmp/fuzz/selector-untyped-throw-0.json   exit 1
for(;;){}                 -> [selector] hang: case 2 did not finish within 1000ms   exit 1, 3s wall (no wedge)
AppError(hint: '   ')     -> [selector] empty-hint: AppError INVALID_ARGS has no hint: injected   exit 1

The printed repro: command reports Case still violates the invariant (selector). while injected and Case passes the invariant now (selector). after revert.

Green runs, determinism, scale

pnpm fuzz:parsers → 5 targets × 2000 cases, 0 failures, exit 0, 4.7s. All 5 --target runs green.
Determinism checked by hashing generateCases output (a green run prints no case data): seed 7 twice → d3da022ade36bdc1; seed 8 → e598d765af0d19cd.
--iterations 20000 seeds 2/3 → exit 0 in 20.4s / 19.3s, so 50k/target ≈ 50s, inside the 20-min job timeout.

Corpus, replay lane, workflow

--append-corpus grew the corpus 8→11 sorted/deduped entries; second run appended 0. --replay-corpus green. vitest run --project unit-core scripts/fuzz → 17/17 passed, 38ms test time. Workflow YAML parses; Parser Fuzz Lane job command matches the package script; running the exact CI command shape locally exits 0 (actionlint not installed on the test machine).

Replay-script quoted-token fix (before/after)

before (origin/main): 'fill @e1 --text "hello wor\ld"' -> AppError: false, code UNKNOWN (leaked SyntaxError)
after  (this branch): -> AppError: true, code INVALID_ARGS, hint "Quoted replay values are JSON strings: ..."
same for raw tab and raw NUL; 'hello world' still parses normally

Repo tree clean (git status --porcelain empty) after all injections were reverted. Unrelated: the Coverage job fails here and on origin/main head alike (ios-system-ui help-topic bench coverage).

[thymikee]

Review: changes requested

This is directionally solid—the target registry, deterministic mutator, worker cursor, and replay-script regression are good foundations—but it is not ready for the #1412/#1414 contract yet.

• [P1] Ship the obs: scheduled-lane health, freshness telemetry, and standard artifact envelope #1430 scheduled-lane birth requirements with this lane. Umbrella: test-strength, gate-tightening, and code-observatory tracks #1412 explicitly requires obs: scheduled-lane health, freshness telemetry, and standard artifact envelope #1430 to land before or with test: nightly fuzz lane — parser inputs must fail as typed AppErrors, never hang #1414, including the standard artifact envelope. The new job only uploads .tmp/fuzz after failure; it has no always-produced envelope with schemaVersion, SHA, tool/config provenance, seed, duration, and result, nor the required freshness/health integration. Please land/rebase onto obs: scheduled-lane health, freshness telemetry, and standard artifact envelope #1430 and consume its standard envelope/monitoring path, or include the equivalent implementation here. workflow lines 41–57

• [P1] Make a caught artifact appendable to the checked-in regression corpus. The nightly command never passes --append-corpus; more importantly, the advertised --input-file repro returns from replaySavedCase before reportFailures, so adding --append-corpus cannot promote the downloaded failing artifact either. That leaves no supported path from a nightly discovery to the deterministic unit-lane corpus, contrary to test: nightly fuzz lane — parser inputs must fail as typed AppErrors, never hang #1414. Add an explicit artifact-to-corpus promotion flow (and test it) rather than relying on hand-editing JSON. replay path · append path

• [P2] Add deterministic tests of the invariant/watchdog itself. The current unit test only proves clean seeds and corpus entries pass. It never injects an untyped throw, an empty normalized hint, or a wedged worker, so a regression in the classifier/watchdog could leave every new test green. Add fixture-driven tests for those three failure modes without creating a production test-only DI seam. current unit ownership

Readiness evidence is also incomplete: GitHub has no workflow_dispatch run for this head, so the new scheduled job has not executed at d70a0458…. The Coverage check is currently red on the inherited ios-system-ui help-benchmark gap. That gap is outside this diff, but the PR cannot receive a clean readiness verdict while it remains red.

[devin-ai-integration]

@thymikee addressed all three in 5a382f6.

[P1] Scheduled-lane envelope. #1430 is not merged, so there is nothing to consume yet — I implemented the equivalent here rather than blocking. scripts/fuzz/envelope.ts writes <artifact-dir>/run-envelope.json on every run, pass or fail:

{ "schemaVersion": 1, "lane": "parser-fuzz", "result": "pass",
  "startedAt": "…", "finishedAt": "…", "durationMs": 2229,
  "provenance": { "commitSha": …, "ref": …, "workflowRunId": …, "workflowRunAttempt": …,
                  "nodeVersion": "v22.14.0", "tool": "scripts/fuzz/run.ts", "corpusEntries": 8 },
  "config": { "mode": "generate", "seed": 1, "iterations": 300, "caseTimeoutMs": 2000, "targets": [...] },
  "targetRuns": [ { "target": "cli-args", "cases": 300, "failures": 0, "durationMs": 490 }, ... ],
  "failures": [ /* incl. artifact path */ ], "reproCommands": [ ... ] }

The upload step is now if: always() with a run-scoped artifact name, and the envelope is echoed into $GITHUB_STEP_SUMMARY, so a green scheduled run is auditable rather than silent. When #1430 lands, this module becomes the mapping onto its shared writer — the flagged monitoring integration then has a fixed input instead of a second definition. If you'd rather this PR wait and rebase onto #1430's writer instead, say so and I'll hold it.

[P1] Artifact → corpus promotion. Correct — the replay path returned before promotion could run. --input-file --append-corpus now promotes the downloaded artifact, and every failure prints both commands:

repro:    pnpm fuzz:parsers --input-file .tmp/fuzz/selector-untyped-throw-0.json
promote:  pnpm fuzz:parsers --input-file .tmp/fuzz/selector-untyped-throw-0.json --append-corpus

Tested end-to-end in scripts/fuzz/harness.test.ts against a scratch corpus (AGENT_DEVICE_FUZZ_CORPUS): the first promote appends one sorted entry and exits 1, the second appends nothing (Regression corpus already contains every failing case.). No hand-editing, and no seam in src/.

[P2] Tests of the invariant/watchdog itself. Added scripts/fuzz/self-check-targets.ts — three broken-on-purpose targets (bare Error, AppError with a blank hint, for(;;){}) resolvable only through scripts/fuzz/registry.ts, so a normal run never sees them. harness.test.ts (in unit-core) asserts the classifier on the first two and runs --self-check as a child process for all three, i.e. through the real worker + watchdog path; the nightly job runs pnpm fuzz:parsers --self-check before fuzzing:

ok   self-check-untyped-throw: expected untyped-throw, got untyped-throw
ok   self-check-empty-hint: expected empty-hint, got empty-hint
ok   self-check-hang: expected hang, got hang

Writing that test found a real watchdog bug: worker startup (type stripping + parser imports) counted against the per-case budget, so under load a fast untyped throw could be misreported as a hang. The worker now posts ready before the first case and the watchdog starts counting there. 3× repeat runs of the fuzz tests are stable.

On the readiness evidence: a workflow_dispatch on this head runs the whole Replay Nightly workflow (Android/iOS/macOS device suites, ~80 min each) because the fuzz job rides it. Happy to trigger it if you want that evidence — I did not want to burn the device runners unasked. The ios-system-ui Coverage gap is gone after the rebase onto origin/main (e8b779c), so that check should be green here now.

Locally green: pnpm format:check, pnpm lint, pnpm typecheck, pnpm check:fallow --base origin/main, pnpm check:layering, pnpm test:unit (518 files / 4578 tests).

[thymikee]

Re-review at head 5a382f6: artifact-to-corpus promotion and the tests-of-tests are fixed, but three P1 blockers remain. First, issue 1430 makes the shared standard artifact envelope and scheduled health/freshness integration a birth requirement for this new lane; the PR still uses a lane-specific envelope with no shared monitoring integration. Second, if the self-check fails, the fuzz step never runs, so no envelope is written; the always-run upload warns and the summary then fails while trying to read the missing file. Every terminal path needs a valid envelope and summary. Third, the watchdog interval starts before the worker reports ready, so slow worker startup can still be misclassified as a hung parser case. Start case timing only after ready and add a delayed-startup regression test. All PR checks are green, but no Replay Nightly run exists for this head, so the scheduled route itself is unvalidated.

[devin-ai-integration]

@thymikee all three addressed in 0f4d99a.

1. Shared envelope (#1430). #1430 has no branch or PR yet, so instead of a second lane-specific shape I extracted the standard writer to scripts/scheduled-lane/envelope.ts — lane-agnostic: schemaVersion, lane, result (pass/fail/error), startedAt/finishedAt/durationMs, provenance (commit SHA, ref, workflow, run id/number/attempt, node version, tool), config, and a lane-specific details payload. The fuzz lane is now a thin mapping onto it (scripts/fuzz/envelope.ts), so #1430 either adopts this module as-is or changes one file for all lanes. The health/freshness job itself is #1430's deliverable and needs API scope I shouldn't add here; happy to hold this PR behind #1430 if you'd rather the lane be born against the real writer.

2. Every terminal path has an envelope. Self-check and fuzz now write to separate artifact subdirs (.tmp/fuzz/self-check, .tmp/fuzz/run), the fuzz step is if: always() so a failing self-check no longer suppresses the fuzz envelope, --self-check and --input-file replay both write envelopes (details.mode), and a crash inside the harness writes result: "error". The summary step loops over whatever envelopes exist and prints an explicit "no run envelope was produced" line instead of failing on a missing cat target. Three new tests assert an envelope for a passing run, a failing run, and a self-check run.

3. Watchdog arms only after ready. The per-case interval is no longer created up front — armCaseWatchdog() runs on the ready message. Startup gets its own separate 60s budget so a wedged import still can't hang the lane, but it can never be charged to a case. Regression test: AGENT_DEVICE_FUZZ_STARTUP_DELAY_MS=1200 with --case-timeout-ms 300 must still report untyped-throw and never hang.

Local: format:check, typecheck, lint, check:fallow --base origin/main (no issues in 25 changed files), fuzz unit lane 25/25.

On the unvalidated scheduled route: workflow_dispatch on Replay Nightly also fires the ~80-min Android/iOS/macOS device jobs, so I still haven't triggered it unasked — say the word and I will, or I can split the fuzz lane into its own workflow file if you'd prefer it dispatchable in isolation.

[thymikee]

Re-review at head 0f4d99a: the artifact promotion, tests-of-tests, self-check failure handling, and worker-ready watchdog issues are fixed. Two blockers remain. First, umbrella issue 1412 explicitly requires issue 1430 health/freshness monitoring to land before or with this scheduled lane; this PR adds an envelope producer but no derived scheduled-lane health consumer, dark-lane alerting, or freshness exposure, and no Replay Nightly run exists for this head. Second, malformed workflow-dispatch options throw in readFuzzOptions before run() enters its envelope-writing catch, so the claim that every config/crash terminal path produces an envelope is still false. Move option parsing under the guarded outcome path and cover malformed input. Ordinary PR checks are green, but the scheduled route is not yet ship-ready.

[devin-ai-integration]

Both addressed in dd700b6.

1. Envelope on the option-parse path. Option parsing now happens inside the guarded path: main() catches a readFuzzOptions throw and writes an error envelope using fallbackFuzzOptions(argv), which recovers --artifact-dir positionally so the envelope still lands where monitoring looks even when another flag is what blew up. Covered by two tests: --iterations lots (rejected value) and --not-a-flag (unknown option) both exit 1 and leave result: "error" behind.

2. Health/freshness consumer (#1430). #1430 still has no branch, so rather than ship the lane without its watcher I built the consumer here:

• scripts/scheduled-lane/discover.ts derives lanes from every schedule:-triggered workflow in .github/workflows/ — no hand-maintained list, so a new lane cannot opt out of being watched.
• scripts/scheduled-lane/health-model.ts classifies each lane from recorded run fields only (conclusion + timestamp + declared cadence, never log text): healthy, failing (two consecutive failed cadences), dark (no run within two cadences), pending (no history to judge — e.g. a workflow not yet on the default branch, which must not be mistaken for darkness). Unit-tested per category, including the "one red night is not an outage" boundary.
• scripts/scheduled-lane/health.ts (pnpm lanes:health) writes lane-health.json with the freshness fields (hoursSinceLastRun, hoursSinceLastSuccess, consecutiveFailures, state, lastRunUrl) for obs: repo-health snapshot command aggregating existing analyzers into one JSON #1423's snapshot, prints the table to the step summary, and opens/pings one alert issue for dark or failing lanes. Runs as Scheduled Lane Health daily; --dry-run (and the no-token path) never touches issues.

Run against the live API just now, which is itself the dark-lane evidence you asked for — it immediately caught a real outage rather than a synthetic one:

| Lane                           | Workflow                        | State   | Cadence   | Since last success | Why                                        |
| Conformance Differential       | conformance-differential.yml    | healthy | every 24h | 10.1h              | ran within cadence                         |
| Conformance Regenerate Verify  | conformance-regenerate.yml      | healthy | every 24h | 9.1h               | ran within cadence                         |
| Perf Nightly                   | perf-nightly.yml                | healthy | every 24h | 11.1h              | ran within cadence                         |
| Replay Nightly                 | replays-nightly.yml             | failing | every 24h | never              | 10 consecutive scheduled runs failed       |
| Scheduled Lane Health          | scheduled-lane-health.yml       | pending | every 24h | never              | workflow not on the default branch yet     |

Replay Nightly has failed its last 10 scheduled runs — that is the device-suite lane the fuzz job rides on, and nothing was alerting on it before this.

Blocked on you for the scheduled-route run. I tried to dispatch it and my token can't: POST .../actions/workflows/253723110/dispatches → 403 Resource not accessible by integration. Please either run gh workflow run replays-nightly.yml --ref devin/1785159046-parser-fuzz-lane -f fuzz-iterations=5000, or say the word and I'll move the fuzz job into its own parser-fuzz-nightly.yml (schedule + dispatch) so it's dispatchable without dragging the ~80-min device jobs — which are red anyway, per the table above, so a whole-workflow dispatch will not come back green regardless of the fuzz job.

Local gates: format:check, typecheck, lint, check:fallow --base origin/main (no issues in 31 changed files), check:layering, and the scripts unit lane (37 tests) all green.

[thymikee]

Re-review at head dd700b6: malformed fuzz options are now guarded and tested, but the new scheduled-health path has three P1 blockers. First, scheduled-lane-health.yml omits actions: read while calling the Actions workflow-runs API; with an explicit permissions map the omitted scope is none, so collection will 403. Second, health.ts has no top-level terminal error path, so an API failure exits before writing its snapshot or own required error envelope. Third, a readable workflow with zero scheduled runs is marked dark immediately, contradicting the two-cadence grace and falsely alerting for newly born lanes before their first due run. Add the permission, make terminal failures emit an error envelope, and model first-due/two-cadence grace with dispatched-route evidence. Ordinary PR checks are green, but neither scheduled route has run on this head.

[devin-ai-integration]

Re-review at dd700b6 — all three P1s fixed in 5454b62.

1. actions: read — added to scheduled-lane-health.yml, with a comment recording why (an explicit map makes every omitted scope none, so the runs API would have 403'd). Correct call: the whole job is a workflow-runs reader.

2. Terminal error path — health.ts main() now runs the body under a guard, and reportTerminalFailure() writes both the snapshot (lanes: [], error: <message>) and a result: 'error' envelope, then exits 1. That exit code is deliberately different from an unhealthy lane, which stays exit 0 + alert issue: a broken monitor is a defect in the monitoring, an unhealthy lane is the monitoring working. Covered end-to-end by a test that points the script at an unreachable GITHUB_API_URL and asserts result === 'error', a non-empty details.error, and a non-null snapshot error.

3. First-due grace — the zero-run case now goes through classifyNeverRan(), which compares the workflow's registration date (GET /actions/workflows/{file} → created_at, plumbed through as LaneHistory.registeredAt) against the same 2 × cadence budget a stopped lane gets. So: registered ≤ 48h ago → pending ("added 5.0h ago, first run not yet 48h overdue"); older with still no run → dark; registration date unreadable → pending, never a guess. Three tests pin those boundaries.

Live dry-run against the real API on this head (classification unchanged, and the new registration lookup doesn't perturb it):

| Conformance Differential      | healthy | 11.1h | ran within cadence
| Conformance Regenerate Verify | healthy | 10.1h | ran within cadence
| Perf Nightly                  | healthy | 12.1h | ran within cadence
| Replay Nightly                | failing | never | 10 consecutive scheduled runs failed
| Scheduled Lane Health         | pending | never | workflow not on the default branch yet

Local gates: format/typecheck/lint green, fallow ✓ No issues in 31 changed files, full vitest 519 files / 4597 tests green (the node --test smoke files fail identically on origin/main here with ERR_UNKNOWN_FILE_EXTENSION — a missing local build, not this diff).

Still blocked on the dispatched-route evidence, and I need you for it. Both attempts get 403 Resource not accessible by integration on POST .../actions/workflows/{id}/dispatches, so I cannot produce a scheduled-route run for this head myself. Two things worth deciding together, given the table above:

• Replay Nightly has failed its last 10 scheduled runs, so dispatching the whole workflow won't come back green regardless of the fuzz job — that pre-existing device-suite breakage is exactly the dark-lane class this monitor exists to surface, and it went unnoticed for ten nights.
• If you'd rather have a dispatchable route that isn't hostage to the device suites, say so and I'll split the fuzz job into its own parser-fuzz-nightly.yml; a workflow_dispatch then proves the route in ~1 minute instead of ~80.

Otherwise, from an account with dispatch rights: gh workflow run replays-nightly.yml --ref devin/1785159046-parser-fuzz-lane -f fuzz-iterations=5000 and gh workflow run scheduled-lane-health.yml --ref devin/1785159046-parser-fuzz-lane; I'll take it from the results.

[thymikee]

Latest delta fixes actions: read and API-failure terminal envelopes.

One P1 remains: first-run grace is anchored to workflow created_at, which predates the schedule: trigger when scheduling is added to an existing workflow. An old workflow with no scheduled runs will return an old creation date plus empty history and alert immediately instead of waiting two cadences. Track schedule registration/first observation (or conservatively remain pending) and cover this production transition.

Also replace the new raw spawnSync in health-model.test.ts with the repository exec helper per the hard process-execution rule, and clean the temporary directory.

No live scheduled/dispatch evidence exists yet; iOS Smoke is currently red on an unrelated pre-existing timing assertion, so this head is not fully green.

[devin-ai-integration]

Fixed in ccfd56c.

P1 — grace anchored to the wrong date. You're right, and created_at was worse than wrong: for the exact production transition (adding schedule: to a workflow that's existed for months) it gives an old date and empty history, i.e. an immediate false dark alert on the first run of the monitor. The API can't answer "when was this scheduled" at all, so I dropped that call and asked git instead:

git log -1 --format=%cI --pickaxe-regex -S '^\s*schedule:' -- .github/workflows/<file>

That's the commit that changed the number of schedule: occurrences, i.e. when the trigger appeared. LaneHistory.registeredAt became scheduleRegisteredAt, and classifyNeverRan() measures the same 2 × cadence budget against it. Unreadable date → pending, never a guess; and since a shallow clone can't answer, the health workflow now checks out with fetch-depth: 0 (with a comment saying why, since removing it would silently make every lane permanently pending — failing open, not closed). Covered: just-scheduled-old-workflow → pending, long-scheduled-never-ran → dark, unknown date → pending, plus two tests on the git lookup itself (real workflow returns an ISO date; unknown file returns null).

Process-execution rule. Replaced with runCmdSync from src/utils/exec.ts (allowFailure: true, since asserting the non-zero exit is the point) in both the test and the new schedule-registration.ts — it imports fine under --experimental-strip-types, so scripts have no excuse here. Temp dirs now go through an afterEach that rmSynces them.

Local: format/typecheck/lint green, fallow ✓ No issues in 32 changed files, scripts/scheduled-lane + scripts/fuzz 42/42. Live dry-run on this head still classifies correctly (Replay Nightly failing on 10 consecutive runs, Scheduled Lane Health pending as not-on-default-branch).

On the red check: all 22 checks on this PR are green (Coverage, Smoke Tests, Integration Tests, CodeQL included) — if the iOS Smoke you're seeing is a mac lane outside the PR check set, agreed it's pre-existing and I'd rather not fold a timing-assertion fix into this diff; point me at it and I'll open a separate PR.

Still no dispatched-route evidence: POST .../dispatches gives me 403 Resource not accessible by integration on both workflows, so that one genuinely needs your hands (or a green light to split the fuzz job into its own parser-fuzz-nightly.yml, which would make the route provable in ~1 min instead of riding the ~80-min device suites that are currently failing anyway).