cli-consumption 0.1.0__tar.gz → 0.1.1__tar.gz

{cli_consumption-0.1.0 → cli_consumption-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cli-consumption
-Version: 0.1.0
+Version: 0.1.1
 Summary: Analyze and consolidate AI coding CLI consumption across machines.
 Project-URL: Homepage, https://github.com/Guillaume-Lombardo/cli-consumption
 Project-URL: Documentation, https://github.com/Guillaume-Lombardo/cli-consumption#readme
@@ -95,6 +95,7 @@ Use the provider name below with `--provider` to select one CLI explicitly.
 | Grok Build | `grok` | `~/.grok/sessions/` | Per-prompt aggregates, reasoning effort, TTFT, and auto-compactions; no costs or subagent relationships. |
 | Kilo Code | `kilo` | `~/.local/share/kilo/kilo.db` | CLI SQLite store only; excludes legacy IDE tasks, cloud sessions, subagents, context windows, and costs. |
 | Kimi Code CLI | `kimi` | `~/.kimi/sessions/` | Wire v1 events, context windows, and compactions; selected model is not persisted and is reported as `unknown`. |
+| Mistral Vibe CLI | `mistral-vibe` | `~/.vibe/logs/session/` | Session-level token aggregates, user turns, tools, and compactions; no per-message timestamps or historical model attribution. |
 | OpenCode | `opencode` | `~/.local/share/opencode/opencode.db` | SQLite v2 only; no legacy storage, child sessions, context windows, or costs. |
 | OpenHands CLI | `openhands` | `~/.openhands/conversations/` | SDK persistence with context windows, reasoning effort, and condensations; excludes cloud-only conversations and delegates. |
 | Pi | `pi` | `~/.pi/agent/sessions/` | Counts all persisted branches; no branch relationships, custom-directory auto-detection, context windows, or provider-reported durations. |

{cli_consumption-0.1.0 → cli_consumption-0.1.1}/README.md

@@ -67,6 +67,7 @@ Use the provider name below with `--provider` to select one CLI explicitly.
 | Grok Build | `grok` | `~/.grok/sessions/` | Per-prompt aggregates, reasoning effort, TTFT, and auto-compactions; no costs or subagent relationships. |
 | Kilo Code | `kilo` | `~/.local/share/kilo/kilo.db` | CLI SQLite store only; excludes legacy IDE tasks, cloud sessions, subagents, context windows, and costs. |
 | Kimi Code CLI | `kimi` | `~/.kimi/sessions/` | Wire v1 events, context windows, and compactions; selected model is not persisted and is reported as `unknown`. |
+| Mistral Vibe CLI | `mistral-vibe` | `~/.vibe/logs/session/` | Session-level token aggregates, user turns, tools, and compactions; no per-message timestamps or historical model attribution. |
 | OpenCode | `opencode` | `~/.local/share/opencode/opencode.db` | SQLite v2 only; no legacy storage, child sessions, context windows, or costs. |
 | OpenHands CLI | `openhands` | `~/.openhands/conversations/` | SDK persistence with context windows, reasoning effort, and condensations; excludes cloud-only conversations and delegates. |
 | Pi | `pi` | `~/.pi/agent/sessions/` | Counts all persisted branches; no branch relationships, custom-directory auto-detection, context windows, or provider-reported durations. |

{cli_consumption-0.1.0 → cli_consumption-0.1.1}/docs/provider-support.md

@@ -17,6 +17,7 @@
 | Grok Build | Supported (core) | Local session summary and update/event JSONL |
 | Kilo Code | Supported (core) | Local SQLite session store |
 | Kimi Code CLI | Supported (core) | Local Wire event JSONL |
+| Mistral Vibe CLI | Supported (core) | Local session metadata JSON and message JSONL |
 | OpenCode | Supported (core) | Local SQLite v2 session store |
 | OpenHands CLI | Supported (core) | Local SDK conversation state and event JSON |
 | Pi | Supported (core) | Local session JSONL v1-v3 |
@@ -31,6 +32,29 @@ It does not mean that token counters are equivalent to invoices.
 ingests each metadata-only snapshot independently. With no explicit source it checks
 the local default homes; repeated `--source` paths are filtered by detected format.
 
+## Mistral Vibe CLI
+
+Mistral Vibe CLI reads top-level session directories under
+`~/.vibe/logs/session/`, when interaction logging is enabled. The adapter was
+qualified against Mistral Vibe 2.24.5 and its current `meta.json` plus
+`messages.jsonl` format in August 2026. It extracts stable session and user-message
+identifiers, session timestamps, the latest active model alias, cumulative token
+usage, function names from assistant tool calls, and compaction markers. Working
+directories are inspected only for explicit project mappings. Titles, prompts,
+responses, reasoning, tool arguments/results, system instructions, usernames, Git
+metadata, environment values other than the mapped working directory, prices,
+arbitrary configuration, and raw messages are discarded.
+
+Vibe persists prompt, cached-prompt, and completion counters only as cumulative
+session statistics. The adapter therefore emits one unattributed aggregate model
+call, subtracts cached prompt tokens from uncached input, and does not assign token
+usage to individual turns. The persisted active model is the latest selection and is
+not attributed historically to turns. Message records have no timestamps, so turns,
+tools, and compactions do not expose event times or durations. Child-agent sessions,
+model changes, cache writes, reasoning tokens, context-window samples, costs, tool
+outcomes, and provider-reported latency are not collected. Vibe's internal session
+format can change without notice, and local token events are not billing data.
+
 ## Codex
 
 Codex additionally exposes provider-reported turn duration and TTFT, model context

{cli_consumption-0.1.0 → cli_consumption-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cli-consumption"
-version = "0.1.0"
+version = "0.1.1"
 description = "Analyze and consolidate AI coding CLI consumption across machines."
 readme = "README.md"
 requires-python = ">=3.14"

{cli_consumption-0.1.0 → cli_consumption-0.1.1}/src/cli_consumption/adapters/__init__.py

@@ -13,6 +13,7 @@ from cli_consumption.adapters.goose import GooseAdapter
 from cli_consumption.adapters.grok import GrokAdapter
 from cli_consumption.adapters.kilo import KiloAdapter
 from cli_consumption.adapters.kimi import KimiAdapter
+from cli_consumption.adapters.mistral_vibe import MistralVibeAdapter
 from cli_consumption.adapters.opencode import OpenCodeAdapter
 from cli_consumption.adapters.openhands import OpenHandsAdapter
 from cli_consumption.adapters.pi import PiAdapter
@@ -35,6 +36,7 @@ __all__ = [
     "GrokAdapter",
     "KiloAdapter",
     "KimiAdapter",
+    "MistralVibeAdapter",
     "OpenCodeAdapter",
     "OpenHandsAdapter",
     "PiAdapter",

cli_consumption-0.1.1/src/cli_consumption/adapters/mistral_vibe.py

@@ -0,0 +1,281 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from cli_consumption.adapters._shared import (
+    add_tokens,
+    counter,
+    iso,
+    label,
+    mapping,
+    project,
+    timestamp,
+    tokens,
+)
+from cli_consumption.models import Snapshot, empty_tokens
+
+
+@dataclass(slots=True)
+class _Candidate:
+    machine: str
+    external_id: str
+    metadata: dict[str, Any]
+    messages: list[dict[str, Any]]
+    event_count: int
+    digest: str
+
+
+class MistralVibeAdapter:
+    """Read Mistral Vibe session logs without retaining conversation content."""
+
+    name = "mistral-vibe"
+
+    def collect(
+        self,
+        sources: list[tuple[str, Path]],
+        project_mappings: list[tuple[str, str]] | None = None,
+    ) -> Snapshot:
+        selected: dict[str, _Candidate] = {}
+        duplicates = malformed = 0
+        for machine, home in sources:
+            sessions = home / "logs" / "session"
+            if not sessions.is_dir():
+                raise ValueError(
+                    f"Missing Mistral Vibe session log directory: {sessions}"
+                )
+            for metadata_path in sorted(sessions.glob("*/meta.json")):
+                candidate, invalid = _read_candidate(machine, metadata_path)
+                malformed += invalid
+                if candidate is None:
+                    continue
+                previous = selected.get(candidate.external_id)
+                if previous is None:
+                    selected[candidate.external_id] = candidate
+                    continue
+                duplicates += 1
+                if _rank(candidate) > _rank(previous):
+                    selected[candidate.external_id] = candidate
+
+        snapshot = Snapshot(
+            provider=self.name,
+            duplicate_conversations=duplicates,
+            malformed_records=malformed,
+        )
+        for candidate in sorted(selected.values(), key=lambda item: item.external_id):
+            self._normalize(snapshot, candidate, project_mappings or [])
+        return snapshot
+
+    def _normalize(
+        self,
+        snapshot: Snapshot,
+        source: _Candidate,
+        mappings: list[tuple[str, str]],
+    ) -> None:
+        conversation_id = f"mistral-vibe:{source.external_id}"
+        started_at = timestamp(source.metadata.get("start_time"))
+        ended_at = timestamp(source.metadata.get("end_time"))
+        active_turn: dict[str, Any] | None = None
+        turn_number = 0
+        tool_number = 0
+        compaction_number = 0
+
+        for message in source.messages:
+            role = message.get("role")
+            if role == "user" and message.get("injected") is not True:
+                if active_turn is not None:
+                    active_turn["status"] = "completed"
+                turn_number += 1
+                active_turn = _turn(conversation_id, message, turn_number)
+                snapshot.turns.append(active_turn)
+                snapshot.turn_settings.append(
+                    {
+                        "id": f"{conversation_id}:settings:{turn_number}",
+                        "conversation_id": conversation_id,
+                        "turn_id": active_turn["id"],
+                        "model": None,
+                        "effort": None,
+                        "collaboration_mode": None,
+                        "service_tier": None,
+                        "context_window_tokens": None,
+                    }
+                )
+
+            if message.get("context_boundary") == "compaction":
+                compaction_number += 1
+                snapshot.compaction_events.append(
+                    {
+                        "id": f"{conversation_id}:compaction:{compaction_number}",
+                        "conversation_id": conversation_id,
+                        "turn_id": active_turn["id"] if active_turn else None,
+                        "sequence": compaction_number,
+                        "timestamp": None,
+                    }
+                )
+
+            if role != "assistant":
+                continue
+            if active_turn is not None:
+                active_turn["status"] = "completed"
+            raw_tool_calls = message.get("tool_calls")
+            if not isinstance(raw_tool_calls, list):
+                continue
+            for raw_call in raw_tool_calls:
+                function = mapping(mapping(raw_call).get("function"))
+                tool_name = label(function.get("name"))
+                if tool_name is None:
+                    snapshot.malformed_records += 1
+                    continue
+                tool_number += 1
+                if active_turn is not None:
+                    active_turn["tool_calls"] += 1
+                snapshot.tool_calls.append(
+                    {
+                        "id": f"{conversation_id}:tool:{tool_number}",
+                        "conversation_id": conversation_id,
+                        "turn_id": active_turn["id"] if active_turn else None,
+                        "sequence": tool_number,
+                        "timestamp": None,
+                        "tool_name": tool_name,
+                        "outer_tool_name": tool_name,
+                    }
+                )
+
+        stats = mapping(source.metadata.get("stats"))
+        prompt_tokens = counter(stats.get("session_prompt_tokens"))
+        cached_tokens = min(prompt_tokens, counter(stats.get("session_cached_tokens")))
+        completion_tokens = counter(stats.get("session_completion_tokens"))
+        usage = tokens(
+            uncached=prompt_tokens - cached_tokens,
+            cached=cached_tokens,
+            visible=completion_tokens,
+        )
+        config = mapping(source.metadata.get("config"))
+        model = label(config.get("active_model"), 255) or "unknown"
+        model_calls = 0
+        totals = empty_tokens()
+        if usage["total_tokens"] > 0 or counter(stats.get("steps")) > 0:
+            model_calls = 1
+            add_tokens(totals, usage)
+            snapshot.model_calls.append(
+                {
+                    "id": f"{conversation_id}:model:aggregate",
+                    "conversation_id": conversation_id,
+                    "turn_id": None,
+                    "sequence": 1,
+                    "timestamp": iso(ended_at),
+                    "model": model,
+                    **usage,
+                }
+            )
+
+        directory = mapping(source.metadata.get("environment")).get("working_directory")
+        project_name, project_source = project(
+            directory if isinstance(directory, str) else None, mappings
+        )
+        snapshot.conversations.append(
+            {
+                "id": conversation_id,
+                "provider": self.name,
+                "external_id": source.external_id,
+                "source_machine": source.machine,
+                "project": project_name,
+                "project_source": project_source,
+                "started_at": iso(started_at),
+                "ended_at": iso(ended_at),
+                "duration_seconds": _duration(started_at, ended_at),
+                "source": "local-session-json",
+                "models": [model] if model_calls else [],
+                "iterations": turn_number,
+                "model_calls": model_calls,
+                "tool_calls": tool_number,
+                "compactions": compaction_number,
+                "event_count": source.event_count,
+                "content_hash": source.digest,
+                **totals,
+            }
+        )
+
+
+def _read_candidate(machine: str, metadata_path: Path) -> tuple[_Candidate | None, int]:
+    digest = hashlib.sha256()
+    try:
+        metadata_bytes = metadata_path.read_bytes()
+        digest.update(metadata_bytes)
+        metadata = json.loads(metadata_bytes)
+    except (OSError, json.JSONDecodeError, UnicodeDecodeError):
+        return None, 1
+    if not isinstance(metadata, dict):
+        return None, 1
+    external_id = label(metadata.get("session_id"), 512)
+    if external_id is None:
+        return None, 1
+
+    messages: list[dict[str, Any]] = []
+    malformed = 0
+    messages_path = metadata_path.parent / "messages.jsonl"
+    try:
+        with messages_path.open("rb") as handle:
+            for line in handle:
+                digest.update(line)
+                if not line.strip():
+                    continue
+                try:
+                    message = json.loads(line)
+                except (json.JSONDecodeError, UnicodeDecodeError):
+                    malformed += 1
+                    continue
+                if not isinstance(message, dict) or not isinstance(
+                    message.get("role"), str
+                ):
+                    malformed += 1
+                    continue
+                messages.append(message)
+    except OSError:
+        malformed += 1
+
+    return (
+        _Candidate(
+            machine=machine,
+            external_id=external_id,
+            metadata=metadata,
+            messages=messages,
+            event_count=len(messages),
+            digest=digest.hexdigest(),
+        ),
+        malformed,
+    )
+
+
+def _turn(
+    conversation_id: str, message: dict[str, Any], sequence: int
+) -> dict[str, Any]:
+    external_id = label(message.get("message_id"), 512) or f"turn-{sequence}"
+    return {
+        "id": f"{conversation_id}:{external_id}",
+        "conversation_id": conversation_id,
+        "external_id": external_id,
+        "started_at": None,
+        "ended_at": None,
+        "status": "in-progress",
+        "duration_ms": None,
+        "time_to_first_token_ms": None,
+        "model_calls": 0,
+        "tool_calls": 0,
+        **empty_tokens(),
+    }
+
+
+def _duration(started_at: datetime | None, ended_at: datetime | None) -> float | None:
+    if started_at is None or ended_at is None:
+        return None
+    return max(0.0, (ended_at - started_at).total_seconds())
+
+
+def _rank(candidate: _Candidate) -> tuple[int, str, str]:
+    ended_at = timestamp(candidate.metadata.get("end_time"))
+    return candidate.event_count, iso(ended_at) or "", candidate.digest

{cli_consumption-0.1.0 → cli_consumption-0.1.1}/src/cli_consumption/cli.py

@@ -24,6 +24,7 @@ from cli_consumption.adapters import (
     GrokAdapter,
     KiloAdapter,
     KimiAdapter,
+    MistralVibeAdapter,
     OpenCodeAdapter,
     OpenHandsAdapter,
     PiAdapter,
@@ -83,6 +84,7 @@ def providers() -> None:
     typer.echo("cline    supported")
     typer.echo("kilo     supported")
     typer.echo("kimi     supported")
+    typer.echo("mistral-vibe supported")
     typer.echo("opencode supported")
     typer.echo("openhands supported")
     typer.echo("pi       supported")
@@ -282,6 +284,11 @@ def _collect_snapshots(
         "cline": (ClineAdapter, ".cline/data", "sessions/sessions.db"),
         "kilo": (KiloAdapter, ".local/share/kilo", "kilo.db"),
         "kimi": (KimiAdapter, ".kimi", "sessions/*/*/wire.jsonl"),
+        "mistral-vibe": (
+            MistralVibeAdapter,
+            ".vibe",
+            "logs/session/*/meta.json",
+        ),
         "opencode": (
             OpenCodeAdapter,
             ".local/share/opencode",

{cli_consumption-0.1.0 → cli_consumption-0.1.1}/tests/test_cli.py

@@ -37,6 +37,7 @@ def test_provider_status_is_explicit() -> None:
     assert "cline    supported" in result.stdout
     assert "kilo     supported" in result.stdout
     assert "kimi     supported" in result.stdout
+    assert "mistral-vibe supported" in result.stdout
     assert "opencode supported" in result.stdout
     assert "openhands supported" in result.stdout
     assert "pi       supported" in result.stdout
@@ -172,6 +173,43 @@ def test_collects_continue_cli(tmp_path: Path) -> None:
     assert "1 written" in result.stdout
 
 
+def test_collects_mistral_vibe_cli(tmp_path: Path) -> None:
+    home = tmp_path / "vibe"
+    session_dir = home / "logs" / "session" / "session_cli"
+    session_dir.mkdir(parents=True)
+    (session_dir / "meta.json").write_text(
+        json.dumps(
+            {
+                "session_id": "vibe-cli",
+                "start_time": "2026-08-27T10:00:00Z",
+                "stats": {"steps": 0},
+            }
+        ),
+        encoding="utf-8",
+    )
+    (session_dir / "messages.jsonl").write_text(
+        json.dumps({"role": "user", "message_id": "message-cli"}) + "\n",
+        encoding="utf-8",
+    )
+
+    result = runner.invoke(
+        app,
+        [
+            "collect",
+            "--provider",
+            "mistral-vibe",
+            "--source",
+            f"desktop={home}",
+            "--database",
+            str(tmp_path / "mistral-vibe.sqlite"),
+        ],
+    )
+
+    assert result.exit_code == 0, result.output
+    assert "Ingestion mistral-vibe" in result.stdout
+    assert "1 written" in result.stdout
+
+
 def test_collects_openhands_cli(tmp_path: Path) -> None:
     home = tmp_path / "openhands"
     conversation = home / "conversations" / "openhands-cli"

cli_consumption-0.1.1/tests/test_mistral_vibe_adapter.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from cli_consumption.adapters.mistral_vibe import MistralVibeAdapter
+from cli_consumption.dashboard import generate_dashboard
+from cli_consumption.exporting import export_csv
+from cli_consumption.storage import (
+    TABLES,
+    create_database_engine,
+    ingest_snapshot,
+    read_table,
+)
+
+CANARY = "mistral vibe privacy canary secret"
+
+
+def session(home: Path, *, extra: bool = False) -> Path:
+    session_dir = home / "logs" / "session" / "session_20260827_vibe0001"
+    session_dir.mkdir(parents=True)
+    metadata = {
+        "session_id": "vibe-session-1",
+        "start_time": "2026-08-27T10:00:00Z",
+        "end_time": "2026-08-27T10:05:00Z",
+        "git_commit": CANARY,
+        "git_branch": CANARY,
+        "username": CANARY,
+        "environment": {
+            "working_directory": f"/srv/work/acme/{CANARY}",
+            "secret": CANARY,
+        },
+        "title": CANARY,
+        "stats": {
+            "steps": 3,
+            "session_prompt_tokens": 100,
+            "session_completion_tokens": 20,
+            "session_cached_tokens": 40,
+            "input_price_per_million": 99,
+        },
+        "config": {
+            "active_model": "devstral-medium-latest",
+            "api_key": CANARY,
+            "system_prompt": CANARY,
+        },
+        "system_prompt": {"role": "system", "content": CANARY},
+        "tools_available": [{"function": {"name": CANARY}}],
+    }
+    (session_dir / "meta.json").write_text(json.dumps(metadata), encoding="utf-8")
+    messages = [
+        {
+            "role": "user",
+            "message_id": "user-1",
+            "content": CANARY,
+            "resources": [{"path": CANARY}],
+        },
+        {
+            "role": "assistant",
+            "message_id": "assistant-1",
+            "content": CANARY,
+            "reasoning_content": CANARY,
+            "tool_calls": [
+                {
+                    "id": "call-1",
+                    "function": {
+                        "name": "bash",
+                        "arguments": json.dumps({"secret": CANARY}),
+                    },
+                }
+            ],
+        },
+        {
+            "role": "tool",
+            "tool_call_id": "call-1",
+            "name": "bash",
+            "content": CANARY,
+            "tool_result": {"output": CANARY},
+        },
+        {
+            "role": "assistant",
+            "injected": True,
+            "context_boundary": "compaction",
+            "content": CANARY,
+        },
+        {"role": "user", "message_id": "user-2", "content": CANARY},
+        {
+            "role": "assistant",
+            "content": CANARY,
+            "tool_calls": [{"function": {"name": CANARY, "arguments": CANARY}}],
+        },
+    ]
+    if extra:
+        messages.append(
+            {"role": "assistant", "message_id": "assistant-3", "content": CANARY}
+        )
+    (session_dir / "messages.jsonl").write_text(
+        "".join(json.dumps(message) + "\n" for message in messages),
+        encoding="utf-8",
+    )
+    return session_dir
+
+
+def test_collects_session_aggregate_usage_turns_tools_and_compactions(
+    tmp_path: Path,
+) -> None:
+    home = tmp_path / "vibe"
+    session(home)
+
+    snapshot = MistralVibeAdapter().collect(
+        [("laptop", home)], [("acme", "/srv/work/acme")]
+    )
+
+    conversation = snapshot.conversations[0]
+    assert conversation["id"] == "mistral-vibe:vibe-session-1"
+    assert conversation["project"] == "acme"
+    assert conversation["project_source"] == "mapping"
+    assert conversation["models"] == ["devstral-medium-latest"]
+    assert conversation["iterations"] == 2
+    assert conversation["model_calls"] == 1
+    assert conversation["tool_calls"] == 1
+    assert conversation["compactions"] == 1
+    assert conversation["duration_seconds"] == 300
+    assert conversation["input_tokens"] == 100
+    assert conversation["uncached_input_tokens"] == 60
+    assert conversation["cached_input_tokens"] == 40
+    assert conversation["output_tokens"] == 20
+    assert conversation["visible_output_tokens"] == 20
+    assert conversation["total_tokens"] == 120
+    assert [turn["status"] for turn in snapshot.turns] == [
+        "completed",
+        "completed",
+    ]
+    assert all(turn["model_calls"] == 0 for turn in snapshot.turns)
+    assert snapshot.model_calls[0]["turn_id"] is None
+    assert snapshot.tool_calls[0]["tool_name"] == "bash"
+    assert snapshot.compaction_events[0]["turn_id"] == snapshot.turns[0]["id"]
+    assert all(setting["model"] is None for setting in snapshot.turn_settings)
+    assert snapshot.malformed_records == 1
+    assert CANARY not in json.dumps(snapshot.to_dict())
+
+
+def test_deduplicates_and_tolerates_malformed_or_partial_sessions(
+    tmp_path: Path,
+) -> None:
+    first, second = tmp_path / "first", tmp_path / "second"
+    session(first)
+    path = session(second, extra=True) / "messages.jsonl"
+    with path.open("a", encoding="utf-8") as handle:
+        handle.write("not-json\n[]\n")
+
+    snapshot = MistralVibeAdapter().collect([("desktop", first), ("laptop", second)])
+
+    assert snapshot.duplicate_conversations == 1
+    assert snapshot.malformed_records == 3
+    assert snapshot.conversations[0]["source_machine"] == "laptop"
+    assert CANARY not in json.dumps(snapshot.to_dict())
+    assert (
+        snapshot.to_dict()
+        == MistralVibeAdapter()
+        .collect([("desktop", first), ("laptop", second)])
+        .to_dict()
+    )
+
+    partial = tmp_path / "partial"
+    partial_dir = partial / "logs" / "session" / "session_partial"
+    partial_dir.mkdir(parents=True)
+    (partial_dir / "meta.json").write_text(
+        json.dumps(
+            {
+                "session_id": "partial-session",
+                "start_time": "2026-08-27T11:00:00Z",
+            }
+        ),
+        encoding="utf-8",
+    )
+    partial_snapshot = MistralVibeAdapter().collect([("machine", partial)])
+    assert partial_snapshot.malformed_records == 1
+    assert partial_snapshot.conversations[0]["model_calls"] == 0
+
+    with pytest.raises(ValueError, match="Missing Mistral Vibe session log directory"):
+        MistralVibeAdapter().collect([("machine", tmp_path / "missing")])
+
+
+def test_privacy_canary_is_absent_and_ingestion_is_idempotent(tmp_path: Path) -> None:
+    home = tmp_path / "vibe"
+    session(home)
+    snapshot = MistralVibeAdapter().collect([("machine", home)])
+    assert CANARY not in json.dumps(snapshot.to_dict())
+
+    engine = create_database_engine(tmp_path / "usage.sqlite")
+    try:
+        first = ingest_snapshot(engine, snapshot)
+        second = ingest_snapshot(engine, snapshot)
+        assert (first.written, first.skipped) == (1, 0)
+        assert (second.written, second.skipped) == (0, 1)
+        rows = {name: read_table(engine, name) for name in TABLES}
+        assert CANARY not in json.dumps(rows)
+        output = tmp_path / "reports"
+        paths = export_csv(engine, output)
+        dashboard = output / "dashboard.html"
+        generate_dashboard(engine, dashboard)
+        assert all(CANARY not in path.read_text() for path in paths)
+        assert CANARY not in dashboard.read_text()
+    finally:
+        engine.dispose()

{cli_consumption-0.1.0 → cli_consumption-0.1.1}/uv.lock

@@ -56,7 +56,7 @@ wheels = [
 
 [[package]]
 name = "cli-consumption"
-version = "0.1.0"
+version = "0.1.1"
 source = { editable = "." }
 dependencies = [
     { name = "fastapi" },