gator-command 1.2.2__tar.gz → 1.4.0__tar.gz

{gator_command-1.2.2/src/gator_command.egg-info → gator_command-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gator-command
-Version: 1.2.2
+Version: 1.4.0
 Summary: Git-native governance for AI-assisted engineering
 Author-email: Cumberland Laboratories <support@cumberlandlaboratories.com>
 License: MIT

{gator_command-1.2.2 → gator_command-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gator-command"
-version = "1.2.2"
+version = "1.4.0"
 description = "Git-native governance for AI-assisted engineering"
 readme = "PYPI_README.md"
 license = {text = "MIT"}

{gator_command-1.2.2 → gator_command-1.4.0}/src/gator_command/cli.py

@@ -75,6 +75,7 @@ COMMANDS = {
     "audit":      ("gator-audit.py",         "Run governance audit"),
     "drift":      ("gator-drift.py",         "Check fleet for governance drift"),
     "fleet":      ("gator-fleet-report.py",  "Fleet status report"),
+    "session-blocks": ("gator-session-block.py", "Generate session-block companions"),
 }
 
 
@@ -121,13 +122,13 @@ def main():
     _run_script(scripts_dir, script_name, remaining)
 
 
-def _get_version():
-    """Get version from the package's single-source version resolver."""
-    try:
-        from gator_command import __version__
-        return __version__
-    except ImportError:
-        return "unknown"
+def _get_version():
+    """Get version from the package's single-source version resolver."""
+    try:
+        from gator_command import __version__
+        return __version__
+    except ImportError:
+        return "unknown"
 
 
 if __name__ == "__main__":

{gator_command-1.2.2 → gator_command-1.4.0}/src/gator_command/scripts/gator-deploy.py

@@ -158,8 +158,12 @@ ROOT_GITIGNORE = (
     "# Session snippets — contain machine-id, not for public repos\n"
     ".gator/session-snippets/\n"
     "\n"
+    "# Session blocks — local-only transcript evidence\n"
+    ".gator/session-blocks/\n"
+    "\n"
     "# Machine-local state (not portable)\n"
     ".gator/product-source.json\n"
+    ".gator/active-vendor-session.json\n"
 )
 
 

{gator_command-1.2.2 → gator_command-1.4.0}/src/gator_command/scripts/gator-session-aggregator.py

@@ -8,7 +8,7 @@ entry point. Dashboard and CLI scripts import this.
 
 @reads: .gator/session-snippets/*.json (per repo)
 @reads: ~/.gator/dashboard-repos.json (fleet queries)
-@writes: ~/.gator/sessions/<path-hash>/<session_id>.json (cached summaries)
+@writes: ~/.gator/sessions/<path-hash>/<esk-hash>.json (cached summaries)
 @writes: ~/.gator/sessions/<path-hash>/_repo.json (repo metadata)
 """
 
@@ -33,6 +33,28 @@ SIGNIFICANCE_ORDER = {"routine": 0, "minor": 1, "high": 2}
 SKIP_CHANGE_TYPES_FOR_GOAL = {"release", "merge", "cleanup"}
 
 
+# ---------------------------------------------------------------------------
+# Session Identity
+# ---------------------------------------------------------------------------
+
+def effective_session_key(snippet):
+    """Return the canonical grouping key for a snippet.
+
+    Uses vendor session identity when available, falls back to legacy
+    Gator session_id. The returned string is used for aggregation grouping,
+    cache filenames, and fingerprint lookups.
+
+    Returns:
+        "group:<repo>:<session_group_key>" when session_group_key is truthy
+        "legacy:<repo>:<session_id>" otherwise
+    """
+    repo = snippet.get("repo", "")
+    sgk = snippet.get("session_group_key")
+    if sgk:
+        return f"group:{repo}:{sgk}"
+    return f"legacy:{repo}:{snippet.get('session_id', '')}"
+
+
 # ---------------------------------------------------------------------------
 # 1a. Snippet Reader
 # ---------------------------------------------------------------------------
@@ -75,7 +97,11 @@ def read_snippets(repo_path):
 # ---------------------------------------------------------------------------
 
 def aggregate_sessions(snippets, repo_path):
-    """Group snippets by (repo, session_id) and aggregate into summaries.
+    """Group snippets by effective_session_key() and aggregate into summaries.
+
+    Uses vendor session_group_key when present, falls back to legacy
+    Gator session_id. Snippets with different effective keys are never
+    merged, even if timestamps or transcript IDs look similar.
 
     Args:
         snippets: list of parsed snippet dicts (the "data" from SnippetRecords)
@@ -83,10 +109,10 @@ def aggregate_sessions(snippets, repo_path):
 
     Returns list of summary dicts matching gator-session-summary-v1 schema.
     """
-    # Group by (repo, session_id)
+    # Group by effective_session_key
     groups = {}
     for s in snippets:
-        key = (s.get("repo", ""), s.get("session_id", ""))
+        key = effective_session_key(s)
         if key not in groups:
             groups[key] = []
         groups[key].append(s)
@@ -94,7 +120,7 @@ def aggregate_sessions(snippets, repo_path):
     repo_key = session_cache_key(repo_path)
     summaries = []
 
-    for (repo, session_id), group in groups.items():
+    for esk, group in groups.items():
         # Sort within group
         group.sort(key=lambda s: (
             s.get("started_at", ""),
@@ -110,6 +136,7 @@ def aggregate_sessions(snippets, repo_path):
         all_intents = []
         all_notes = []
         all_change_types = set()
+        all_models = set()
         max_sig = "routine"
         architect = ""
         transcript_session_id = None
@@ -150,6 +177,11 @@ def aggregate_sessions(snippets, repo_path):
             if ct:
                 all_change_types.add(ct)
 
+            # Models — distinct
+            model = s.get("model_inferred", "")
+            if model:
+                all_models.add(model)
+
             # Max significance
             sig = s.get("significance", "routine")
             if SIGNIFICANCE_ORDER.get(sig, 0) > SIGNIFICANCE_ORDER.get(max_sig, 0):
@@ -165,14 +197,24 @@ def aggregate_sessions(snippets, repo_path):
             if not transcript_ref:
                 transcript_ref = s.get("transcript_ref")
 
+        # session_group_key: first non-null from the group (all should agree)
+        session_group_key = None
+        for s in group:
+            sgk = s.get("session_group_key")
+            if sgk:
+                session_group_key = sgk
+                break
+
         summary = {
             "schema": "gator-session-summary-v1",
-            "session_id": session_id,
-            "repo": repo,
+            "session_id": first.get("session_id", ""),
+            "session_group_key": session_group_key,
+            "repo": first.get("repo", ""),
             "repo_key": repo_key,
             "branch": first.get("branch", ""),
             "vendor": first.get("vendor_inferred", ""),
             "model": first.get("model_inferred", ""),
+            "models": sorted(all_models),
             "agent": first.get("agent", ""),
             "architect": architect,
             "started_at": min(s.get("started_at", "") for s in group),
@@ -273,21 +315,32 @@ def write_repo_metadata(cache_path, repo_name, repo_path):
     _atomic_write(meta_path, json.dumps(meta, indent=2) + "\n")
 
 
-def _summary_cache_filename(repo, session_id):
-    """Build a cache filename from the (repo, session_id) compound key.
+def _esk_from_summary(summary):
+    """Reconstruct the effective session key from a summary dict.
+
+    Mirrors effective_session_key() but reads from summary fields
+    instead of snippet fields.
+    """
+    repo = summary.get("repo", "")
+    sgk = summary.get("session_group_key")
+    if sgk:
+        return f"group:{repo}:{sgk}"
+    return f"legacy:{repo}:{summary.get('session_id', '')}"
+
+
+def _summary_cache_filename(esk):
+    """Build a cache filename from the effective session key.
 
-    Uses a short hash prefix of the repo name to avoid filename collisions
-    when two repos share a session_id in the same cache directory.
+    Hashes the full effective_session_key string to produce a stable,
+    filesystem-safe filename. The key already encodes repo + identity.
     """
-    if repo:
-        repo_prefix = hashlib.sha256(repo.encode()).hexdigest()[:6]
-        return f"{repo_prefix}-{session_id}.json"
-    return f"{session_id}.json"
+    h = hashlib.sha256(esk.encode()).hexdigest()[:16]
+    return f"{h}.json"
 
 
-def read_cached_summary(cache_path, repo, session_id):
+def read_cached_summary(cache_path, esk):
     """Read a cached session summary, or return None."""
-    summary_path = cache_path / _summary_cache_filename(repo, session_id)
+    summary_path = cache_path / _summary_cache_filename(esk)
     if not summary_path.exists():
         return None
     try:
@@ -296,10 +349,10 @@ def read_cached_summary(cache_path, repo, session_id):
         return None
 
 
-def write_cached_summary(cache_path, summary):
+def write_cached_summary(cache_path, summary, esk):
     """Write a session summary to cache."""
     cache_path.mkdir(parents=True, exist_ok=True)
-    filename = _summary_cache_filename(summary.get("repo", ""), summary["session_id"])
+    filename = _summary_cache_filename(esk)
     summary_path = cache_path / filename
     _atomic_write(summary_path, json.dumps(summary, indent=2) + "\n")
 
@@ -349,10 +402,10 @@ def get_session_summaries(repo_path, force_refresh=False):
     snippets_data = [r["data"] for r in records]
     sessions = aggregate_sessions(snippets_data, repo_path)
 
-    # Build a lookup: (repo, session_id) -> list of records (for fingerprinting)
+    # Build a lookup: effective_session_key -> list of records (for fingerprinting)
     session_records = {}
     for r in records:
-        key = (r["data"].get("repo", ""), r["data"].get("session_id", ""))
+        key = effective_session_key(r["data"])
         if key not in session_records:
             session_records[key] = []
         session_records[key].append(r)
@@ -362,13 +415,13 @@ def get_session_summaries(repo_path, force_refresh=False):
     wrote_any = False
 
     for summary in sessions:
-        repo = summary["repo"]
-        sid = summary["session_id"]
-        recs = session_records.get((repo, sid), [])
+        # Reconstruct the effective key from the summary's first snippet identity
+        esk = _esk_from_summary(summary)
+        recs = session_records.get(esk, [])
         fp = snippet_fingerprint(recs)
 
         if not force_refresh:
-            cached = read_cached_summary(cpath, repo, sid)
+            cached = read_cached_summary(cpath, esk)
             if cached and is_fresh(cached, fp):
                 results.append(cached)
                 continue
@@ -376,7 +429,7 @@ def get_session_summaries(repo_path, force_refresh=False):
         # Generate and cache
         summary["generated_at"] = datetime.now(timezone.utc).isoformat()
         summary["snippet_fingerprint"] = fp
-        write_cached_summary(cpath, summary)
+        write_cached_summary(cpath, summary, esk)
         results.append(summary)
         wrote_any = True