livepilot 1.10.6 → 1.10.7

package/mcp_server/sample_engine/analyzer.py

@@ -188,14 +188,30 @@ def build_profile_from_filename(
     source: str = "filesystem",
     duration_seconds: float = 0.0,
 ) -> SampleProfile:
-    """Build a SampleProfile from filename metadata only (no spectral analysis).
-
-    This is the fallback when M4L bridge is unavailable.
+    """Build a SampleProfile from filename metadata + offline spectral
+    analysis (BUG-B49 fix).
+
+    Filename still supplies key / bpm / material-type hints when
+    present, but we now ALSO open the audio file via soundfile and
+    compute:
+        - duration_seconds (exact)
+        - frequency_center / frequency_spread (FFT-based centroid)
+        - brightness (high-band energy ratio)
+        - transient_density (RMS-gradient peak count)
+        - has_clear_downbeat (peak-interval consistency)
+    These used to be zeros regardless of file contents — downstream
+    critics had no real data.
+
+    If soundfile isn't available or the file can't be decoded, we
+    gracefully fall back to the filename-only path (legacy behavior).
     """
     name = os.path.splitext(os.path.basename(file_path))[0]
     metadata = parse_filename_metadata(file_path)
     material = classify_material_from_name(name)
 
+    # Offline spectral analysis — best-effort, never raises.
+    spectral = _analyze_audio_file(file_path)
+
     profile = SampleProfile(
         source=source,
         file_path=file_path,
@@ -206,7 +222,14 @@ def build_profile_from_filename(
         bpm_confidence=0.5 if metadata.get("bpm") else 0.0,
         material_type=material,
         material_confidence=0.4,  # filename-only is low confidence
-        duration_seconds=duration_seconds,
+        duration_seconds=(
+            spectral.get("duration_seconds") or duration_seconds
+        ),
+        frequency_center=spectral.get("frequency_center", 0.0),
+        frequency_spread=spectral.get("frequency_spread", 0.0),
+        brightness=spectral.get("brightness", 0.0),
+        transient_density=spectral.get("transient_density", 0.0),
+        has_clear_downbeat=spectral.get("has_clear_downbeat", False),
     )
 
     profile.suggested_mode = suggest_simpler_mode(profile)
@@ -214,3 +237,107 @@ def build_profile_from_filename(
     profile.suggested_warp_mode = suggest_warp_mode(profile)
 
     return profile
+
+
+def _analyze_audio_file(file_path: str) -> dict:
+    """Read an audio file and compute lightweight spectral/temporal
+    features via numpy. Returns {} if the file can't be decoded.
+
+    Uses soundfile (already a dependency) + numpy FFT — no librosa
+    required. Falls back cleanly so file-not-found / unsupported
+    format doesn't break the analyzer.
+    """
+    try:
+        import soundfile as sf
+        import numpy as np
+    except ImportError:
+        return {}
+
+    if not file_path or not os.path.exists(file_path):
+        return {}
+
+    try:
+        data, samplerate = sf.read(file_path, dtype="float32")
+    except Exception:
+        return {}
+
+    # Downmix to mono
+    if data.ndim > 1:
+        data = data.mean(axis=1)
+    if data.size == 0 or samplerate <= 0:
+        return {}
+
+    duration = float(data.size) / float(samplerate)
+
+    # Spectral centroid via magnitude-weighted frequency average.
+    # Use a Welch-style average over ~50ms windows to stabilize.
+    win_len = max(1024, int(samplerate * 0.05))
+    hop = win_len // 2
+    centroids: list[float] = []
+    spreads: list[float] = []
+    frames = range(0, max(len(data) - win_len, 1), hop)
+    for start in frames:
+        frame = data[start:start + win_len]
+        if len(frame) < 32:
+            continue
+        # Hann-window + FFT
+        mags = np.abs(np.fft.rfft(frame * np.hanning(len(frame))))
+        total = mags.sum()
+        if total <= 0:
+            continue
+        freqs = np.linspace(0, samplerate / 2, len(mags))
+        c = float((mags * freqs).sum() / total)
+        centroids.append(c)
+        # Spectral spread = sqrt(sum(mags * (freqs - c)**2) / total)
+        s = float(np.sqrt(((mags * (freqs - c) ** 2).sum()) / total))
+        spreads.append(s)
+
+    if not centroids:
+        return {"duration_seconds": duration}
+
+    frequency_center = float(np.mean(centroids))
+    frequency_spread = float(np.mean(spreads))
+    # Brightness: fraction of energy above 4kHz
+    # Use a single FFT on the whole signal for this (cheap)
+    full_mags = np.abs(np.fft.rfft(data * np.hanning(len(data))))
+    full_freqs = np.linspace(0, samplerate / 2, len(full_mags))
+    total_energy = full_mags.sum() or 1.0
+    high_energy = full_mags[full_freqs >= 4000].sum()
+    brightness = float(high_energy / total_energy)
+
+    # Transient density: peak count in rectified-RMS gradient
+    # Coarse envelope over ~20ms windows
+    env_win = max(256, int(samplerate * 0.02))
+    envelope = np.array([
+        float(np.sqrt(np.mean(data[i:i + env_win] ** 2)))
+        for i in range(0, len(data), env_win)
+    ])
+    if envelope.size > 1:
+        diffs = np.diff(envelope)
+        # Count upward transitions above a dynamic threshold
+        thresh = max(envelope.std() * 1.5, 1e-4)
+        peaks = int(np.sum(diffs > thresh))
+        transient_density = float(peaks / max(duration, 0.001))
+    else:
+        transient_density = 0.0
+
+    # Clear downbeat: peaks evenly spaced
+    has_clear_downbeat = False
+    if envelope.size > 4:
+        # Find top-N peaks and check interval stddev
+        peak_positions = np.argsort(envelope)[-8:]
+        peak_positions.sort()
+        if len(peak_positions) >= 3:
+            intervals = np.diff(peak_positions)
+            if intervals.size > 0 and float(np.mean(intervals)) > 0:
+                cv = float(np.std(intervals)) / float(np.mean(intervals))
+                has_clear_downbeat = cv < 0.5  # low variation → steady
+
+    return {
+        "duration_seconds": duration,
+        "frequency_center": frequency_center,
+        "frequency_spread": frequency_spread,
+        "brightness": brightness,
+        "transient_density": transient_density,
+        "has_clear_downbeat": has_clear_downbeat,
+    }

package/mcp_server/sample_engine/critics.py

@@ -164,21 +164,36 @@ def run_frequency_fit_critic(
 ) -> CriticResult:
     """Score frequency fit against existing mix.
 
