bake: name the five ways the extension can fail to answer, and move the landing verdict into a pure, tab-provable classifier

A no-answer stays a failure; it now says whether the extension never ran the landing, answered a stale generation, spoke a wire this build cannot read, cleared the request, or refused it.

src/shell/capture/CLAUDE.md

@@ -56,7 +56,7 @@ detail not covered there:
 - `render_selection` (`shell/capture`) — the transient track selection a selected-tracks render (`&128`) requires, as a stack RAII guard: REAPER prints whatever tracks are selected, so `renderOffline` makes the request's own tracks BE the selection for the render's duration and restores the user's set on every exit path. Engaged ONLY for that source mode, which leaves a stated residual: a `&32` selected-items render still prints whatever ITEMS the user has selected. Live captures are unaffected (that selection is the source), but a recipe replay of a `SelectedItems` capture renders against whatever happens to be selected then — the recipe stores tracks and a range, never item GUIDs, so this guard cannot close it. Filed in `docs/TODO.md`.
 - `render_isolation` (`shell/capture`) — the transient upstream silencing a ranged ITEM render needs, as a stack RAII guard alongside the two above: the selected-tracks source prints everything flowing INTO the track, so each direct folder child's `B_MAINSEND` and each of the track's receives' `B_MUTE` are cut for the render and restored on every exit path. Direct children only — a grandchild reaches the track through the child that owns it. The child-set walk is pure (`core/capture/track_topology`).
 - `capture_orchestrator` (`shell/capture`) — single-capture orchestration + the realtime/insert action bodies (Q-W3 hoist, T4-02): `renderOffline` (one offline render under the scope's FX-bypass guard), `captureAndIndexOne` (render + provenance stamp + bank add + tracking-ledger record, unpersisted), `RunCapture`/`RunCaptureItemAssign`, `RunCaptureRealtimeTrack`/`RunCancelRealtime` (the realtime action bodies — the in-flight state lives in `realtime_lifecycle`), and `RunInsertSelected` (the ONE deliberate exception to capture-never-places).
-- `bake_land` (`shell/capture`) — the EXTENSION's half of the resample chain: scans every open project tab for pending `rsbake_*` requests, lands the ones belonging to the project this session has loaded, and refuses the rest with `WrongProject` — one undo point for the batch, each answered over its own key inside the invoking instance's synchronous action call. It RENDERS NOTHING — the instrument already did, through its own engine in its own process, which is what makes the baked audio the sound the user approved and what keeps the voice engine out of the extension's link graph. Replace-vs-add comes from `tracking::resampleLanding`; a replace keeps the entry's id and slot and never deletes the superseded file. Hash-dedup applies on the add path only, before the disk write, matching `updateSampleInPlace`'s "an in-place refresh is not an insert". A refused index withdraws the bytes this call had just written — the self-cleanup carve-out from prune's deletion authority, stated in `prune_fs.cpp`'s header.
+- `bake_land` (`shell/capture`) — the EXTENSION's half of the resample chain: scans every open project tab for pending `rsbake_*` requests, lands the ones belonging to the project this session has loaded, and refuses the rest with `WrongProject` — one undo point for the batch, each answered over its own key inside the invoking instance's synchronous action call. The per-key verdict itself is NOT this TU's: it is `core/wire`'s pure `classifyBakeScan`, so this shell only enumerates, reads, and applies. It RENDERS NOTHING — the instrument already did, through its own engine in its own process, which is what makes the baked audio the sound the user approved and what keeps the voice engine out of the extension's link graph. Replace-vs-add comes from `tracking::resampleLanding`; a replace keeps the entry's id and slot and never deletes the superseded file. Hash-dedup applies on the add path only, before the disk write, matching `updateSampleInPlace`'s "an in-place refresh is not an insert". A refused index withdraws the bytes this call had just written — the self-cleanup carve-out from prune's deletion authority, stated in `prune_fs.cpp`'s header.
 - `capture_batch` (`shell/capture`) — the batch-capture family + re-capture-from-source (Q-W3 hoist, T4-02): `RunBatchCaptureItems` (one sample per selected item), `RunBatchCaptureRazor` (one sample per razor area), `RunRecaptureFromSource` (regenerate a provenanced sample from its recorded source's current state, bank-only). Every unit routes through `capture_orchestrator` so every precision invariant holds; persist is batched to one ext-state write per action.
 - `realtime_lifecycle` (`shell/capture`) — the in-flight realtime-capture state machine + globals (Q-W3 hoist): the action starts it, `OnTimer` drives it per tick via `DriveRealtimeCapture` (a single-pointer-test idle fast path — load-bearing hot-path guardrail), `CommitRealtimeResult` lands a finished capture in the bank, `AbortRealtimeCaptureForUnload` tears down cleanly on extension unload.
 - `capture_realtime_shell` (`shell/capture`) — the async realtime-record backend surface (Q-W6 split of the former fat `capture.h`): `RealtimeRecordBackend::begin`/`tick`/`abort`, transport-driven across timer ticks (a realtime record cannot block REAPER's UI for its own duration). Deliberately shares NO interface with the offline backend — the lifecycles genuinely differ (the former `ICaptureBackend` interface was deleted in Q-W3, T4-26).

src/shell/capture/bake_land.cpp

@@ -6,7 +6,6 @@
 #include "shell/capture/bake_land.h"
 
 #include <cstdint>
-#include <cstdlib>
 #include <ctime>
 #include <filesystem>
 #include <fstream>
@@ -53,13 +52,6 @@ using wire::BakeOutcome;
 using wire::BakeRequest;
 using wire::BakeStatus;
 
-// The whole chain is a call and a return inside ONE editor tick, so a request older than
-// this has no reader left: it is a crash leftover, and it is CLEARED rather than landed.
-// Without the guard a stranded request would be banked on the next unrelated instance's
-// click, and the outcome written back to a key nobody will collect would persist into the
-// .rpp forever.
-constexpr std::int64_t kMaxRequestAgeSeconds = 30;
-
 BakeOutcome refuse(BakeStatus status, std::string message, std::int64_t generation) {
     BakeOutcome out;
     out.status = status;
@@ -268,15 +260,12 @@ struct Answer {
 }  // namespace
 
 void RunResampleBake(ReaSamplerSession& session) {
-    // Three projects have to agree before anything may land: the tab the request was found
-    // in, the tab whose book/ledger poll() last loaded, and the tab saveToActiveProject
-    // will persist into. Land on a disagreement and one tab's bake is written into
-    // another's bank. Whether REAPER makes Main_OnCommandEx's `proj` current for the
-    // action's duration is unverified in the DAW; this holds either way, and a request it
-    // cannot land is told why rather than silently ignored.
+    // Whether REAPER makes Main_OnCommandEx's `proj` current for the action's duration is
+    // unverified in the DAW; the per-key verdict holds either way, and a request it cannot
+    // land is told why rather than silently ignored.
     const void* loaded = session.loadedProject();
     const void* active = EnumProjects(-1, nullptr, 0);
-    const bool sessionUsable = loaded != nullptr && loaded == active;
+    const wire::BakeScanContext scanContext{loaded != nullptr, loaded == active};
     const std::int64_t nowSec = static_cast<std::int64_t>(std::time(nullptr));
 
     std::vector<Answer> answers;
@@ -285,21 +274,23 @@ void RunResampleBake(ReaSamplerSession& session) {
     for (const OpenProject& open : openProjects()) {
         for (const std::string& key : pendingBakeKeys(open.proj)) {
             const std::optional<std::string> raw = readKey(open.proj, key);
-            if (!raw) continue;
-            const std::optional<BakeRequest> request = wire::decodeBakeRequest(*raw);
-            // Not a request: an outcome this instance has not yet collected, or a value from
-            // a build we do not read. Leave it — the writing instance owns clearing its key.
-            if (!request) continue;
+            const std::optional<BakeRequest> request =
+                raw ? wire::decodeBakeRequest(*raw) : std::nullopt;
+            const wire::BakeScanKey scanKey{
+                request.has_value(), request ? request->generation : 0,
+                static_cast<const void*>(open.proj) == loaded};
+            const wire::BakeScanVerdict verdict =
+                wire::classifyBakeScan(scanContext, scanKey, nowSec);
 
-            // Stale (either direction, so a clock moved backwards is caught too): clear the
-            // key, never answer it. The instance that could read an answer is gone.
-            if (std::llabs(nowSec - request->generation) > kMaxRequestAgeSeconds) {
+            // Leave it — the writing instance owns clearing its own key.
+            if (verdict == wire::BakeScanVerdict::Ignore) continue;
+            if (verdict == wire::BakeScanVerdict::ClearStale) {
                 answers.push_back(Answer{open.proj, key, std::string{}, std::string{}});
                 continue;
             }
 
             BakeOutcome outcome;
-            if (!sessionUsable || static_cast<const void*>(open.proj) != loaded) {
+            if (verdict == wire::BakeScanVerdict::RefuseWrongProject) {
                 outcome = refuse(BakeStatus::WrongProject,
                                  "this bake's project tab is not the one the extension has "
                                  "loaded -- focus that tab and try again",
@@ -310,9 +301,9 @@ void RunResampleBake(ReaSamplerSession& session) {
             }
             // A WrongProject request left sitting in a tab this call did not come from
             // prints again on every OTHER tab's bake, since the scan revisits every open
-            // project each time. `active` is this call's own proxy for "the invoking tab"
-            // (see the three-projects comment above) — only that tab's own refusal is fresh
-            // feedback to a user who just clicked bake; every other one is a rescan repeat.
+            // project each time. `active` is this call's own proxy for "the invoking tab" —
+            // only that tab's own refusal is fresh feedback to a user who just clicked
+            // bake; every other one is a rescan repeat.
             const bool ownRequest = static_cast<const void*>(open.proj) == active;
             std::string console;
             if (outcome.status != BakeStatus::Ok &&

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. 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.
 - `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

@@ -187,24 +187,45 @@ BakeChainResult runBake(ReaSamplerProcessor& processor) {
     if (!bridge.invokeExtensionAction(wire::bakeActionLookupName()))
         return fail("the ReaSampler extension's bake action is not registered");
 
-    const std::optional<std::string> raw = bridge.readReasamplerExtState(key);
-    const std::optional<BakeOutcome> outcome =
-        raw ? wire::decodeBakeOutcome(*raw) : std::nullopt;
-    // No outcome at all means the action never reached our request — an older extension
-    // that registers the id but does not read this key, or an invocation REAPER deferred.
-    if (!outcome) return fail("the extension did not answer the bake request");
-    if (outcome->generation != request.generation)
-        return fail("the extension answered a different bake request");
-    if (outcome->status != BakeStatus::Ok)
-        return fail(outcome->message.empty() ? std::string("the bake was refused")
-                                             : outcome->message);
+    // What the key holds now is the only evidence this side gets, and each of the five
+    // non-answers is a different thing to go fix — collapsing them into one sentence is
+    // what made a stale install indistinguishable from a refusal.
+    const wire::BakeAnswer answer =
+        wire::classifyBakeAnswer(bridge.readReasamplerExtState(key), request);
+    switch (answer.kind) {
+        case wire::BakeAnswerKind::Answered:
+            break;
+        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");
+        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");
+        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");
+        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;
+    if (outcome.status != BakeStatus::Ok)
+        return fail(outcome.message.empty() ? std::string("the bake was refused")
+                                            : outcome.message);
 
     SampleRefEntry entry;
-    entry.sampleId = outcome->sampleId;
-    entry.displayName = outcome->displayName;
-    entry.ref.relativePath = outcome->relativePath;
-    entry.ref.rootNote = outcome->rootNote;
-    entry.ref.channelCount = outcome->channelCount;
+    entry.sampleId = outcome.sampleId;
+    entry.displayName = outcome.displayName;
+    entry.ref.relativePath = outcome.relativePath;
+    entry.ref.rootNote = outcome.rootNote;
+    entry.ref.channelCount = outcome.channelCount;
     // No loop: the loop points shaped the render and are meaningless against the new file
     // (bake_reset owns that rule for the parameter set; this is its bank-intrinsic peer).
 
@@ -213,7 +234,7 @@ BakeChainResult runBake(ReaSamplerProcessor& processor) {
 
     // The extension's own wording, which distinguishes the three landings (replaced, added,
     // and pointed at an identical existing entry) more precisely than this side can.
-    return BakeChainResult{true, "resampled -- " + outcome->message};
+    return BakeChainResult{true, "resampled -- " + outcome.message};
 }
 
 }  // namespace reasampler::vst