How to share agentic coding artifacts with your teammates

---
name: team-sync
description: Synchronizes local Antigravity conversation history, transcripts, and artifacts (including a light summary) to the project repository for team sharing.
---

# Team-Sync Custom Skill

Use this skill to archive and upload your conversation's transcripts, artifacts, and a "light" human-readable summary into the Git repository, allowing other team members to quickly catch up on your agent steps, decisions, and outcomes.

## When to Use
* Call this skill when a coding task, implementation plan, or refactoring conversation has finished successfully.
* Run it before opening a Pull Request so that reviewers can inspect the execution logs and the conversation summary.

## Instructions for the Agent
1. **Generate the Light Transcript (`summary.md`):**
   Create a file named `summary.md` in your local brain directory. The summary must follow this structure:

   ```markdown
   # Conversation Summary: [Objective/Topic]
   * **Date:** [Current Date]
   * **Conversation ID:** [ANTIGRAVITY_CONVERSATION_ID]

   ## TL;DR
   [A 1-2 sentence high-level summary of what was accomplished]

   ## Key Decisions & Rationale
   * **Decision:** [e.g., Using Python's shutil instead of bash commands]
     * **Why:** [e.g., Cross-platform safety and better permission handling]

   ## Most Interesting Event / "Aha" Moment
   [Capture any major back-and-forth conversation, user course corrections, pivot points, or model/user "aha" moments that defined the flow of this conversation.]

   ## Scope of Changes
   * **Files Modified/Created:** [List of files]
   * **Verification:** [How the changes were validated, command outputs, etc.]

   ## Learnings & Gotchas for the Team
   * [Any lessons learned about the API, codebase, or environment that others should know]
   ```

2. **Verify Environment:**
   Ensure `ANTIGRAVITY_CONVERSATION_ID` is set in the environment.

3. **Execute Sync Script:**
   Run the sync helper script:
   ```bash
   python3 .agents/skills/team-sync/scripts/sync.py
   ```
   *Note: Because `sync.py` automatically copies all `.md` files, your newly created `summary.md` will be synced to the workspace repository automatically.*

4. **Report Status:**
   Confirm to the user that the summary and files have been successfully synced.

#!/usr/bin/env python3
import os
import sys
import shutil
import subprocess
from pathlib import Path

def get_project_root() -> Path:
    # Find project root by looking for .agents or .git starting from CWD
    current = Path.cwd().resolve()
    for parent in [current] + list(current.parents):
        if (parent / ".agents").is_dir() or (parent / ".git").is_dir():
            return parent
    return current

def find_most_recent_conversation(brain_root: Path) -> str:
    """Finds the most recently modified conversation subdirectory in the brain cache."""
    if not brain_root.is_dir():
        return None
    
    subdirs = []
    for p in brain_root.iterdir():
        # Conversation directories are 36-char UUIDs (plus optional custom name directories)
        if p.is_dir() and p.name != "scratch":
            try:
                mtime = p.stat().st_mtime
                subdirs.append((mtime, p.name))
            except OSError:
                continue
                
    if not subdirs:
        return None
    
    # Sort by modification time, newest first
    subdirs.sort(key=lambda x: x[0], reverse=True)
    return subdirs[0][1]

def check_git_installed() -> bool:
    """Checks if git command-line tool is installed and available in PATH."""
    return shutil.which("git") is not None