-    Without mix_snapshot (no M4L bridge), returns neutral 0.5.
+    BUG-B38 fix: the old stub branch returned a neutral 0.5 "fair"
+    score even when the analyzer had no spectral data at all —
+    misleading the user into thinking the sample was a middling fit
+    when in reality the critic couldn't evaluate anything. We now
+    mark the result as explicitly unavailable (score=-1 sentinel +
+    available=False + rating="unavailable") so downstream aggregators
+    can skip this critic rather than fold a fake 0.5 into the overall
+    score.
     """
     if mix_snapshot is None or not mix_snapshot:
         return CriticResult(
-            critic_name="frequency_fit", score=0.5,
-            recommendation="No spectral data — verify frequency fit by ear",
-            adjustments=[{"note": "stub — spectral overlap analysis not yet implemented"}],
+            critic_name="frequency_fit",
+            score=-1.0,
+            available=False,
+            rating_override="unavailable",
+            recommendation=(
+                "No mix snapshot available — load LivePilot_Analyzer on "
+                "master and call get_mix_snapshot first. Falling back to "
+                "by-ear verification."
+            ),
         )
 
     # Basic frequency overlap check using mix_snapshot track data
-    # mix_snapshot expected shape: {"tracks": [{"name": ..., "peak_frequency": ...}]}
     tracks = mix_snapshot.get("tracks", [])
     if not tracks:
         return CriticResult(
-            critic_name="frequency_fit", score=0.5,
+            critic_name="frequency_fit",
+            score=-1.0,
+            available=False,
+            rating_override="unavailable",
             recommendation="Mix snapshot has no track data",
         )
 
@@ -186,8 +201,14 @@ def run_frequency_fit_critic(
     sample_center = profile.frequency_center
     if sample_center <= 0:
         return CriticResult(
-            critic_name="frequency_fit", score=0.5,
-            recommendation="Sample has no spectral data — verify by ear",
+            critic_name="frequency_fit",
+            score=-1.0,
+            available=False,
+            rating_override="unavailable",
+            recommendation=(
+                "Sample has no spectral data — analyze_sample couldn't "
+                "decode the file, or it's a clip-only reference."
+            ),
         )
 
     # Count tracks with energy near the sample's center frequency

package/mcp_server/sample_engine/models.py

@@ -82,15 +82,32 @@ class SampleIntent:
 
 @dataclass
 class CriticResult:
-    """Result from a single sample critic."""
+    """Result from a single sample critic.
+
+    BUG-B38: added `available` + rating override so critics can
+    explicitly mark themselves as unevaluated (e.g. no mix snapshot
+    for frequency_fit) rather than returning a misleading 0.5 score.
+    Downstream aggregators check `available` before folding a critic's
+    score into the composite.
+    """
 
     critic_name: str
     score: float
     recommendation: str
     adjustments: list = field(default_factory=list)
+    # Explicit availability flag — False when critic couldn't evaluate
+    # (score will be -1.0 sentinel; aggregators should skip)
+    available: bool = True
+    # Optional hand-set rating label — overrides the score-based
+    # default when provided (used for "unavailable" status)
+    rating_override: str = ""
 
     @property
     def rating(self) -> str:
+        if self.rating_override:
+            return self.rating_override
+        if not self.available:
+            return "unavailable"
         if self.score >= 0.8:
             return "excellent"
         if self.score >= 0.6:
@@ -102,6 +119,8 @@ class CriticResult:
     def to_dict(self) -> dict:
         d = asdict(self)
         d["rating"] = self.rating
+        # Strip internal override from payload (not for consumers)
+        d.pop("rating_override", None)
         return d
 
 

package/mcp_server/sample_engine/tools.py

@@ -104,30 +104,64 @@ def evaluate_sample_fit(
                 logger.debug("get_track_info(%d) skipped: %s", i, exc)
                 continue
 
-        # Detect key from MIDI tracks
+        # Detect key from MIDI tracks.
+        # BUG-B37 fix: the old code checked clip_info.get("is_midi") but
+        # the Remote Script returns is_midi_clip (different field name),
+        # so the check always failed and song_key stayed None —
+        # key_fit then reported "Song key unknown" even on obvious
+        # Dm sessions. Now we check both field names for safety AND
+        # aggregate notes from all harmonic tracks via harmonic_score
+        # (Batch 5 helper), so key detection uses the richest signal.
         try:
             from ..tools._theory_engine import detect_key
-            for i in range(min(track_count, 8)):
+            from ..tools._composition_engine.harmony import harmonic_score
+
+            # Collect all tracks' notes, scored by harmonic-ness
+            harmonic_pool: list[dict] = []
+            for i in range(min(track_count, 16)):
                 try:
                     clip_info = ableton.send_command("get_clip_info", {
                         "track_index": i, "clip_index": 0,
                     })
-                    if clip_info.get("is_midi"):
-                        notes_result = ableton.send_command("get_notes", {
-                            "track_index": i, "clip_index": 0,
-                        })
-                        notes = notes_result.get("notes", [])
-                        if notes:
-                            key_result = detect_key(notes)
-                            mode = key_result.get("mode", "")
-                            mode_suffix = "m" if "minor" in mode else ""
-                            song_key = f"{key_result['tonic_name']}{mode_suffix}"
-                            break
                 except Exception as exc:
-                    logger.debug("key detection on track %d skipped: %s", i, exc)
+                    logger.debug("get_clip_info(%d) skipped: %s", i, exc)
+                    continue
+                # Accept either the new is_midi_clip field or the legacy
+                # is_midi (in case some install combines versions)
+                is_midi = (
+                    clip_info.get("is_midi_clip")
+                    or clip_info.get("is_midi")
+                    or False
+                )
+                if not is_midi:
                     continue
+                try:
+                    notes_result = ableton.send_command("get_notes", {
+                        "track_index": i, "clip_index": 0,
+                    })
+                except Exception as exc:
+                    logger.debug("get_notes(%d) skipped: %s", i, exc)
+                    continue
+                notes = notes_result.get("notes", []) if isinstance(
+                    notes_result, dict
+                ) else []
+                if not notes:
+                    continue
+                track_name = (
+                    existing_roles[i] if i < len(existing_roles) else ""
+                )
+                if harmonic_score(notes, track_name) >= 0.3:
+                    harmonic_pool.extend(notes)
+
+            if harmonic_pool:
+                key_result = detect_key(harmonic_pool)
+                mode = key_result.get("mode", "")
+                mode_suffix = "m" if "minor" in mode else ""
+                song_key = f"{key_result['tonic_name']}{mode_suffix}"
         except ImportError:
             pass
+        except Exception as exc:
+            logger.debug("key aggregation failed: %s", exc)
     except Exception as exc:
         logger.warning("session context for evaluate_sample_fit failed: %s", exc)
 

package/mcp_server/semantic_moves/sound_design_compilers.py

@@ -14,9 +14,11 @@ from . import resolvers
 def _compile_add_warmth(move: SemanticMove, kernel: dict) -> CompiledPlan:
     """Compile 'add_warmth': volume boost + reverb send for perceived warmth.
 
