Make tool-managed lane splits visually transparent: collapse display + lazy-mint

Drive C_LANESCOLLAPSED=2 and hide lane buttons only on tracks the tool itself splits
(gated on the pre-write I_FREEMODE read, so user comp-lane display prefs are never
stomped). Lazy-mint managed lanes only for modes with own content, never an empty
reserved lane; confinement holds via C_LANEPLAYS on the lone lane.

src/view.cpp

@@ -53,6 +53,39 @@ namespace {
 // positioning, 2=fixed lanes.
 constexpr int kFreeModeFixedLanes = 2;
 
+// C_LANESCOLLAPSED display value (char*). SDK: 1=lanes collapsed,
+// 2=track displays as non-fixed-lanes but hidden lanes exist. Value 2 is the lever that
+// makes a tool-split track read like a NORMAL single-lane track showing only the playing
+// lane — the inactive/silenced managed lanes are present but not drawn as separate rows.
+constexpr int kLanesDisplayAsNormal = 2;
+
+// C_LANESETTINGS bit (char* bitmask). SDK: &32=hide lane buttons. We OR this in (never
+// clobber the whole mask) to strip the per-lane button chrome from a tool-split track, so
+// it reads as an ordinary track. We deliberately do NOT set &1 (auto-remove empty lanes at
+// bottom): a managed lane whose item is later deleted would be silently removed out from
+// under the ownership index. The lazy-mint decision already avoids ever minting an empty
+// lane, so &1 buys nothing and risks a reconcile hazard.
+constexpr int kLaneSettingsHideButtons = 32;
+
+// Drives a TOOL-SPLIT track's display transparent: C_LANESCOLLAPSED=2 (render like a normal
+// single-lane track showing only the playing lane) + OR C_LANESETTINGS &32 (hide lane
+// buttons). Both are char* params driven through the double API, same convention as
+// C_LANEPLAYS:N. C_LANESETTINGS is read-modify-write so any pre-existing bit is preserved.
+//
+// MANAGED-VS-MANUAL BOUNDARY (load-bearing): these are TRACK-LEVEL settings that affect the
+// whole track including a user's own manual comp lanes. Every caller gates this on the
+// tool-driven transition INTO fixed lanes (freeMode != 2 before the flip), so a track the
+// user already had in fixed-lane mode never reaches it and the user's comp-lane display
+// prefs are never stomped. Idempotent: a re-run finds the track already at I_FREEMODE==2,
+// the transition branch is skipped, and these writes do not fire again.
+void applyTransparentLaneDisplay(MediaTrack* tr) {
+    SetMediaTrackInfo_Value(tr, "C_LANESCOLLAPSED",
+                            static_cast<double>(kLanesDisplayAsNormal));
+    const int settings = static_cast<int>(GetMediaTrackInfo_Value(tr, "C_LANESETTINGS"));
+    SetMediaTrackInfo_Value(tr, "C_LANESETTINGS",
+                            static_cast<double>(settings | kLaneSettingsHideButtons));
+}
+
 // The parmname for each planner Flag. All four are documented bool*/int* track
 // info params driven through the double-valued Get/SetMediaTrackInfo_Value API.
 const char* flagParm(Flag f) {
@@ -224,11 +257,16 @@ bool applyLaneOps(const std::vector<std::pair<std::string, MediaTrack*>>& handle
 
         // Ensure fixed-lane mode is on before driving lane play state. A track carrying
         // a managed lane must be in I_FREEMODE=2; set it only if not already, and flag
-        // that a timeline refresh is owed.
+        // that a timeline refresh is owed. Every track reaching this loop is already in the
+        // managed-lane ownership index (planToggle only emits ops for managed lanes), so a
+        // track here is one the TOOL split — a re-assert of fixed-lane mode is a tool-driven
+        // (re)split and must carry the same transparent display, mirroring applyMintPlan's
+        // transition branch. It is never a user's untouched manual-fixed-lane track.
         const int freeMode = static_cast<int>(GetMediaTrackInfo_Value(tr, "I_FREEMODE"));
         if (freeMode != kFreeModeFixedLanes) {
             SetMediaTrackInfo_Value(tr, "I_FREEMODE",
                                     static_cast<double>(kFreeModeFixedLanes));
+            applyTransparentLaneDisplay(tr);  // tool-managed track ⇒ read like a normal track
             touchedFreeMode = true;
         }
 
@@ -371,10 +409,16 @@ bool applyMintPlan(ViewModeModel& model, const LaneMintPlan& plan,
         MediaTrack* tr = resolve(handleByGuid, split.trackGuid);
         if (!tr) continue;  // stale GUID — prune
 
-        // Enable fixed-lane mode if not already (SDK: UpdateTimeline() owed after).
+        // Enable fixed-lane mode if not already (SDK: UpdateTimeline() owed after). The
+        // pre-write freeMode read is ALSO the managed-vs-manual boundary signal: a track that
+        // was NOT in fixed-lane mode here is one the TOOL is splitting now, so the tool owns
+        // its lane display and drives it transparent. A track already at I_FREEMODE==2 (user
+        // had fixed lanes, or a prior tool run) skips this branch — its C_LANESCOLLAPSED /
+        // C_LANESETTINGS are left exactly as the user set them.
         const int freeMode = static_cast<int>(GetMediaTrackInfo_Value(tr, "I_FREEMODE"));
         if (freeMode != kFreeModeFixedLanes) {
             SetMediaTrackInfo_Value(tr, "I_FREEMODE", static_cast<double>(kFreeModeFixedLanes));
+            applyTransparentLaneDisplay(tr);  // tool-split track ⇒ read like a normal track
             changed = true;
         }