thinkstack-core 4.0.0__py3-none-any.whl

thinkstack_core/cloud/sync_conflicts.py

@@ -0,0 +1,183 @@
+"""
+thinkstack_core.cloud.sync_conflicts
+====================================
+Append-only, hash-chained conflict log for sync conflicts.
+
+Each conflict entry records what was found on both sides, what resolution
+was applied, and whether it has been manually reviewed.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+from collections.abc import Sequence
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger("thinkstack.cloud.sync_conflicts")
+
+LEARNING_CONFLICT_EVENT = "LEARNING_CONFLICT"
+_CONFLICTS_FILE = "sync_conflicts.jsonl"
+
+
+class ConflictLog:
+    """Append, list, and resolve sync conflicts."""
+
+    def __init__(self, gcc_dir: Path | str) -> None:
+        self._gcc_dir = Path(gcc_dir)
+        self._path = self._gcc_dir / _CONFLICTS_FILE
+
+    def append(self, conflict: dict) -> str:
+        """Append a conflict entry (hash-chained). Returns conflict_id.
+
+        Also emits a ``{LEARNING_CONFLICT_EVENT}`` event to ``.GCC/events.log.jsonl``
+        so the sprint-writer and dashboard can track learning sync conflicts.
+        """
+        entry = dict(conflict)
+        if "conflict_id" not in entry:
+            from uuid import uuid4
+            entry["conflict_id"] = f"conf_{uuid4().hex[:12]}"
+        entry["timestamp"] = entry.get("timestamp", _now_iso())
+
+        last_hash = self._last_hash()
+        prior = last_hash or "null"
+        entry["prior_hash"] = prior
+        entry["hash"] = _compute_hash(json.dumps(entry, separators=(",", ":")))
+
+        self._gcc_dir.mkdir(parents=True, exist_ok=True)
+        with open(str(self._path), "a", encoding="utf-8") as f:
+            f.write(json.dumps(entry, separators=(",", ":")) + "\n")
+
+        self._emit_conflict_event(entry)
+        return entry["conflict_id"]
+
+    def _emit_conflict_event(self, entry: dict) -> None:
+        """Write a learning conflict event to .GCC/events.log.jsonl."""
+        events_path = self._gcc_dir / "events.log.jsonl"
+        try:
+            event = {
+                "type": LEARNING_CONFLICT_EVENT,
+                "conflict_id": entry.get("conflict_id", ""),
+                "severity": entry.get("severity", "medium"),
+                "data_type": entry.get("data_type", "unknown"),
+                "item_id": entry.get("item_id", ""),
+                "resolution": entry.get("resolution", ""),
+                "timestamp": _now_iso(),
+            }
+            with open(str(events_path), "a", encoding="utf-8") as f:
+                f.write(json.dumps(event, separators=(",", ":")) + "\n")
+        except Exception as exc:
+            logger.warning("thinkstack: failed to emit conflict event — %s", exc)
+
+    def list_unresolved(self) -> list[dict]:
+        """Return all unresolved conflicts."""
+        return [c for c in self._read_all() if not c.get("resolved")]
+
+    def list_all(self) -> list[dict]:
+        """Return all conflicts (resolved + unresolved)."""
+        return self._read_all()
+
+    def resolve(self, conflict_id: str, use_remote: bool = False, dismiss: bool = False) -> dict | None:
+        """Mark a conflict as resolved. If *use_remote*, returns the remote_value for application.
+
+        Returns the conflict dict (with resolution fields) if found, or None if not found.
+        """
+        all_entries = self._read_all()
+        found = None
+        for entry in all_entries:
+            if entry.get("conflict_id") == conflict_id:
+                entry["resolved"] = True
+                entry["resolved_at"] = _now_iso()
+                if use_remote:
+                    entry["resolution"] = "used_remote"
+                elif dismiss:
+                    entry["resolution"] = "dismissed"
+                else:
+                    entry["resolution"] = entry.get("resolution", "kept_local")
+                found = entry
+                break
+
+        if found is None:
+            return None
+
+        self._rewrite_all(all_entries)
+        if use_remote:
+            return found
+        return found
+
+    def count_unresolved(self) -> int:
+        """Return count of unresolved conflicts."""
+        return len(self.list_unresolved())
+
+    def summary(self) -> str:
+        """Return a formatted summary for the ``thinkstack today`` dashboard."""
+        unresolved = self.list_unresolved()
+        if not unresolved:
+            return ""
+        high = sum(1 for c in unresolved if c.get("severity") == "high")
+        medium = sum(1 for c in unresolved if c.get("severity") == "medium")
+        parts = [f"  \u26a0 {len(unresolved)} unresolved conflict(s)"]
+        for c in unresolved[:5]:
+            parts.append(f"    [{c.get('severity','?')}] {c.get('type','?')} — {c.get('item_id','?')}")
+        if len(unresolved) > 5:
+            parts.append(f"    ... and {len(unresolved) - 5} more")
+        parts.append("  Run 'thinkstack sync conflicts' for details.")
+        return "\n".join(["─── Sync conflicts ───"] + parts)
+
+    def _read_all(self) -> list[dict]:
+        if not self._path.exists():
+            return []
+        entries: list[dict] = []
+        try:
+            for line in self._path.read_text(encoding="utf-8").splitlines():
+                if not line.strip():
+                    continue
+                try:
+                    entries.append(json.loads(line))
+                except json.JSONDecodeError:
+                    continue
+        except OSError:
+            pass
+        return entries
+
+    def _rewrite_all(self, entries: Sequence[dict]) -> None:
+        content = "\n".join(json.dumps(e, separators=(",", ":")) for e in entries) + "\n"
+        _atomic_write(self._path, content)
+
+    def _last_hash(self) -> str | None:
+        if not self._path.exists():
+            return None
+        try:
+            last_line = ""
+            with open(str(self._path), "r", encoding="utf-8") as f:
+                for line in f:
+                    if line.strip():
+                        last_line = line.strip()
+            if last_line:
+                return json.loads(last_line).get("hash")
+        except (OSError, json.JSONDecodeError):
+            pass
+        return None
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _compute_hash(data: str) -> str:
+    return hashlib.sha256(data.encode("utf-8")).hexdigest()[:16]
+
+
+def _atomic_write(path: Path, content: str) -> None:
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    try:
+        tmp.write_text(content, encoding="utf-8")
+        tmp.replace(path)
+    finally:
+        if tmp.exists():
+            try:
+                tmp.unlink()
+            except Exception:
+                pass

thinkstack_core/cloud/sync_state.py

@@ -0,0 +1,159 @@
+"""
+thinkstack_core.cloud.sync_state
+===============================
+Read, update, and persist sync state at .GCC/sync_state.json.
+
+Tracks what has been synced between local .GCC/ and the MCP server for
+each data type (commits, theta, learnings, sensitivities, topics).
+"""
+from __future__ import annotations
+
+import json
+import logging
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger("thinkstack.cloud.sync_state")
+
+
+class SyncState:
+    """Read, update, and persist sync state at .GCC/sync_state.json."""
+
+    def __init__(self, gcc_dir: Path | str) -> None:
+        self._gcc_dir = Path(gcc_dir)
+        self._path = self._gcc_dir / "sync_state.json"
+
+    def load(self) -> dict:
+        """Load sync state, returning empty state if file doesn't exist."""
+        if not self._path.exists():
+            return self._empty_state()
+        try:
+            data = json.loads(self._path.read_text(encoding="utf-8"))
+            if not isinstance(data, dict):
+                return self._empty_state()
+            return data
+        except (json.JSONDecodeError, OSError):
+            return self._empty_state()
+
+    def save(self, state: dict) -> None:
+        """Persist sync state atomically."""
+        self._gcc_dir.mkdir(parents=True, exist_ok=True)
+        state["last_sync_at"] = _now_iso()
+        _atomic_write(self._path, json.dumps(state, indent=2) + "\n")
+
+    def update_after_pull(self, state: dict, pull_result: dict) -> dict:
+        """Update cursors after a successful pull."""
+        server_state = pull_result.get("server_state", {})
+
+        commits_state = state.setdefault("commits", {})
+        server_commits = server_state.get("commits", {})
+        commits_state["remote_head"] = server_commits.get("head", "0")
+        synced_ids = set(commits_state.get("synced_ids", []))
+        for c in pull_result.get("delta", {}).get("commits", []):
+            cid = c.get("id")
+            if cid:
+                synced_ids.add(cid)
+        commits_state["synced_ids"] = sorted(synced_ids)
+
+        state["theta"] = server_state.get("theta", {})
+
+        learnings_state = state.setdefault("learnings", {})
+        server_learnings = server_state.get("learnings", {})
+        synced_lids = set(learnings_state.get("synced_ids", []))
+        for l in pull_result.get("delta", {}).get("learnings", []):
+            lid = l.get("id")
+            if lid:
+                synced_lids.add(lid)
+        learnings_state["synced_ids"] = sorted(synced_lids)
+        learnings_state["synced_count"] = len(synced_lids)
+
+        sensitivities_state = state.setdefault("sensitivities", {})
+        sensitivities_state["last_synced_ts"] = server_state.get("sensitivities", {}).get("last_synced_ts", "")
+
+        topics_state = state.setdefault("topics", {})
+        synced_topics = set(topics_state.get("synced_custom_names", []))
+        for name in server_state.get("topics", {}).get("synced_custom_names", []):
+            synced_topics.add(name)
+        topics_state["synced_custom_names"] = sorted(synced_topics)
+
+        return state
+
+    def update_after_push(self, state: dict, push_result: dict, server_state: dict) -> dict:
+        """Update cursors after a successful push."""
+        commits_state = state.setdefault("commits", {})
+        synced_ids = set(commits_state.get("synced_ids", []))
+        for c in push_result.get("delta", {}).get("commits", []):
+            cid = c.get("id")
+            if cid:
+                synced_ids.add(cid)
+        commits_state["synced_ids"] = sorted(synced_ids)
+        commits_state["remote_head"] = server_state.get("commits", {}).get("head", "0")
+
+        learnings_state = state.setdefault("learnings", {})
+        synced_lids = set(learnings_state.get("synced_ids", []))
+        for l in push_result.get("delta", {}).get("learnings", []):
+            lid = l.get("id")
+            if lid:
+                synced_lids.add(lid)
+        learnings_state["synced_ids"] = sorted(synced_lids)
+        learnings_state["synced_count"] = len(synced_lids)
+
+        state["theta"] = server_state.get("theta", state.get("theta", {}))
+
+        sensitivities_state = state.setdefault("sensitivities", {})
+        sensitivities_state["last_synced_ts"] = server_state.get("sensitivities", {}).get("last_synced_ts", "")
+
+        topics_state = state.setdefault("topics", {})
+        synced_topics = set(topics_state.get("synced_custom_names", []))
+        for name in server_state.get("topics", {}).get("synced_custom_names", []):
+            synced_topics.add(name)
+        topics_state["synced_custom_names"] = sorted(synced_topics)
+
+        return state
+
+    def get_remote_state_view(self, state: dict) -> dict:
+        """Return the subset of state representing what the remote has."""
+        commits_state = state.get("commits", {})
+        return {
+            "commits": {
+                "synced_ids": commits_state.get("synced_ids", []),
+                "remote_head": commits_state.get("remote_head", "0"),
+            },
+            "theta": state.get("theta", {}),
+            "learnings": {"synced_ids": state.get("learnings", {}).get("synced_ids", [])},
+            "sensitivities": {"last_synced_ts": state.get("sensitivities", {}).get("last_synced_ts", "")},
+            "topics": {"synced_custom_names": state.get("topics", {}).get("synced_custom_names", [])},
+        }
+
+    def reset(self, state: dict) -> dict:
+        """Reset sync state to empty (triggers full re-sync on next sync)."""
+        return self._empty_state()
+
+    def _empty_state(self) -> dict:
+        return {
+            "version": "1",
+            "last_sync_at": "",
+            "commits": {"synced_ids": [], "remote_head": "0"},
+            "theta": {},
+            "learnings": {"synced_ids": [], "synced_count": 0},
+            "sensitivities": {"last_synced_ts": ""},
+            "topics": {"synced_custom_names": []},
+        }
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _atomic_write(path: Path, content: str) -> None:
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    try:
+        tmp.write_text(content, encoding="utf-8")
+        tmp.replace(path)
+    finally:
+        if tmp.exists():
+            try:
+                tmp.unlink()
+            except Exception:
+                pass