-    SAFETY: Never blindly set device parameters — device_index=0, parameter_index=0
-    can kill audio if the first device isn't a Saturator. Only adjust device params
-    when find_device_on_track confirms a Saturator is present.
+    SAFETY: Never target device parameters by raw index. Ableton's parameter
+    index 0 is "Device On" on every device, so set_device_parameter(idx=0)
+    with any fractional value rounds to 0 and DISABLES the device. Use sends
+    and volume for warmth; device-param automation is only safe once the
+    resolver can look parameters up by name.
     """
     steps = []
     descriptions = []
@@ -31,24 +33,6 @@ def _compile_add_warmth(move: SemanticMove, kernel: dict) -> CompiledPlan:
         idx = t["index"]
         name = t["name"]
 
-        # Try to find a Saturator on the track (safe device adjustment)
-        saturator = resolvers.find_device_on_track(kernel, idx, "Saturator")
-        if saturator:
-            steps.append(CompiledStep(
-                tool="set_device_parameter",
-                params={
-                    "track_index": idx,
-                    "device_index": saturator["device_index"],
-                    "parameter_index": 0,
-                    "value": 0.3,
-                },
-                description=f"Gentle Saturator drive on {name}",
-            ))
-            descriptions.append(f"Saturate {name}")
-        else:
-            # No Saturator found — use volume + send instead of risky device params
-            warnings.append(f"No Saturator on {name} — using volume+reverb for warmth")
-
         # Boost volume slightly for perceived warmth
         steps.append(CompiledStep(
             tool="set_track_volume",
@@ -84,32 +68,22 @@ def _compile_add_warmth(move: SemanticMove, kernel: dict) -> CompiledPlan:
 
 
 def _compile_add_texture(move: SemanticMove, kernel: dict) -> CompiledPlan:
-    """Compile 'add_texture': perlin filter motion + delay send."""
+    """Compile 'add_texture': delay send for spatial texture.
+
+    Device-parameter automation (perlin filter motion) was removed because it
+    targeted device_index=0, parameter_index=0 without a resolver check — that
+    hits "Device On" on every Ableton device and would silently disable the
+    first device. Re-enable once resolvers.find_device_parameter lands.
+    """
     steps = []
     descriptions = []
+    warnings = []
 
     targets = resolvers.find_tracks_by_role(kernel, ["pad", "chords", "lead"])
 
     for t in targets[:1]:
         idx = t["index"]
         name = t["name"]
-        steps.append(CompiledStep(
-            tool="apply_automation_shape",
-            params={
-                "track_index": idx,
-                "clip_index": 0,
-                "parameter_type": "device",
-                "device_index": 0,
-                "parameter_index": 0,
-                "curve_type": "perlin",
-                "center": 0.4,
-                "amplitude": 0.2,
-                "duration": 8,
-                "density": 16,
-            },
-            description=f"Perlin filter motion on {name} for organic texture",
-        ))
-        descriptions.append(f"Perlin filter on {name}")
 
         # Add delay send
         steps.append(CompiledStep(
@@ -119,6 +93,9 @@ def _compile_add_texture(move: SemanticMove, kernel: dict) -> CompiledPlan:
         ))
         descriptions.append(f"Delay texture on {name}")
 
+    if not targets:
+        warnings.append("No pad/chords/lead tracks — texture needs a melodic bed")
+
     steps.append(CompiledStep(
         tool="get_track_meters",
         params={"include_stereo": True},
@@ -132,14 +109,17 @@ def _compile_add_texture(move: SemanticMove, kernel: dict) -> CompiledPlan:
         risk_level="medium",
         summary="; ".join(descriptions) if descriptions else "No tracks for texture",
         requires_approval=(kernel.get("mode", "improve") != "explore"),
+        warnings=warnings,
     )
 
 
 def _compile_shape_transients(move: SemanticMove, kernel: dict) -> CompiledPlan:
     """Compile 'shape_transients': push drum volume for punch, adjust sends.
 
