devin-internals-spec 0.3.0__py3-none-any.whl

devin_internals/__init__.py

@@ -0,0 +1,20 @@
+__version__ = "0.3.0"
+
+from devin_internals.schema import (
+    LATEST_KNOWN_SCHEMA,
+    MIN_SUPPORTED_SCHEMA,
+    SchemaDetectionError,
+    SchemaError,
+    UnknownSchemaVersionError,
+    detect_schema_version,
+)
+
+__all__ = [
+    "LATEST_KNOWN_SCHEMA",
+    "MIN_SUPPORTED_SCHEMA",
+    "SchemaDetectionError",
+    "SchemaError",
+    "UnknownSchemaVersionError",
+    "detect_schema_version",
+    "__version__",
+]

devin_internals/cli.py

@@ -0,0 +1,339 @@
+"""``devin-inspect`` — thin CLI wrapper; all logic lives in the library.
+
+Subcommands (all read-only, all accept ``--json``):
+
+- ``schema <path>``             print the schema-detection contract as JSON
+- ``sessions <sessions.db>``    list sessions (id, title, cwd, created_at, status)
+- ``health <devin-data-dir>``   locate the three stores, report versions/counts
+- ``make-fixture <out>``        write deterministic synthetic stores for tests
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sqlite3
+import sys
+from dataclasses import asdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Sequence
+
+from devin_internals import fixtures
+from devin_internals.contract import check_contract
+from devin_internals.parsers import (
+    AcpMessagesStore,
+    SessionsStore,
+    StateVscdbStore,
+)
+from devin_internals.parsers.vscdb_scan import scan as vscdb_scan
+from devin_internals.schema import SchemaError, detect_schema_version
+
+
+def _print_json(payload: Any) -> None:
+    print(json.dumps(payload, indent=2, sort_keys=False))
+
+
+def _ms_to_iso(ts: int | None) -> str:
+    if ts is None:
+        return "-"
+    return (
+        datetime.fromtimestamp(ts / 1000, tz=timezone.utc)
+        .isoformat(timespec="seconds")
+        .replace("+00:00", "Z")
+    )
+
+
+def _fmt_table(headers: list[str], rows: list[list[str]]) -> str:
+    widths = [
+        max([len(h), *(len(r[i]) for r in rows)])
+        for i, h in enumerate(headers)
+    ]
+    line = "  ".join(h.ljust(widths[i]) for i, h in enumerate(headers))
+    sep = "  ".join("-" * widths[i] for i in range(len(headers)))
+    body = [
+        "  ".join(r[i].ljust(widths[i]) for i in range(len(headers)))
+        for r in rows
+    ]
+    return "\n".join([line, sep, *body])
+
+
+def _truncate(text: str, width: int) -> str:
+    return text if len(text) <= width else text[: width - 1] + "…"
+
+
+# ---------------------------------------------------------------------------
+# subcommands
+# ---------------------------------------------------------------------------
+
+
+def cmd_schema(args: argparse.Namespace) -> int:
+    info = detect_schema_version(args.path)
+    _print_json(info)
+    return 0
+
+
+def cmd_sessions(args: argparse.Namespace) -> int:
+    with SessionsStore(args.path) as store:
+        sessions = store.sessions(limit=args.limit)
+    if args.json:
+        _print_json(
+            [
+                {**asdict(s), "status": s.status}
+                for s in sessions
+            ]
+        )
+        return 0
+    rows = [
+        [
+            _truncate(s.id, 36),
+            _truncate(s.title or "-", 30),
+            _truncate(s.working_directory, 40),
+            _ms_to_iso(s.created_at),
+            s.status,
+        ]
+        for s in sessions
+    ]
+    if rows:
+        print(_fmt_table(["ID", "TITLE", "CWD", "CREATED_AT", "STATUS"], rows))
+    else:
+        print("no sessions")
+    return 0
+
+
+def _health_sessions_db(path: Path) -> dict[str, Any]:
+    entry: dict[str, Any] = {"path": str(path), "exists": path.is_file()}
+    if not entry["exists"]:
+        return entry
+    try:
+        info = detect_schema_version(path)
+        with SessionsStore(path) as store:
+            entry["counts"] = store.counts()
+        entry["schema_version"] = info["schema_version"]
+        entry["supported"] = info["supported"]
+    except SchemaError as exc:
+        entry["error"] = str(exc)
+    return entry
+
+
+def _health_acp_messages(dir_path: Path) -> dict[str, Any]:
+    entry: dict[str, Any] = {"dir": str(dir_path), "exists": dir_path.is_dir()}
+    if not entry["exists"]:
+        return entry
+    dbs = []
+    for db in sorted(dir_path.glob("*.db")):
+        item: dict[str, Any] = {"name": db.name, "path": str(db)}
+        try:
+            with AcpMessagesStore(db) as store:
+                item["counts"] = store.counts()
+        except SchemaError as exc:
+            item["error"] = str(exc)
+        dbs.append(item)
+    entry["dbs"] = dbs
+    entry["count"] = len(dbs)
+    return entry
+
+
+def _health_state_vscdb(path: Path) -> dict[str, Any]:
+    entry: dict[str, Any] = {"path": str(path), "exists": path.is_file()}
+    if not entry["exists"]:
+        return entry
+    try:
+        with StateVscdbStore(path) as store:
+            entry["counts"] = store.counts()
+            entry["windsurf_keys"] = len(store.list_prefix())
+    except SchemaError as exc:
+        entry["error"] = str(exc)
+    return entry
+
+
+def cmd_vscdb_scan(args: argparse.Namespace) -> int:
+    with StateVscdbStore(Path(args.path).expanduser()) as store:
+        report = vscdb_scan(store)
+    if args.json:
+        print(json.dumps(report, ensure_ascii=False, indent=2))
+    else:
+        print(f"keys: {report['total_keys']} · flagged: {report['flagged_keys']}")
+        for head, n in report["key_prefixes"].items():
+            print(f"  {head}: {n}")
+        for k in report["keys"]:
+            if k.get("risk_flags"):
+                print(f"  FLAG {k['key']}  {k['value_kind']} "
+                      f"len={k['value_len']}  {','.join(k['risk_flags'])}")
+        print(f"({report['note']})")
+    return 1 if (report["flagged_keys"] and args.fail_on_flags) else 0
+
+
+def cmd_health(args: argparse.Namespace) -> int:
+    root = Path(args.devin_data_dir).expanduser()
+    report = {
+        "root": str(root),
+        "exists": root.is_dir(),
+        "stores": {
+            "sessions_db": _health_sessions_db(root / "cli" / "sessions.db"),
+            "acp_messages": _health_acp_messages(
+                root / "User" / "acp-messages"
+            ),
+            "state_vscdb": _health_state_vscdb(
+                root / "User" / "globalStorage" / "state.vscdb"
+            ),
+        },
+    }
+    stores = report["stores"]
+    ok = report["exists"] and all(
+        s["exists"] and "error" not in s for s in stores.values()
+    )
+    report["ok"] = ok
+
+    if args.json:
+        _print_json(report)
+    else:
+        s = stores["sessions_db"]
+        detail = (
+            f"v{s['schema_version']} {s['counts']}"
+            if s.get("schema_version")
+            else s.get("error", "missing")
+        )
+        print(f"sessions.db     {'OK' if s['exists'] else 'MISSING'}  {detail}")
+        a = stores["acp_messages"]
+        detail = (
+            f"{a['count']} db file(s)"
+            if a.get("count") is not None
+            else a.get("error", "missing")
+        )
+        print(f"acp-messages    {'OK' if a['exists'] else 'MISSING'}  {detail}")
+        v = stores["state_vscdb"]
+        detail = (
+            f"{v['counts']} windsurf_keys={v['windsurf_keys']}"
+            if v.get("counts")
+            else v.get("error", "missing")
+        )
+        print(f"state.vscdb     {'OK' if v['exists'] else 'MISSING'}  {detail}")
+        print(f"overall: {'OK' if ok else 'DEGRADED'}")
+    return 0 if ok else 1
+
+
+def cmd_contract(args: argparse.Namespace) -> int:
+    report = check_contract(args.devin_data_dir)
+    _print_json(report)
+    return 0 if report["status"] == "ok" else 1
+
+
+def cmd_make_fixture(args: argparse.Namespace) -> int:
+    out = Path(args.output).expanduser()
+    created: dict[str, Any]
+    if args.kind == "dir":
+        created = fixtures.create_devin_data_dir(
+            out,
+            seed=args.seed,
+            n_acp_dbs=args.n_acp_dbs,
+            schema_version=args.schema_version,
+            n_sessions=args.n_sessions,
+        )
+    elif args.kind == "sessions":
+        created = {
+            "sessions_db": fixtures.create_sessions_db(
+                out,
+                schema_version=args.schema_version,
+                seed=args.seed,
+                n_sessions=args.n_sessions,
+            )
+        }
+    elif args.kind == "acp-messages":
+        created = {"acp_messages_db": fixtures.create_acp_messages_db(out, seed=args.seed)}
+    else:
+        created = {"state_vscdb": fixtures.create_state_vscdb(out, seed=args.seed)}
+    created["synthetic"] = True
+    created["seed"] = args.seed
+    _print_json({k: [str(p) for p in v] if isinstance(v, list) else str(v)
+                 for k, v in created.items()})
+    return 0
+
+
+# ---------------------------------------------------------------------------
+# entry point
+# ---------------------------------------------------------------------------
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="devin-inspect",
+        description="Read-only inspection of Devin's local session stores.",
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p = sub.add_parser("schema", help="print the schema-detection contract")
+    p.add_argument("path", help="path to a sessions.db")
+    p.add_argument("--json", action="store_true", help="JSON output (default)")
+    p.set_defaults(func=cmd_schema)
+
+    p = sub.add_parser("sessions", help="list sessions in a sessions.db")
+    p.add_argument("path", help="path to a sessions.db")
+    p.add_argument("--limit", type=int, default=None, metavar="N",
+                   help="show at most N sessions")
+    p.add_argument("--json", action="store_true", help="JSON output")
+    p.set_defaults(func=cmd_sessions)
+
+    p = sub.add_parser("health", help="check a Devin data directory")
+    p.add_argument("devin_data_dir",
+                   help="Devin data root (contains cli/ and User/)")
+    p.add_argument("--json", action="store_true", help="JSON output")
+    p.set_defaults(func=cmd_health)
+
+    p = sub.add_parser(
+        "make-fixture",
+        help="write deterministic synthetic Devin stores (for tests/demos)",
+    )
+    p.add_argument("output",
+                   help="output dir (kind=dir) or file path (other kinds)")
+    p.add_argument("--kind", choices=["dir", "sessions", "acp-messages", "state-vscdb"],
+                   default="dir", help="what to generate (default: full data dir)")
+    p.add_argument("--seed", type=int, default=fixtures.DEFAULT_SEED,
+                   help="deterministic seed (default: %(default)s)")
+    p.add_argument("--schema-version", type=int,
+                   default=fixtures.LATEST_KNOWN_SCHEMA,
+                   help="sessions.db schema version; >17 exercises the "
+                        "unknown-version path (default: %(default)s)")
+    p.add_argument("--n-sessions", type=int, default=3,
+                   help="sessions to generate (default: %(default)s)")
+    p.add_argument("--n-acp-dbs", type=int, default=2,
+                   help="acp-messages DBs in kind=dir (default: %(default)s)")
+    p.set_defaults(func=cmd_make_fixture)
+
+    p = sub.add_parser(
+        "vscdb-scan",
+        help="shape-only audit of a state.vscdb — key names, value "
+             "types/lengths, risk flags; never prints values (IS-1)",
+    )
+    p.add_argument("path", help="path to state.vscdb")
+    p.add_argument("--json", action="store_true", help="JSON output")
+    p.add_argument("--fail-on-flags", action="store_true",
+                   help="exit 1 when any key has risk flags (CI mode)")
+    p.set_defaults(func=cmd_vscdb_scan)
+
+    p = sub.add_parser(
+        "contract",
+        help="unified drift contract: schema version, acp-messages meta, "
+             "usage shape — one report for all stores",
+    )
+    p.add_argument("devin_data_dir",
+                   help="Devin data root (contains cli/ and User/)")
+    p.set_defaults(func=cmd_contract)
+
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        return args.func(args)
+    except SchemaError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+    except (sqlite3.Error, OSError) as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

devin_internals/commits.py

@@ -0,0 +1,100 @@
+"""Extract git commit references from ``tool_call_state`` payloads.
+
+Devin sessions record shell/tool traffic as JSON blobs in
+``tool_call_state.tool_call_json`` (the call) and
+``tool_call_state.tool_call_update_json`` (streaming updates / results).
+Commits a session touched — created, inspected, pushed, linked — surface
+as 40-char hex SHAs or ``<host>/<owner>/<repo>/commit/<sha>`` URLs inside
+those blobs.
+
+Only full 40-hex SHAs are extracted. Short SHAs (7+) are ambiguous
+(config hashes, truncated ids, random hex) and are deliberately ignored —
+precision over recall, because these refs feed the knowledge graph.
+
+Everything is pure stdlib, read-only over the parsed rows — pass in
+``SessionsStore.tool_call_state(...)`` results.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+# 40-hex git SHA-1 (also matches SHA-256 object ids — same length, hex).
+_SHA_RE = re.compile(r"\b[0-9a-f]{40}\b")
+
+# well-known /commit/<sha> or /commits/<sha> URL fragments carry the same
+# 40-hex capture the plain regex already finds, but also name the repo.
+_COMMIT_URL_RE = re.compile(
+    r"https?://[^\s\"'<>)]+?/commits?/([0-9a-f]{40})\b"
+)
+
+
+@dataclass(frozen=True)
+class CommitRef:
+    """One commit reference found inside a tool-call payload."""
+
+    session_id: str
+    tool_call_id: str
+    field: str  # "call" | "update"
+    sha: str
+    repo_url: str | None = None  # e.g. "github.com/owner/repo" when a URL
+
+
+def _refs_in_text(
+    text: str | None, session_id: str, tool_call_id: str, field_name: str
+) -> list[CommitRef]:
+    if not text:
+        return []
+    refs: list[CommitRef] = []
+    # URLs first so the SHA can carry its repo context
+    url_shas: dict[str, str] = {}
+    for m in _COMMIT_URL_RE.finditer(text):
+        sha = m.group(1)
+        repo = m.group(0).split("/commit")[0].split("://", 1)[-1]
+        url_shas.setdefault(sha, repo)
+        refs.append(
+            CommitRef(session_id, tool_call_id, field_name, sha, repo)
+        )
+    for m in _SHA_RE.finditer(text):
+        sha = m.group(0)
+        if sha in url_shas:
+            continue  # already captured with repo context
+        refs.append(CommitRef(session_id, tool_call_id, field_name, sha))
+    return refs
+
+
+def commit_references(tool_calls) -> list[CommitRef]:
+    """All commit refs in a ``ToolCallState`` iterable.
+
+    Accepts anything with ``session_id``, ``tool_call_id``,
+    ``tool_call_json`` and ``tool_call_update_json`` attributes — typically
+    ``SessionsStore.tool_call_state()`` output. Results are deduplicated
+    on ``(sha, tool_call_id)`` keeping the richer (URL-carrying) record.
+    """
+    seen: dict[tuple[str, str], CommitRef] = {}
+    for tc in tool_calls:
+        for ref in (
+            _refs_in_text(
+                tc.tool_call_json, tc.session_id, tc.tool_call_id, "call"
+            )
+            + _refs_in_text(
+                tc.tool_call_update_json,
+                tc.session_id,
+                tc.tool_call_id,
+                "update",
+            )
+        ):
+            key = (ref.sha, ref.tool_call_id)
+            prev = seen.get(key)
+            if prev is None or (prev.repo_url is None and ref.repo_url):
+                seen[key] = ref
+    return sorted(seen.values(), key=lambda r: (r.session_id, r.sha))
+
+
+def commits_by_session(tool_calls) -> dict[str, set[str]]:
+    """Convenience rollup: ``session_id -> {sha, ...}``."""
+    out: dict[str, set[str]] = {}
+    for ref in commit_references(tool_calls):
+        out.setdefault(ref.session_id, set()).add(ref.sha)
+    return out

