@@ -445,6 +445,7 @@ async def ingest_audio(
     device_name: str = Form(...),
     direction: Literal["input", "output", "unknown"] = Form(...),
     content_hash: str = Form(..., pattern=r"^[0-9a-fA-F]{64}$"),
+    meeting_id: Optional[str] = Form(None, min_length=1, max_length=200),
     source: CaptureSource = Depends(_device_source),
 ):
     existing = await DeviceInputItem.find_one(
@@ -474,6 +475,7 @@ async def ingest_audio(
             "device_name": device_name,
             "direction": direction,
             "duration_seconds": duration_seconds,
+            **({"meeting_id": meeting_id} if meeting_id else {}),
         },
         media_data=data,
         media_filename=file.filename or "chunk.wav",
 
@@ -29,6 +29,11 @@
 _SESSION_GAP = timedelta(seconds=60)
 _CLOSE_DELAY = timedelta(seconds=90)
 _MAX_SESSION = timedelta(minutes=30)
+# Chunks the collector tagged with the same meeting interval belong to one
+# conversation: tolerate longer silences and only split at a safety cap
+# instead of the blind 30-minute rule.
+_MEETING_SESSION_GAP = timedelta(minutes=5)
+_MAX_MEETING_SESSION = timedelta(hours=2)
 
 
 def _as_utc(value: datetime) -> datetime:
@@ -38,6 +43,11 @@ def _as_utc(value: datetime) -> datetime:
     return value.astimezone(timezone.utc)
 
 
+def _meeting_id(item: DeviceInputItem) -> str | None:
+    value = item.metadata.get("meeting_id")
+    return str(value) if value else None
+
+
 def group_audio_sessions(items: list[DeviceInputItem]) -> list[list[DeviceInputItem]]:
     sessions: list[list[DeviceInputItem]] = []
     for item in sorted(items, key=lambda row: _as_utc(row.captured_at)):
@@ -48,9 +58,18 @@ def group_audio_sessions(items: list[DeviceInputItem]) -> list[list[DeviceInputI
         previous_end = _as_utc(previous.ended_at or previous.captured_at)
         session_start = _as_utc(sessions[-1][0].captured_at)
         captured_at = _as_utc(item.captured_at)
+        # A meeting boundary always starts a new session; within one meeting
+        # the collector's interval is trusted over the blind gap/duration
+        # rules, up to a safety cap.
+        same_meeting = _meeting_id(item) is not None and _meeting_id(
+            item
+        ) == _meeting_id(previous)
+        gap_limit = _MEETING_SESSION_GAP if same_meeting else _SESSION_GAP
+        max_session = _MAX_MEETING_SESSION if same_meeting else _MAX_SESSION
         if (
-            captured_at - previous_end > _SESSION_GAP
-            or captured_at - session_start >= _MAX_SESSION
+            _meeting_id(item) != _meeting_id(previous)
+            or captured_at - previous_end > gap_limit
+            or captured_at - session_start >= max_session
         ):
             sessions.append([item])
         else:
 
@@ -7,11 +7,17 @@
 )
 
 
-def item(identifier: str, start: datetime, duration: float = 30):
+def item(
+    identifier: str,
+    start: datetime,
+    duration: float = 30,
+    meeting_id: str | None = None,
+):
     return SimpleNamespace(
         source_item_id=identifier,
         captured_at=start,
         ended_at=start + timedelta(seconds=duration),
+        metadata={"meeting_id": meeting_id} if meeting_id else {},
     )
 
 
@@ -60,6 +66,69 @@ def test_continuous_capture_is_bounded_into_processing_windows():
     assert [len(session) for session in sessions] == [30, 2]
 
 
+def test_meeting_chunks_are_not_split_by_the_thirty_minute_window():
+    start = datetime(2026, 7, 22, tzinfo=timezone.utc)
+    rows = [
+        item(str(index), start + timedelta(minutes=index), meeting_id="meeting:1")
+        for index in range(45)
+    ]
+    sessions = group_audio_sessions(rows)
+    assert [len(session) for session in sessions] == [45]
+
+
+def test_meeting_boundary_starts_a_new_session():
+    start = datetime(2026, 7, 22, tzinfo=timezone.utc)
+    sessions = group_audio_sessions(
+        [
+            item("ambient", start),
+            item("call-1", start + timedelta(seconds=30), meeting_id="meeting:1"),
+            item("call-2", start + timedelta(seconds=60), meeting_id="meeting:1"),
+            item("after", start + timedelta(seconds=90)),
+        ]
+    )
+    assert [[row.source_item_id for row in session] for session in sessions] == [
+        ["ambient"],
+        ["call-1", "call-2"],
+        ["after"],
+    ]
+
+
+def test_back_to_back_meetings_stay_separate_conversations():
+    start = datetime(2026, 7, 22, tzinfo=timezone.utc)
+    sessions = group_audio_sessions(
+        [
+            item("first", start, meeting_id="meeting:1"),
+            item("second", start + timedelta(seconds=30), meeting_id="meeting:2"),
+        ]
+    )
+    assert len(sessions) == 2
+
+
+def test_meeting_tolerates_longer_silences_than_ambient_capture():
+    start = datetime(2026, 7, 22, tzinfo=timezone.utc)
+    sessions = group_audio_sessions(
+        [
+            item("one", start, meeting_id="meeting:1"),
+            item("two", start + timedelta(minutes=4), meeting_id="meeting:1"),
+            item("three", start + timedelta(minutes=11), meeting_id="meeting:1"),
+        ]
+    )
+    assert [[row.source_item_id for row in session] for session in sessions] == [
+        ["one", "two"],
+        ["three"],
+    ]
+
+
+def test_meetings_still_split_at_the_safety_cap():
+    start = datetime(2026, 7, 22, tzinfo=timezone.utc)
+    rows = [
+        item(str(index), start + timedelta(minutes=4 * index), meeting_id="meeting:1")
+        for index in range(32)
+    ]
+    sessions = group_audio_sessions(rows)
+    assert [len(session) for session in sessions] == [30, 2]
+
+
 def test_mongo_naive_and_aware_timestamps_group_together():
     naive = datetime(2026, 7, 22, 10, 0)
     aware = datetime(2026, 7, 22, 10, 0, 30, tzinfo=timezone.utc)
 
@@ -482,6 +482,33 @@ def installed_legacy_units() -> list[str]:
 # ── update integration ───────────────────────────────────────────────────────
 
 
+# Flags the recommended recorder invocation no longer carries. The recorder's
+# spec argv is per-node state that code updates never regenerate (and the
+# tray's capture dialog edits only capture flags), so a retired flag would
+# survive every update without this sweep. Currently: the meeting detector
+# must stay ON — the collector mirrors the recorder's persisted meetings into
+# Chronicle's session bounds (see docs/screenpipe.md).
+_RETIRED_RECORDER_FLAGS = ("--disable-meeting-detector",)
+
+
+def migrate_recorder_spec() -> bool:
+    """Drop retired flags from the recorder spec; True if anything changed.
+
+    Regenerates the unit/plist and restarts the recorder so the change takes
+    effect — the one case worth interrupting a live capture session for.
+    """
+    name = "screenpipe"
+    if not component_installed(name) or not component_spec_path(name).exists():
+        return False
+    spec = read_component_spec(name)
+    argv = [arg for arg in spec["argv"] if arg not in _RETIRED_RECORDER_FLAGS]
+    if argv == spec["argv"]:
+        return False
+    update_component_argv(name, argv)
+    component_action(name, "restart")
+    return True
+
+
 def restart_installed(progress=None) -> list[tuple[str, bool]]:
     """Restart every installed client unit so it picks up updated code.
 
@@ -492,10 +519,17 @@ def restart_installed(progress=None) -> list[tuple[str, bool]]:
 
     Spec components are skipped: they run a third-party binary this repo does
     not ship, so an update gives them nothing and a restart would drop a live
-    capture session for no reason.
+    capture session for no reason. The one exception is a retired-flag
+    migration, which does regenerate and restart the recorder.
     """
     progress = progress or (lambda msg: None)
     results: list[tuple[str, bool]] = []
+    try:
+        if migrate_recorder_spec():
+            progress("Recorder flags migrated (meeting detector re-enabled)")
+            results.append(("screenpipe", True))
+    except Exception:
+        results.append(("screenpipe", False))
     for name in installed_components():
         if CLIENT_COMPONENTS[name].get("spec"):
             continue
 
@@ -137,6 +137,45 @@ requests zero or one 640px preview; the curator may request one different previe
 selected ScreenPipe image is then fetched at a bounded 1280px size. ScreenPipe remains
 the high-resolution source and Chronicle never uploads a frame sequence.
 
+## Meeting detection and audio session bounds
+
+Without a meeting signal, the backend can only sessionize forwarded audio by blind
+time rules (60 s gap, 30-minute hard split), so a 45-minute call became two arbitrary
+conversations. The collector now supplies real meeting intervals from two sources,
+recorder first:
+
+1. **The recorder's own meetings table (macOS / Windows — preferred).** ScreenPipe's
+   meeting watcher (CoreAudio process taps / WASAPI sessions) persists meetings —
+   with titles — into `db.sqlite`'s `meetings` table. The collector mirrors those
+   rows into Chronicle events and, because the rows are persisted, this is
+   **retroactive**: a meeting recorded while the collector was down still gets its
+   bounds on backfill. The recommended recording flags therefore no longer pass
+   `--disable-meeting-detector`; use ScreenPipe's `ignored_meeting_apps` for
+   exclusions. Once the recorder has written a meeting recently, it owns detection
+   on that node and the collector's own sensor stands down.
+2. **The collector's PipeWire tracker (Linux fallback).** Upstream ScreenPipe has no
+   Linux sensor, so the collector runs the pattern the bot-free note-takers
+   (Granola, ScreenPipe's watcher) converged on: a process holding a *running*
+   PipeWire microphone capture stream (`pw-dump`, `media.class =
+   Stream/Input/Audio`, `state = running` — browsers cork the stream outside calls)
+   is the trigger; classification is allowlist-only (known meeting apps directly, a
+   browser attributed through the current observation's `browser_url`, falling back
+   to `browser-call`), so always-on capturers — ScreenPipe itself, OBS, dictation
+   tools — can never mint meetings. Hysteresis: two consecutive sightings to open
+   (pre-join lobbies, mic tests), a 30 s grace before closing at the drop time, and
+   a stale-sensor close so a dead `pw-dump` cannot pin a meeting open. Live-only:
+   intervals cover only time the collector was running.
+
+Meeting boundaries ship as ordinary observation open/close events
+(`metadata.observation_type = "meeting"`, `detection_source = recorder|pipewire`),
+so they land on the timeline and join overlapping conversations through the existing
+correlation. Each forwarded audio chunk overlapping a meeting interval — state
+persists in `~/.local/state/chronicle-screenpipe/meetings.json` — carries a
+`meeting_id`, and the backend's session grouping (`device_audio_ingest.py`) splits
+on meeting boundaries, tolerates 5-minute silences inside one meeting, and replaces
+the 30-minute split with a 2-hour safety cap. Disable per node at pairing time with
+`--no-meeting-detection`.
+
 ## Screen context and the `chronicle` fork branch
 
 A completed conversation opens a bounded OCR job over its interval, and the collector
@@ -273,7 +312,9 @@ recorder and Chronicle collector remain independently managed background service
 ## Implementation map
 
 - `extras/screenpipe-collector/`: collector CLI, observation state machine, checkpoints, and service installation
+- `extras/screenpipe-collector/chronicle_screenpipe/meeting.py`: PipeWire meeting detection and audio-chunk tagging
 - `backends/advanced/src/advanced_omi_backend/routers/modules/device_input_routes.py`: capture-node ingestion API
+- `backends/advanced/src/advanced_omi_backend/services/device_audio_ingest.py`: meeting-aware audio sessionization into conversations
 - `backends/advanced/src/advanced_omi_backend/services/observation_curation.py`: sparse preview and vault curation
 - `extras/vault-sync/vault_core.py` and `syncthing_manager.py`: vault sync core and Syncthing pairing/control
 - `extras/chronicle-tray/chronicle_tray/sections/vault.py`: unified tray UI adapter (imports the vault-sync core in place)
@@ -28,7 +28,7 @@ pixels and OCR are retrieved only for bounded jobs requested by Chronicle. See t
      --disable-clipboard-capture --capture-scroll true \
      --prioritize-input-latency --pause-on-drm-content \
      --screenpipe-aec-enabled \
-     --disable-meeting-detector --disable-telemetry \
+     --disable-telemetry \
      --video-quality balanced --retention-days 90 \
      --retention-mode media --api-auth true
    ```
@@ -46,6 +46,20 @@ pixels and OCR are retrieved only for bounded jobs requested by Chronicle. See t
    locally recorded sources are uploaded. The guided setup asks for both the local
    capture mode and forwarding mode.
 
+   Leave ScreenPipe's meeting detector **enabled** (no
+   `--disable-meeting-detector`): on macOS and Windows it persists meetings —
+   with titles — into its own database, and the companion mirrors those rows
+   into Chronicle and tags forwarded audio chunks with the meeting interval,
+   so the backend bounds the conversation on the real call instead of fixed
+   time windows. Because the rows are persisted, bounds survive companion
+   downtime and backfill retroactively. Use ScreenPipe's
+   `ignored_meeting_apps` to exclude specific apps. On Linux, where ScreenPipe
+   has no meeting sensor, the companion detects calls itself from the PipeWire
+   graph (a known meeting app or browser holding a *running* microphone
+   stream, browsers attributed through the current observation's URL) —
+   live-only, so intervals only cover time the companion was running. Disable
+   all of it at pairing time with `--no-meeting-detection`.
+
 4. Run the companion:
 
    ```bash