-    SAFETY: Never blindly set device parameters. Only adjust Compressor params
-    when find_device_on_track confirms one exists. Otherwise use volume for punch.
+    SAFETY: Never target device parameters by raw index. Index 0 on every
+    Ableton device is "Device On" — writing 0.2 rounds to 0 and disables the
+    device. Punch is achieved via volume + send shaping; Compressor attack
+    automation is only safe once the resolver can look parameters up by name.
     """
     steps = []
     descriptions = []
@@ -158,24 +138,7 @@ def _compile_shape_transients(move: SemanticMove, kernel: dict) -> CompiledPlan:
         idx = dt["index"]
         name = dt["name"]
 
-        # Try to find a Compressor on the track
-        compressor = resolvers.find_device_on_track(kernel, idx, "Compressor")
-        if compressor:
-            steps.append(CompiledStep(
-                tool="set_device_parameter",
-                params={
-                    "track_index": idx,
-                    "device_index": compressor["device_index"],
-                    "parameter_index": 0,
-                    "value": 0.2,
-                },
-                description=f"Faster Compressor attack on {name} for snap",
-            ))
-            descriptions.append(f"Shape {name} compressor")
-        else:
-            warnings.append(f"No Compressor on {name} — using volume push for punch")
-
-        # Push volume for transient punch regardless
+        # Push volume for transient punch
         steps.append(CompiledStep(
             tool="set_track_volume",
             params={"track_index": idx, "volume": 0.75},

package/mcp_server/semantic_moves/transition_compilers.py

@@ -8,31 +8,20 @@ from . import resolvers
 
 
 def _compile_increase_forward_motion(move: SemanticMove, kernel: dict) -> CompiledPlan:
-    """Compile 'increase_forward_motion': rising filter + rhythm push."""
+    """Compile 'increase_forward_motion': rhythm push + reverb wash.
+
+    Device-parameter automation (rising filter sweep) was removed: targeting
+    device_index=0, parameter_index=0 without a resolver lookup hits "Device
+    On" on every Ableton device and would disable the first effect. Re-enable
+    once resolvers.find_device_parameter can locate a filter cutoff by name.
+    """
     steps = []
     descriptions = []
+    warnings = []
 
     melodic = resolvers.find_tracks_by_role(kernel, ["chords", "lead", "pad"])
     drums = resolvers.find_tracks_by_role(kernel, ["drums", "percussion"])
 
-    for mt in melodic[:1]:
-        steps.append(CompiledStep(
-            tool="apply_automation_shape",
-            params={
-                "track_index": mt["index"],
-                "clip_index": 0,
-                "parameter_type": "device",
-                "device_index": 0,
-                "parameter_index": 0,
-                "curve_type": "exponential",
-                "start": 0.2,
-                "end": 0.7,
-                "duration": 4,
-            },
-            description=f"Rising filter sweep on {mt['name']} over 4 bars",
-        ))
-        descriptions.append(f"Rising filter on {mt['name']}")
-
     for dt in drums[:1]:
         steps.append(CompiledStep(
             tool="set_track_volume",
@@ -49,6 +38,9 @@ def _compile_increase_forward_motion(move: SemanticMove, kernel: dict) -> Compil
         ))
         descriptions.append(f"Reverb wash on {mt['name']}")
 
+    if not drums and not melodic:
+        warnings.append("No drum or melodic tracks — cannot build forward motion")
+
     steps.append(CompiledStep(
         tool="get_track_meters",
         params={"include_stereo": True},
@@ -62,6 +54,7 @@ def _compile_increase_forward_motion(move: SemanticMove, kernel: dict) -> Compil
         risk_level="low",
         summary="; ".join(descriptions) if descriptions else "No melodic tracks for motion",
         requires_approval=(kernel.get("mode", "improve") != "explore"),
+        warnings=warnings,
     )
 
 

package/mcp_server/server.py

@@ -33,13 +33,76 @@ def _identify_port_holder(port: int) -> str | None:
                         text=True, timeout=2,
                     ).strip()
                     return f"{pid} ({cmdline[:60]})"
-                except (subprocess.CalledProcessError, FileNotFoundError):
+                except (subprocess.CalledProcessError,
+                        subprocess.TimeoutExpired,
+                        FileNotFoundError):
                     return str(pid)
         return None
-    except (subprocess.CalledProcessError, FileNotFoundError, ValueError):
+    except (subprocess.CalledProcessError,
+            subprocess.TimeoutExpired,
+            FileNotFoundError,
+            ValueError):
+        # TimeoutExpired catches the busy-system case where lsof exceeds
+        # the 3-second budget; we treat it as "can't identify" and return
+        # None so startup never stalls for slow host diagnostics.
         return None
 
 
+def _check_remote_script_version(ableton: AbletonConnection) -> None:
+    """BUG-A1: detect stale Remote Script installs at startup.
+
+    The installed Remote Script is loaded by Ableton at its own launch time
+    and cached in Python's module system — source-tree edits don't take
+    effect until the user reinstalls + restarts Live. When the installed
+    copy lags behind the MCP-server source, commands added after the install
+    date (e.g. ``insert_device`` in v1.10.6) return "Unknown command type".
+
+    This check pings the Remote Script, compares its reported version to
+    the MCP server version, and logs a loud warning on mismatch. We don't
+    abort — the server should still work for whatever handlers the older
+    Remote Script does support — but we make the drift visible.
+    """
+    import sys
+
+    try:
+        from . import __version__ as mcp_version
+    except ImportError:
+        mcp_version = "unknown"
+
+    try:
+        pong = ableton.send_command("ping")
+    except Exception as exc:
+        import logging as _logging
+        _logging.getLogger(__name__).debug(
+            "Remote Script version check failed: %s", exc,
+        )
+        return
+
+    if not isinstance(pong, dict):
+        return
+    rs_version = pong.get("remote_script_version")
+    if rs_version is None:
+        # Remote Script is old enough that it doesn't even embed its version
+        # in ping responses — definitely stale.
+        msg = (
+            "LivePilot: Remote Script is out of date (pre-version-handshake). "
+            "Run 'npx livepilot --install' and restart Ableton Live to fix "
+            "'Unknown command type' errors for newer tools (insert_device, "
+            "set_clip_pitch, etc)."
+        )
+        print(msg, file=sys.stderr)
+        return
+
+    if str(rs_version) != str(mcp_version):
+        msg = (
+            f"LivePilot: Remote Script version {rs_version} does not match "
+            f"MCP server version {mcp_version}. Newer tools may fail with "
+            f"'Unknown command type'. Run 'npx livepilot --install' and "
+            f"restart Ableton Live to resync."
+        )
+        print(msg, file=sys.stderr)
+
+
 def _master_has_livepilot_analyzer(ableton: AbletonConnection) -> bool:
     """Check whether the analyzer device is currently on the master track."""
     try:
@@ -128,6 +191,9 @@ async def lifespan(server):
     }
 
     try:
+        # BUG-A1: detect stale Remote Script installs early so the user
+        # sees a clear message instead of cryptic "Unknown command type" errors.
+        _check_remote_script_version(ableton)
         if bridge_state["transport"] is not None:
             await _warm_analyzer_bridge(ableton, spectral)
         yield {

package/mcp_server/session_continuity/models.py

@@ -50,6 +50,9 @@ class SessionStory:
     """The narrative of the current session."""
 
     song_id: str = ""
+    # BUG-B16: link back to the SongBrain snapshot that generated the
+    # identity_summary so callers can tell which brain was used.
+    song_brain_id: str = ""
     identity_summary: str = ""
     what_changed_last: str = ""
     what_still_feels_open: list[str] = field(default_factory=list)
@@ -60,6 +63,7 @@ class SessionStory:
     def to_dict(self) -> dict:
         return {
             "song_id": self.song_id,
+            "song_brain_id": self.song_brain_id,
             "identity_summary": self.identity_summary,
             "what_changed_last": self.what_changed_last,
             "what_still_feels_open": self.what_still_feels_open,

package/mcp_server/session_continuity/tracker.py

@@ -50,10 +50,23 @@ def reset_story() -> None:
 def get_session_story(
     song_brain: Optional[dict] = None,
 ) -> SessionStory:
-    """Get the current session story with identity summary."""
+    """Get the current session story with identity summary.
+
+    BUG-B16: now also populates song_brain_id from the passed brain so
+    callers can tell which brain generated the identity_summary.
+    Previously the field was empty and users got a half-populated
+    response that read as "something's wrong" even though the partial
+    data was correct for a fresh session.
+    """
     song_brain = song_brain or {}
 
     _story.identity_summary = song_brain.get("identity_core", "")
+    _story.song_brain_id = str(song_brain.get("brain_id", "") or "")
+    # Carry song_id through when present on the brain — fresh sessions
+    # leave this empty, which is documented below.
+    if not _story.song_id and song_brain.get("song_id"):
+        _story.song_id = str(song_brain.get("song_id"))
+
     _story.threads = [t for t in _threads.values() if t.status == "open"]
     _story.turns = _turns
     _story.what_still_feels_open = [