thinkstack_core/cloud/team_sync.py

@@ -0,0 +1,337 @@
+"""Team-level Θ (coordination vector) synchronization.
+
+Provides ``push_theta`` and ``pull_theta`` primitives that store the org-level
+Θ in the same cloud storage backend used by the ThinkStack MCP server. Each repo
+pushes its local ``.GCC/theta.json`` to ``team_theta/<org_id>.json`` and pulls
+the remote org Θ back, merging it with the local copy using the same
+``merge_theta`` logic used by the REP network.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from thinkstack_core.rep_network.merge import merge_theta
+from thinkstack_core.storage import create_backend_from_env
+from thinkstack_core.theta import THETA_FILE
+
+if TYPE_CHECKING:
+    from thinkstack_core.storage import StorageBackend
+
+TEAM_THETA_PREFIX = "team_theta"
+
+
+def _theta_remote_key(org_id: str) -> str:
+    return f"{TEAM_THETA_PREFIX}/{org_id}.json"
+
+
+def _load_local_theta(gcc_dir: Path) -> dict:
+    path = gcc_dir / THETA_FILE
+    if not path.exists():
+        return {"version": 1, "updated_at": None, "coordination_vector": {}}
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return {"version": 1, "updated_at": None, "coordination_vector": {}}
+
+
+def _save_local_theta(gcc_dir: Path, theta: dict) -> None:
+    path = gcc_dir / THETA_FILE
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(theta, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+
+
+def _get_backend(org_id: str) -> "StorageBackend":
+    return create_backend_from_env(prefix=org_id)
+
+
+def push_theta(org_id: str, gcc_dir: str | Path) -> dict:
+    """Push the local ``.GCC/theta.json`` to the org's team Θ store.
+
+    Uses read-merge-write to avoid destructive overwrite of concurrent pushes.
+    Local theta is merged into the remote store using the same ``merge_theta``
+    logic used by ``pull_theta``, so concurrent pushes from different repos
+    do not lose data.
+
+    Args:
+        org_id: ThinkStack org ID.
+        gcc_dir: Path to the local ``.GCC/`` directory.
+
+    Returns:
+        A status dict with the number of concepts pushed.
+    """
+    backend = _get_backend(org_id)
+    local_path = Path(gcc_dir)
+    local_theta = _load_local_theta(local_path)
+    remote_key = _theta_remote_key(org_id)
+
+    try:
+        remote_bytes = backend.read_bytes(remote_key)
+        remote_theta = json.loads(remote_bytes.decode("utf-8"))
+    except (FileNotFoundError, json.JSONDecodeError, OSError):
+        remote_theta = {"version": 1, "updated_at": None, "coordination_vector": {}}
+
+    merged = merge_theta(local_theta, remote_theta)
+    backend.write_bytes(
+        remote_key,
+        json.dumps(merged, indent=2, sort_keys=True).encode("utf-8"),
+    )
+    concepts = len(local_theta.get("coordination_vector", {}))
+    return {
+        "org_id": org_id,
+        "remote_key": remote_key,
+        "concepts_pushed": concepts,
+    }
+
+
+def pull_theta(org_id: str, gcc_dir: str | Path) -> dict:
+    """Pull the org's team Θ and merge it into the local ``.GCC/theta.json``.
+
+    Args:
+        org_id: ThinkStack org ID.
+        gcc_dir: Path to the local ``.GCC/`` directory.
+
+    Returns:
+        A status dict with the number of concepts before and after the merge.
+    """
+    backend = _get_backend(org_id)
+    local_path = Path(gcc_dir)
+    local_theta = _load_local_theta(local_path)
+    remote_key = _theta_remote_key(org_id)
+
+    try:
+        remote_bytes = backend.read_bytes(remote_key)
+    except FileNotFoundError:
+        remote_theta = {"version": 1, "updated_at": None, "coordination_vector": {}}
+    else:
+        remote_theta = json.loads(remote_bytes.decode("utf-8"))
+
+    before = len(local_theta.get("coordination_vector", {}))
+    merged = merge_theta(local_theta, remote_theta)
+    _save_local_theta(local_path, merged)
+    after = len(merged.get("coordination_vector", {}))
+    return {
+        "org_id": org_id,
+        "remote_key": remote_key,
+        "concepts_before": before,
+        "concepts_after": after,
+        "concepts_added": after - before,
+    }
+
+
+# ------------------------------------------------------------------
+# Cross-project learning sync
+# ------------------------------------------------------------------
+
+TEAM_LEARNINGS_PREFIX = "team_learnings"
+
+
+def _learnings_remote_key(org_id: str) -> str:
+    return f"{TEAM_LEARNINGS_PREFIX}/{org_id}.json"
+
+
+def _load_local_learnings(gcc_dir: Path) -> list[dict]:
+    """Load and serialize all learnings from a local .GCC/ into dicts."""
+    from thinkstack_core.reasoning_plus.learning.store import LearningStore
+    store = LearningStore(gcc_dir)
+    return [l.to_dict() for l in store.list()]
+
+
+def _save_remote_learnings(
+    backend: "StorageBackend",
+    remote_key: str,
+    learnings: list[dict],
+) -> None:
+    """Atomically write learnings to the remote key.
+
+    Each learning dict carries a ``_source_gcc_dir`` field to track origin.
+    """
+    data = {
+        "version": "1",
+        "updated_at": _now_iso(),
+        "learnings": learnings,
+    }
+    backend.write_bytes(
+        remote_key,
+        json.dumps(data, indent=2).encode("utf-8"),
+    )
+
+
+def _load_remote_learnings(
+    backend: "StorageBackend",
+    remote_key: str,
+) -> list[dict]:
+    """Load learnings from the remote key, returning a list of dicts."""
+    try:
+        raw_bytes = backend.read_bytes(remote_key)
+    except FileNotFoundError:
+        return []
+    try:
+        data = json.loads(raw_bytes.decode("utf-8"))
+        return data.get("learnings", [])
+    except (json.JSONDecodeError, OSError, KeyError):
+        return []
+
+
+def _merge_learnings(
+    local: list[dict],
+    remote: list[dict],
+) -> list[dict]:
+    """Merge remote learnings into local, keyed by learning ID.
+
+    Remote learnings with IDs not present locally are added.
+    Remote learnings with IDs already present are skipped (local wins).
+    """
+    local_ids = {l.get("id") for l in local if l.get("id")}
+    merged = list(local)
+    for rl in remote:
+        rid = rl.get("id")
+        if rid and rid not in local_ids:
+            merged.append(rl)
+            local_ids.add(rid)
+    return merged
+
+
+def _emit_sync_new_data_event(local_path: Path, local_learnings: list[dict]) -> None:
+    """Emit a SYNC_NEW_DATA event to .GCC/events.log.jsonl for cross-agent notification."""
+    events_path = local_path / "events.log.jsonl"
+    try:
+        event = {
+            "type": "SYNC_NEW_DATA",
+            "learnings_pushed": len(local_learnings),
+            "agent_id": local_path.name,
+            "timestamp": _now_iso(),
+        }
+        with open(str(events_path), "a", encoding="utf-8") as f:
+            f.write(json.dumps(event, separators=(",", ":")) + "\n")
+    except Exception as exc:
+        logger.warning("thinkstack: failed to emit sync event — %s", exc)
+
+
+def push_learnings(
+    org_id: str,
+    gcc_dir: str | Path,
+    *,
+    skip_private: bool = True,
+    skip_branch: bool = True,
+) -> dict:
+    """Push local learnings to the org's team learning store.
+
+    Args:
+        org_id: ThinkStack org ID.
+        gcc_dir: Path to the local .GCC/ directory.
+        skip_private: Exclude PRIVATE-disclosure learnings from push.
+        skip_branch: Exclude branch-scoped learnings from push.
+
+    Returns:
+        A status dict with the number of learnings pushed.
+    """
+    from thinkstack_core.reasoning_plus.learning.models import Learning
+
+    backend = _get_backend(org_id)
+    local_path = Path(gcc_dir)
+    local_learnings_raw = _load_local_learnings(local_path)
+
+    local_learnings: list[dict] = []
+    for l in local_learnings_raw:
+        if skip_private and l.get("sensitivity") == "PRIVATE":
+            continue
+        scope = l.get("scope", "project")
+        if skip_branch and scope == "branch":
+            continue
+        l["_source_gcc_dir"] = str(local_path)
+        l.setdefault("scope", "project")
+        l.setdefault("sensitivity", "PUBLIC")
+        local_learnings.append(l)
+
+    remote_learnings = _load_remote_learnings(backend, _learnings_remote_key(org_id))
+    merged = _merge_learnings(remote_learnings, local_learnings)
+    _save_remote_learnings(backend, _learnings_remote_key(org_id), merged)
+
+    _emit_sync_new_data_event(local_path, local_learnings)
+
+    return {
+        "org_id": org_id,
+        "remote_key": _learnings_remote_key(org_id),
+        "learnings_pushed": len(local_learnings),
+        "learnings_total_remote": len(merged),
+        "learnings_skipped": len(local_learnings_raw) - len(local_learnings),
+    }
+
+
+def pull_learnings(
+    org_id: str,
+    gcc_dir: str | Path,
+    *,
+    min_confidence: float = 0.3,
+    allowed_scope: str | None = None,
+) -> dict:
+    """Pull team learnings from the org store and add new ones to the local store.
+
+    Remote learnings that do not exist locally (by ID) are saved.
+    Remote learnings with IDs already present are skipped (local wins).
+
+    Args:
+        org_id: ThinkStack org ID.
+        gcc_dir: Path to the local .GCC/ directory.
+        min_confidence: Minimum confidence threshold for incoming learnings.
+        allowed_scope: Only accept learnings with this scope (e.g. "org").
+
+    Returns:
+        A status dict with the number of learnings added locally.
+    """
+    from thinkstack_core.reasoning_plus.learning.models import Learning
+    from thinkstack_core.reasoning_plus.learning.store import LearningStore
+
+    backend = _get_backend(org_id)
+    local_path = Path(gcc_dir)
+    store = LearningStore(local_path)
+    local_learnings = store.list()
+    local_ids = {l.id for l in local_learnings}
+
+    remote_learnings = _load_remote_learnings(backend, _learnings_remote_key(org_id))
+    added = 0
+    for rl in remote_learnings:
+        rid = rl.get("id")
+        if rid and rid not in local_ids:
+            if min_confidence > 0 and rl.get("confidence", 1.0) < min_confidence:
+                continue
+            if allowed_scope and rl.get("scope") != allowed_scope:
+                continue
+            try:
+                learning = Learning.from_dict(rl)
+                store.save(learning)
+                local_ids.add(rid)
+                added += 1
+            except Exception as exc:
+                logger.warning("thinkstack: failed to save remote learning %s — %s", rid, exc)
+
+    return {
+        "org_id": org_id,
+        "remote_key": _learnings_remote_key(org_id),
+        "learnings_added": added,
+        "learnings_total_local": len(local_learnings) + added,
+        "learnings_skipped_confidence": sum(
+            1 for rl in remote_learnings
+            if rl.get("id") and rl.get("id") not in local_ids and rl.get("confidence", 1.0) < min_confidence
+        ),
+    }
+
+
+def _now_iso() -> str:
+    from datetime import datetime, timezone
+    return datetime.now(timezone.utc).isoformat()
+
+
+def setup_team_sync_env(org_id: str, backend: "StorageBackend" | None = None) -> None:
+    """Ensure the process environment points at the cloud backend for this org.
+
+    This is mainly a convenience for CLI tests; the backend factory is normally
+    driven by ``THINKSTACK_STORAGE`` and friends.
+    """
+    os.environ.setdefault("THINKSTACK_ORG_ID", org_id)
+    if backend is None:
+        os.environ.setdefault("THINKSTACK_STORAGE", "r2")