def main():
    print("=== Antigravity Team Sync ===")
    
    home_dir = Path.home()
    brain_root = home_dir / ".gemini" / "antigravity" / "brain"
    
    # 1. Retrieve conversation ID from environment or fallback
    conv_id = os.environ.get("ANTIGRAVITY_CONVERSATION_ID")
    if not conv_id:
        print("Notice: ANTIGRAVITY_CONVERSATION_ID env variable is not set.", file=sys.stderr)
        print("Attempting to auto-detect the most recent local conversation...", file=sys.stderr)
        conv_id = find_most_recent_conversation(brain_root)
        
        if not conv_id:
            print("ERROR: Could not locate any local conversation histories.", file=sys.stderr)
            sys.exit(1)
        print(f"Auto-detected conversation: {conv_id}")
    else:
        print(f"Active Conversation ID: {conv_id}")
    
    # 2. Define source paths
    source_brain_dir = brain_root / conv_id
    if not source_brain_dir.is_dir():
        print(f"ERROR: Local conversation directory not found at: {source_brain_dir}", file=sys.stderr)
        sys.exit(1)
        
    # 3. Define target paths
    proj_root = get_project_root()
    target_history_dir = proj_root / ".antigravity" / "history" / conv_id
    
    print(f"Source Directory: {source_brain_dir}")
    print(f"Target Directory: {target_history_dir}")
    
    # Create target directory
    try:
        target_history_dir.mkdir(parents=True, exist_ok=True)
    except PermissionError:
        print(f"ERROR: Permission denied. Cannot write to target directory: {target_history_dir}", file=sys.stderr)
        sys.exit(1)
    except Exception as e:
        print(f"ERROR: Failed to create target directory: {e}", file=sys.stderr)
        sys.exit(1)
    
    # 4. Copy Artifacts (markdown files and media in the main directory)
    copied_count = 0
    for file_path in source_brain_dir.iterdir():
        if file_path.is_file() and file_path.suffix in [".md", ".png", ".jpg", ".jpeg", ".gif", ".mp4", ".mov"]:
            try:
                shutil.copy2(file_path, target_history_dir / file_path.name)
                print(f"-> Copied file: {file_path.name}")
                copied_count += 1
            except PermissionError:
                print(f"Warning: Permission denied copying file {file_path.name}")
            except Exception as e:
                print(f"Warning: Failed to copy {file_path.name}: {e}")
            
    # 5. Copy Transcripts
    logs_dir = source_brain_dir / ".system_generated" / "logs"
    transcript_copied = False
    if logs_dir.is_dir():
        for log_file in ["transcript.jsonl", "transcript_full.jsonl"]:
            source_log = logs_dir / log_file
            if source_log.is_file():
                try:
                    shutil.copy2(source_log, target_history_dir / log_file)
                    print(f"-> Copied log: {log_file}")
                    transcript_copied = True
                except PermissionError:
                    print(f"Warning: Permission denied copying log {log_file}")
                except Exception as e:
                    print(f"Warning: Failed to copy log {log_file}: {e}")
                
    if not transcript_copied:
        print("Warning: No transcript files found in the conversation logs.")
        
    # 6. Git Synchronization
    git_dir = proj_root / ".git"
    if git_dir.is_dir():
        if not check_git_installed():
            print("\nWarning: Git repository detected, but git executable is not available in your PATH. Skipping Git commit.")
            print("Sync completed successfully!")
            return
            
        try:
            print("\nStaging files in Git...")
            subprocess.run(["git", "add", str(target_history_dir)], check=True, cwd=proj_root)
            print("Conversation history and transcripts staged in Git successfully!")
            print("You can now commit these staged history files together with your code updates.")
        except subprocess.CalledProcessError as e:
            print(f"\nWarning: Git command failed with error code {e.returncode}.", file=sys.stderr)
            print("Your files have been successfully copied locally, but could not be staged automatically in Git.", file=sys.stderr)
    else:
        print("\nNote: Not a Git repository (or .git not found). Skipping Git commit.")
        
    print("\nSync completed successfully!")

if __name__ == "__main__":
    main()

# Team Customization Rules

These rules govern how Antigravity agents operate within this project repository to facilitate seamless team collaboration.

## 1. Artifact Mirroring
To ensure that all design decisions, test verifications, and walkthroughs are visible to the team during code reviews:
* **Mirroring Rule:** Whenever you create or modify an artifact (such as `implementation_plan.md`, `task.md`, or `walkthrough.md`) in the local user cache directory (`~/.gemini/antigravity/brain/<conversation-id>`), you MUST copy or write a duplicate version of that file to the workspace under `.antigravity/history/<conversation-id>/`.
* **Git Commits:** These mirrored documents should be staged and committed to Git alongside the source code changes.

## 2. Conversation Telemetry & Syncing
* If the user or agent needs to share the raw execution logs, terminal outputs, and thinking transcripts of a conversation:
  * Run the `team-sync` skill at the end of the session.
  * This will execute the `sync.py` script to collect the finalized `transcript.jsonl` and copy it to the same `.antigravity/history/<conversation-id>/` directory.

Review the summary transcripts in this project and help me understand how the team decided to deploy to Cloud Run instead of Kubernetes.