devin_internals/contract.py

@@ -0,0 +1,231 @@
+"""Unified drift contract (F4): one call, every known contract boundary.
+
+Checks, in one pass over a Devin data directory:
+
+- ``sessions.db`` schema version against the supported range
+- ``acp-messages/*.db`` meta ``schema_version`` (observed: 6) and the
+  declared ``info``/``truncated`` keys
+- usage-shape probe — what token/cost signals actually persist locally.
+  Verified on a real install (2026-10): ``tool_call_state`` carries **no**
+  cost/usage columns; ``message_nodes.metadata`` carries only
+  ``num_tokens_preceding`` (context-window tokens, cumulative); per-turn
+  cost exists **only** in the live ACP session meta
+  (``total_credit_cost``/``total_acu_cost``) and is never written to disk.
+- ``state.vscdb`` presence
+
+Every check returns ``ok``/``drift``/``unknown`` — a ``drift`` means the
+stored shape differs from what downstream tools assume and they should
+fail loudly rather than misread.
+"""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+from pathlib import Path
+from typing import Any
+
+from devin_internals.schema import (
+    SchemaError,
+    detect_schema_version,
+)
+
+# Observed on a real install (2026-10): 47 DBs at v6, 2 legacy DBs at v1.
+KNOWN_ACP_SCHEMA_VERSIONS = {1, 6}
+
+_EXPECTED_META_KEYS = {"info", "message_count", "schema_version", "truncated"}
+
+# Verified on a real v17 install: tool_call_state has no cost/usage keys and
+# message_nodes.metadata carries only these documented keys.
+_KNOWN_MN_METADATA_KEYS = {
+    "summarized_from",
+    "num_tokens_preceding",
+    "is_system_prefix",
+    "extensions",
+}
+_COST_HINT_KEYS = ("cost", "usage", "acu", "credit", "price", "billing")
+
+
+def _ro(path: Path) -> sqlite3.Connection:
+    return sqlite3.connect(f"file:{path.as_posix()}?mode=ro", uri=True)
+
+
+def _check_sessions_db(path: Path) -> dict[str, Any]:
+    if not path.is_file():
+        return {"status": "missing", "path": str(path)}
+    try:
+        info = detect_schema_version(path)
+    except SchemaError as exc:
+        return {"status": "drift", "path": str(path), "error": str(exc)}
+    return {
+        "status": "ok" if info["supported"] else "drift",
+        "path": str(path),
+        "schema_version": info["schema_version"],
+        "supported_range": [info["min_supported"], info["max_supported"]],
+    }
+
+
+def _check_acp_messages(dir_path: Path) -> dict[str, Any]:
+    if not dir_path.is_dir():
+        return {"status": "missing", "dir": str(dir_path)}
+    dbs = sorted(dir_path.glob("*.db"))
+    versions: dict[str, int] = {}
+    meta_keys: dict[str, int] = {}
+    for db in dbs:
+        try:
+            con = _ro(db)
+            for key, value in con.execute("SELECT key, value FROM meta"):
+                meta_keys[key] = meta_keys.get(key, 0) + 1
+                if key == "schema_version":
+                    try:
+                        v = int(value)
+                    except (TypeError, ValueError):
+                        v = value
+                    versions[v] = versions.get(v, 0) + 1
+            con.close()
+        except sqlite3.Error:
+            continue
+    unknown_versions = sorted(set(versions) - KNOWN_ACP_SCHEMA_VERSIONS,
+                              key=str)
+    # ``fixture.*`` keys are the declared self-identification marker of
+    # synthetic stores — expected, not drift.
+    unexpected_meta = sorted(
+        k for k in meta_keys
+        if k not in _EXPECTED_META_KEYS and not k.startswith("fixture.")
+    )
+    status = "ok"
+    if unknown_versions or unexpected_meta:
+        status = "drift"
+    if not dbs:
+        status = "missing"
+    return {
+        "status": status,
+        "dir": str(dir_path),
+        "db_count": len(dbs),
+        "schema_versions": {str(k): v for k, v in versions.items()},
+        "unknown_schema_versions": unknown_versions,
+        "unexpected_meta_keys": unexpected_meta,
+    }
+
+
+def _cost_keys_in(obj: Any, out: set[str]) -> None:
+    if isinstance(obj, dict):
+        for key, value in obj.items():
+            lowered = key.lower()
+            if any(h in lowered for h in _COST_HINT_KEYS):
+                out.add(key)
+            _cost_keys_in(value, out)
+    elif isinstance(obj, list):
+        for item in obj[:8]:
+            _cost_keys_in(item, out)
+
+
+def _check_usage_shape(sessions_db: Path) -> dict[str, Any]:
+    """What token/cost signals actually persist — verified 2026-10 on v17."""
+    if not sessions_db.is_file():
+        return {"status": "missing"}
+    con = _ro(sessions_db)
+    try:
+        tables = {
+            r[0]
+            for r in con.execute(
+                "SELECT name FROM sqlite_master WHERE type='table'"
+            )
+        }
+        cost_keys: set[str] = set()
+        if "tool_call_state" in tables:
+            for (tcc,) in con.execute(
+                "SELECT tool_call_update_json FROM tool_call_state "
+                "WHERE tool_call_update_json IS NOT NULL LIMIT 500"
+            ):
+                try:
+                    _cost_keys_in(json.loads(tcc), cost_keys)
+                except (TypeError, json.JSONDecodeError):
+                    continue
+        metadata_keys: set[str] = set()
+        num_tokens = 0
+        if "message_nodes" in tables:
+            for (md,) in con.execute(
+                "SELECT metadata FROM message_nodes "
+                "WHERE metadata IS NOT NULL LIMIT 1000"
+            ):
+                try:
+                    keys = set(json.loads(md))
+                except (TypeError, json.JSONDecodeError):
+                    continue
+                metadata_keys |= keys
+                if "num_tokens_preceding" in keys:
+                    num_tokens += 1
+        # "synthetic" is the declared marker written by make-fixture.
+        unexpected = sorted(
+            metadata_keys - _KNOWN_MN_METADATA_KEYS - {"synthetic"}
+        )
+        return {
+            "status": "drift" if cost_keys or unexpected else "ok",
+            "cost_keys_in_tool_calls": sorted(cost_keys),
+            "cost_persisted": bool(cost_keys),
+            "num_tokens_preceding_rows": num_tokens,
+            "unexpected_metadata_keys": unexpected,
+            "note": (
+                "per-turn cost lives only in the live ACP session meta "
+                "(total_credit_cost/total_acu_cost); local stores persist "
+                "num_tokens_preceding as the sole token signal"
+            ),
+        }
+    finally:
+        con.close()
+
+
+def _gui_root(data_root: Path) -> Path:
+    """Locate the ``User/`` tree.
+
+    Fixture-style layouts keep ``User/`` under the data root; real Linux
+    installs split stores across ``~/.local/share/devin/cli/`` (data) and
+    ``~/.config/Devin/User/`` (GUI). Windows/macOS keep them under
+    ``%APPDATA%``/``~/Library/Application Support``.
+    """
+    if (data_root / "User").is_dir():
+        return data_root
+    import os
+    import sys
+
+    if sys.platform.startswith("win"):
+        base = Path(os.environ.get("APPDATA", "")) / "Devin"
+    elif sys.platform == "darwin":
+        base = Path.home() / "Library" / "Application Support" / "Devin"
+    else:
+        base = Path(
+            os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")
+        ) / "Devin"
+    return base
+
+
+def check_contract(devin_data_dir: str | Path) -> dict[str, Any]:
+    """Run every contract check and return the unified drift report."""
+    root = Path(devin_data_dir).expanduser()
+    gui_root = _gui_root(root)
+    sessions_db = root / "cli" / "sessions.db"
+    checks = {
+        "sessions_db": _check_sessions_db(sessions_db),
+        "acp_messages": _check_acp_messages(gui_root / "User" / "acp-messages"),
+        "usage_shape": _check_usage_shape(sessions_db),
+        "state_vscdb": {
+            "status": (
+                "ok"
+                if (gui_root / "User" / "globalStorage" / "state.vscdb").is_file()
+                else "missing"
+            ),
+            "path": str(gui_root / "User" / "globalStorage" / "state.vscdb"),
+        },
+    }
+    worst = "ok"
+    if any(c["status"] == "drift" for c in checks.values()):
+        worst = "drift"
+    elif any(c["status"] == "missing" for c in checks.values()):
+        worst = "missing"
+    return {
+        "root": str(root),
+        "gui_root": str(gui_root),
+        "status": worst,
+        "checks": checks,
+    }