fix: bake-answer messages stop asserting causes the classifier can't see

Rewords Cleared/Unanswered/ForeignRequest to name only observed facts and every live hypothesis instead of picking a winner; adds a guarded answeredOutcome accessor against a future unhandled BakeAnswerKind; folds an unreachable BakeScanKey/Context test state; fixes generation-stamp timing.

src/shell/instrument/CLAUDE.md

@@ -108,7 +108,7 @@ declared ahead of the instrument slots at that member in `reasampler_processor.h
 - `reasampler_editor` — VST3 `IPlugView` LICE editor shell: hosts a LICE-drawn child window; the Sample face is home and Browse is a modal picker over it. Split on the Sample face's BAND axis, mirroring the pure `sample_bands` allocator: `editor_session` (session/bridge state, caches, commit-and-reload), `editor_controls` (the ONE `faceLayout` band resolve every paint and hit-test path shares, the node-drag bounds, the value labels, and the per-instance controls the parameter set does not carry — the parameter-set binding itself is the pure `core/instrument/ui/deck_values` module this only adapts int ids onto), `editor_models` (the orthogonal half: which stored struct each transient editor selection names — the staged-envelope pack/unpack, the drawn contour, and the three velocity curves), then matching paint and input sets — `editor_paint`/`editor_input` (dispatch + drag router + hover dispatch), `_chrome`, `_waveform`, `_deck` — plus the two band-independent surfaces (`_browse` for the modal picker, `_curve` for the velocity-curve popup) and `editor_platform` (IPlugView/Win32 window plumbing). Shared internals in `editor_internal.h`, no TU of its own. Drop-onto-editor ingest is NOT shipped (deferred).
 - `reasampler_embed` — implements `IReaperUIEmbedInterface` so the instrument draws inline in the TCP/MCP without a plugin-owned HWND; delegates layout to `embed_strip`. A read-only readout: the loaded capture across the keyboard span with its root marked, plus the activity level. It takes no mouse input (there is nothing on the strip to select).
 - `editor_stroke` — the editor's LICE side of the analytic stroker: builds a coverage mask with the pure `core/ui/stroke_aa` and blends it into the bitmap ONCE, writing straight to the bitmap's bits (the arithmetic matches LICE's own mode-0 combine, so a stroke composites identically to every other kit draw). Every radial and spline stroke on the editor routes through `strokeArcAA` / `strokePolylineAA` / `strokeLineAA`. Holds the draw-thread-only scratch mask and arc point list — reuse, not a hidden dependency: threading a canvas through the eight paint sites would grow those signatures to carry an allocation detail. Deliberately does NOT touch `shell/panel/draw_kit`: the waveform stroke, the docked bank panel and the browse cards are out of this seam's blast radius.
-- `instrument_bake` — the instrument's half of the resample chain, on the UI thread: render the dialed sound through the pure `core/instrument/bake` modules at the instance's PERSISTED PREVIEW VELOCITY (the velocity the user has been auditioning at — three velocity curves are live, so it is a property of the sound and not a render detail), stage the WAV OUTSIDE the bank folder, publish one `rsbake_<guid>` request, invoke the extension's landing action SYNCHRONOUSLY, read the outcome back over the same key, then adopt + reset in one act. What that key holds afterwards is classified by `core/wire`'s pure `classifyBakeAnswer`, and each of its five non-answers gets its OWN sentence — a silent no-answer stays a failure, but the user is told whether the extension never ran the landing, answered a stale generation, answered in a wire this build cannot read, cleared the request, or refused it. Two stack-RAII guards mirror `FxBypassGuard`'s discipline: the staged file and the request key are both cleared on every exit path, so a failed bake leaves no temp, no bank entry and no parameter reset. `bakeAvailable` is the affordance's paint gate.
+- `instrument_bake` — the instrument's half of the resample chain, on the UI thread: render the dialed sound through the pure `core/instrument/bake` modules at the instance's PERSISTED PREVIEW VELOCITY (the velocity the user has been auditioning at — three velocity curves are live, so it is a property of the sound and not a render detail), stage the WAV OUTSIDE the bank folder, publish one `rsbake_<guid>` request, invoke the extension's landing action SYNCHRONOUSLY, read the outcome back over the same key, then adopt + reset in one act. What that key holds afterwards is classified by `core/wire`'s pure `classifyBakeAnswer`, and each of its five non-answers gets its OWN sentence — a silent no-answer stays a failure, but the user is told whether the extension never ran the landing, answered a stale generation, answered in a wire this build cannot read, cleared the request, or refused it. Two stack-RAII guards mirror `FxBypassGuard`'s discipline: the staged file and the request key are both cleared on every exit path, so a failed bake leaves no temp, no bank entry and no parameter reset. `bakeAvailable` is the affordance's paint gate. A cloned `instanceGuid` (two instances sharing one `rsbake_` key) is NOT handled here — the residual is contained by pre-existing tracking machinery instead: `planUsagePublish`'s sticky `unioned` poison plus `tiedUsageExists` (`core/tracking/tracking_authority.cpp`) force a clone's bake to `AddDistinct` rather than silently replacing a sibling's entry.
 - `vst_entry` — VST3 entry point: `GetPluginFactory` export, class registration, channel-forked class UIDs.
 - `editor_internal.h` — INTERNAL shared helpers for the `reasampler_editor` TU family, included only by the editor's own shell TUs (`editor_session` / `editor_controls` / `editor_paint_*` / `editor_input_*` / `editor_platform`), never a public seam: the `Rect`↔kit adapters, small draw primitives (knob face / title band), label helpers, and the velocity-curve box derivation — the helpers more than one band TU needs. The deck's control ids, group ids and group composition are the pure `deck_groups` module's, not this file's. The piano-strip and root-key draws live in `editor_paint_chrome`, their only consumer, not here.
 - `reasampler_vst.h` — shared identity constants for the ReaSampler VST3 instrument (Phase S): the plugin's class UID (the channel-selected `Steinberg::FUID`, built from the FOREVER-FROZEN macros in `core/wire/reasampler_uid.h`), vendor name/URL/email, so the processor, factory, and editor agree. A class UID is FOREVER-STABLE once shipped — minted once, never regenerated. *(Newly authored per this dispatch's brief — no existing root-CLAUDE.md bullet; verified by reading `src/shell/instrument/reasampler_vst.h` directly.)*

src/shell/instrument/instrument_bake.cpp

@@ -154,14 +154,18 @@ BakeChainResult runBake(ReaSamplerProcessor& processor) {
                         static_cast<std::size_t>(audio.frameCount()), interleaved);
 
     const std::string instanceGuid = processor.usageInstanceGuid();
-    const std::int64_t stamp = static_cast<std::int64_t>(std::time(nullptr));
+    // Named for what it is used for here — the staged file's own name, nothing else.
+    // `request.generation` below takes its OWN, later timestamp: kMaxRequestAgeSeconds
+    // is a budget measured from the write, and re-using this one would silently spend it
+    // on the WAV write that happens in between.
+    const std::int64_t stageStamp = static_cast<std::int64_t>(std::time(nullptr));
 
     // OUTSIDE the bank folder, always: the bank holds indexed captures only, and a stray
     // file there would read as a prune orphan.
     std::error_code ec;
     const fs::path stagedPath =
         fs::temp_directory_path(ec) /
-        ("reasampler_bake_" + instanceGuid + "_" + std::to_string(stamp) + ".wav");
+        ("reasampler_bake_" + instanceGuid + "_" + std::to_string(stageStamp) + ".wav");
     if (ec) return fail("no writable temp directory for the staged render");
     const std::string staged = stagedPath.string();
     StagedFileGuard stagedGuard(staged);
@@ -175,7 +179,10 @@ BakeChainResult runBake(ReaSamplerProcessor& processor) {
     request.sourceDisplayName = sourceEntry->displayName;
     request.ownUsageKey = usageKeyFor(instanceGuid);
     request.rootNote = plan.note;
-    request.generation = stamp;
+    // Stamped here, immediately before the publish below — AFTER the WAV write above,
+    // which is what makes kMaxRequestAgeSeconds' budget (bake_wire.h) exclude staging
+    // time rather than eat into it.
+    request.generation = static_cast<std::int64_t>(std::time(nullptr));
 
     const std::string key = bakeKeyFor(instanceGuid);
     RequestKeyGuard keyGuard(bridge, key);
@@ -198,24 +205,38 @@ BakeChainResult runBake(ReaSamplerProcessor& processor) {
         case wire::BakeAnswerKind::Unanswered:
             return fail(
                 "the ReaSampler extension did not run the bake landing -- its action id "
-                "resolved but nothing read the request. Most likely the installed "
-                "extension is older than this plugin: reinstall it and restart REAPER");
+                "resolved but nothing read the request. Possible causes: the extension is "
+                "older than this plugin and does not know this action; REAPER deferred "
+                "running the action past this call returning (unverified -- see "
+                "reaper_bridge.h); the extension ran but could not read its own request "
+                "key on this pass; or the action name resolved to an id no currently "
+                "loaded extension actually handles. Reinstalling the extension and "
+                "restarting REAPER is worth trying, but is not the only possible fix");
         case wire::BakeAnswerKind::Undecodable:
             return fail(
                 "the extension answered in a format this plugin does not read -- the "
                 "extension and ReaSampler 9000 are from different builds");
         case wire::BakeAnswerKind::Cleared:
             return fail(
-                "the extension discarded the bake request as stale before answering it");
+                "the bake key came back empty -- either the request was cleared before "
+                "an answer was written, or this build could not read whatever was there");
         case wire::BakeAnswerKind::ForeignRequest:
             return fail(
-                "another ReaSampler 9000 instance is baking under this instance's key -- "
-                "the two were copied from one another; reload this one and retry");
+                "the bake key held a different pending request instead of an answer -- "
+                "unexpected given the bake's single-threaded call flow; if this recurs, "
+                "note the exact steps and file it");
         case wire::BakeAnswerKind::ForeignOutcome:
             return fail("the extension answered a different bake request");
     }
-    // Set by construction on Answered (bake_wire.h states the invariant at BakeAnswer).
-    const BakeOutcome& outcome = *answer.outcome;
+    // wire::answeredOutcome is the guard, not switch exhaustiveness alone: the switch
+    // above has no `default`, so a future BakeAnswerKind enumerator it doesn't yet handle
+    // would otherwise fall through to a raw `*answer.outcome` deref with nothing set.
+    const BakeOutcome* outcomePtr = wire::answeredOutcome(answer);
+    if (!outcomePtr)
+        return fail(
+            "the extension's answer was not one this build recognizes -- the extension "
+            "and ReaSampler 9000 may be from different builds");
+    const BakeOutcome& outcome = *outcomePtr;
     if (outcome.status != BakeStatus::Ok)
         return fail(outcome.message.empty() ? std::string("the bake was refused")
                                             : outcome.message);