[ADD] .antigravity workflow folder

.antigravity/resources/architecting/act-template.md

@@ -0,0 +1,68 @@
+# Act-Level CLAUDE.md Template
+
+Template for creating the root CLAUDE.md with Act overview and Casts summary.
+
+## Full Template Structure
+
+```markdown
+# Backand
+
+## Act Overview
+**Purpose:** {One sentence describing what this project does}
+**Domain:** {e.g., Customer Support, Data Processing, Business Automation}
+
+## Casts
+| Cast Name | Purpose | Location |
+|-----------|---------|----------|
+| Chat | {Brief purpose} | [casts/chat/CLAUDE.md](casts/chat/CLAUDE.md) |
+
+## Next Steps
+
+### Initial Setup
+1. Review this architecture
+2. Create cast package: `uv run act cast -c "Chat"`
+3. Implement cast following [casts/chat/CLAUDE.md](casts/chat/CLAUDE.md)
+
+### Development Workflow
+1. **Design**: Use `architecting-act` skill - Create/update architecture
+2. **Scaffold**: Use `engineering-act` skill - Create cast package and manage dependencies
+3. **Implement**: Use `developing-cast` skill - Implement nodes, state, and graph
+4. **Test**: Use `testing-cast` skill - Write and run tests
+```
+
+## Usage Notes
+
+### Location
+- **File path**: `PROJECT_ROOT/CLAUDE.md`
+- **Contains**: Act-level information and Casts summary only
+- **Does NOT contain**: Detailed Cast specifications (those go in `casts/{cast_slug}/CLAUDE.md`)
+
+### When to Update
+
+- **Initial Design (Mode 1)**: Create this file
+- **Add Cast (Mode 2)**: Add row to Casts table
+- **Extract Sub-Cast (Mode 3)**: Add row to Casts table for sub-cast
+- **Update Act Purpose**: Modify Act Overview section
+
+### Casts Table Format
+
+Each row should have:
+- **Cast Name**: Display name (PascalCase)
+- **Purpose**: One sentence describing what this cast does
+- **Location**: Link to cast's CLAUDE.md file in `casts/` directory
+
+### Next Steps Section
+
+Keep this section updated with:
+- Current implementation status
+- Next cast to implement
+- Outstanding architecture decisions
+- Dependencies between casts
+
+## Checklist
+
+- [ ] Act Overview is clear and concise (1-2 sentences)
+- [ ] Domain is specified
+- [ ] All Casts are listed in Casts table
+- [ ] Each Cast has a working link to its CLAUDE.md
+- [ ] Next Steps are actionable

.antigravity/resources/architecting/cast-analysis-guide.md

@@ -0,0 +1,152 @@
+# Cast Complexity Analysis Guide
+
+Guide for analyzing Cast complexity and determining when to extract Sub-Casts.
+
+## When to Analyze
+
+Analyze Cast complexity when:
+- User mentions cast is "too complex" or "hard to understand"
+- You notice a cast has many nodes during design
+- User wants to add similar logic to another cast
+- During review of existing CLAUDE.md files (root + cast-specific)
+
+## Complexity Indicators
+
+### High Complexity Signals
+
+**Node Count**: More than 7 nodes suggests high complexity
+
+**Deep Nesting**: Conditional branches >3 levels deep
+
+**Repeated Patterns**: Same node sequence appears in multiple casts
+
+**Long Cycles**: Loop contains >4 nodes
+
+**Mixed Concerns**: Single cast handles multiple distinct workflows
+
+## Analysis Process
+
+### Step 1: Count Nodes
+
+Read the Cast's Architecture Diagram and count nodes (excluding START/END).
+
+```
+Low: 3-5 nodes
+Medium: 6-7 nodes
+High: 8+ nodes
+```
+
+### Step 2: Identify Patterns
+
+Look for:
+- **Repeated Sequences**: Same 2-3 nodes appearing together
+- **Isolated Sections**: Nodes that don't interact with rest of graph
+- **Reusable Logic**: Validation, formatting, common transformations
+
+### Step 3: Check for Shared Logic
+
+Compare with other Casts (check root CLAUDE.md's Casts table and their respective cast CLAUDE.md files):
+- Do multiple casts have similar node sequences?
+- Is there common preprocessing/postprocessing?
+- Are there shared validation steps?
+
+## Extraction Criteria
+
+### Extract as Sub-Cast When:
+
+✅ **Reusable**: Used by 2+ casts
+✅ **Self-contained**: Has clear input/output, minimal dependencies
+✅ **Cohesive**: Nodes work together toward single purpose
+✅ **Stable**: Logic unlikely to change frequently
+
+### Keep in Main Cast When:
+
+❌ **One-off**: Only used in this cast
+❌ **Tightly coupled**: Heavily depends on parent cast's state
+❌ **Simple**: Only 1-2 nodes
+❌ **Unstable**: Logic changes frequently
+
+## Extraction Proposal Template
+
+When suggesting extraction, present:
+
+```
+"I notice [Pattern/Section] in Cast: [CastName].
+
+**Complexity**: [X] nodes, [specific issue]
+
+**Suggestion**: Extract as Sub-Cast: [ProposedName]
+
+**Benefits**:
+- Reduces main cast from X to Y nodes
+- Reusable in [OtherCast1, OtherCast2]
+- Clearer separation of concerns
+
+**Extracted Nodes**:
+- NodeA
+- NodeB
+- NodeC
+
+Should we proceed with this extraction?"
+```
+
+## Sub-Cast Naming
+
+Sub-Casts should be named with clear purpose:
+
+✅ Good: `InputValidation`, `DocumentParser`, `ResponseFormatter`
+❌ Bad: `Helper`, `Utils`, `Common`
+
+## Example Analysis
+
+### Before (Complex Cast)
+
+```mermaid
+graph TD
+    START --> ValidateInput
+    ValidateInput --> ParseDocument
+    ParseDocument --> CleanText
+    CleanText --> ChunkText
+    ChunkText --> EmbedChunks
+    EmbedChunks --> StoreVectors
+    StoreVectors --> RetrieveContext
+    RetrieveContext --> GenerateResponse
+    GenerateResponse --> FormatOutput
+    FormatOutput --> END
+```
+
+**Analysis**: 10 nodes, contains two distinct workflows (indexing + retrieval)
+
+### After (Extracted Sub-Casts)
+
+**Main Cast (Retrieval)**:
+```mermaid
+graph TD
+    START --> ValidateInput
+    ValidateInput --> RetrieveContext
+    RetrieveContext --> GenerateResponse
+    GenerateResponse --> FormatOutput
+    FormatOutput --> END
+```
+
+**Sub-Cast (DocumentIndexing)**:
+```mermaid
+graph TD
+    START --> ParseDocument
+    ParseDocument --> CleanText
+    CleanText --> ChunkText
+    ChunkText --> EmbedChunks
+    EmbedChunks --> StoreVectors
+    StoreVectors --> END
+```
+
+**Benefits**: Main cast reduced from 10 to 5 nodes, indexing logic reusable, clearer responsibilities
+
+## Checklist
+
+- [ ] Node count exceeds 10
+- [ ] Repeated patterns identified
+- [ ] Shared logic across casts found
+- [ ] Clear extraction boundary exists
+- [ ] Sub-Cast would be reusable
+- [ ] Extraction maintains graph correctness

.antigravity/resources/architecting/cast-template.md

@@ -0,0 +1,162 @@
+# Cast-Level CLAUDE.md Template
+
+Template for creating Cast-specific CLAUDE.md with detailed specifications.
+
+## Full Template Structure
+
+```markdown
+# Cast: Chat
+
+> **Parent Act:** [Backand](../../CLAUDE.md)
+
+## Overview
+**Purpose:** {One sentence describing what this cast does}
+**Pattern:** {Sequential | Branching | Cyclic | Multi-agent}
+**Latency:** {Low | Medium | High}
+**Dependencies:** {List of other casts this depends on, or "None"}
+
+## Architecture Diagram
+
+\```mermaid
+graph TD
+    START((START)) --> Node1[NodeName]
+    Node1 --> Node2[NodeName]
+    Node2 --> END((END))
+\```
+
+## State Schema
+
+### InputState
+| Field | Type | Description |
+|-------|------|-------------|
+| field_name | type | description |
+
+### OutputState
+| Field | Type | Description |
+|-------|------|-------------|
+| field_name | type | description |
+
+### OverallState
+| Field | Type | Category | Description |
+|-------|------|----------|-------------|
+| field_name | type | Input | description |
+| field_name | type | Output | description |
+| field_name | type | Internal | description |
+
+## Node Specifications
+
+### NodeName
+| Attribute | Value |
+|-----------|-------|
+| Responsibility | {Single sentence describing what this node does} |
+| Reads | {state fields this node reads} |
+| Writes | {state fields this node writes} |
+
+## Technology Stack
+
+> Note: `langgraph`, `langchain` are already in template. List only **additional** dependencies for this Cast.
+
+### Additional Dependencies
+| Package | Purpose |
+|---------|---------|
+| package-name | purpose |
+
+### Environment Variables
+| Variable | Required | Description |
+|----------|----------|-------------|
+| VAR_NAME | Yes/No | description |
+
+## Implementation Notes
+
+### Module Structure
+```
+casts/chat/
+  ├── graph.py           # Main graph assembly
+  ├── modules/
+  │   ├── state.py       # State definitions
+  │   ├── nodes.py       # Node implementations
+  │   ├── conditions.py  # Conditional routing (if needed)
+  │   ├── agents.py      # Agent configurations (if needed)
+  │   ├── tools.py       # Custom tools (if needed)
+  │   └── middlewares.py # Middleware setup (if needed)
+  └── tests/
+      └── test_*.py      # Test files
+```
+
+### Next Steps
+1. Create cast package: `uv run act cast -c "Chat"`
+2. Implement components in order: state → dependency modules → nodes → conditions → graph
+3. Add dependencies: `uv add --package chat package-name`
+4. Write tests: Use `testing-cast` skill
+5. Run LangGraph dev server: `uv run langgraph dev`
+```
+
+## Usage Notes
+
+### Location
+- **File path**: `PROJECT_ROOT/casts/chat/CLAUDE.md`
+- **Contains**: Complete Cast specifications and implementation guide
+- **Links to**: Root CLAUDE.md for Act-level context
+
+### When to Create
+
+- **Initial Design (Mode 1)**: Create along with root CLAUDE.md
+- **Add Cast (Mode 2)**: Create for each new cast
+- **Extract Sub-Cast (Mode 3)**: Create for extracted sub-cast
+
+### When to Update
+
+- **Add nodes**: Update Node Specifications and Architecture Diagram
+- **Modify state**: Update State Schema
+- **Add dependencies**: Update Technology Stack
+- **Change pattern**: Update Overview and possibly entire structure
+
+### Pattern-Specific Guidance
+
+#### Sequential Pattern
+- Nodes execute in linear order
+- Each node processes and passes to next
+- Simple state flow (Input → Internal → Output)
+
+#### Branching Pattern
+- Router node determines path
+- Multiple handler nodes for different cases
+- State includes routing decision field
+
+#### Cyclic Pattern
+- Refinement loop with exit condition
+- State tracks iteration count and quality metrics
+- Condition node checks if refinement needed
+
+#### Multi-agent Pattern
+- Specialized agents for different roles
+- Supervisor coordinates agent interactions
+- State includes agent outputs and coordination info
+
+## Cross-References
+
+### Parent/Sub-Cast Relationships
+
+If this is a sub-cast, document:
+- **Parent Cast**: Link to parent cast CLAUDE.md
+- **Integration Point**: Where/how parent calls this sub-cast
+- **Input Contract**: What parent passes to this sub-cast
+- **Output Contract**: What this sub-cast returns to parent
+
+If this has sub-casts, document:
+- **Sub-Casts**: List of sub-casts this calls
+- **Why Sub-Cast**: Reason for extraction (complexity, reuse, etc.)
+- **Integration**: How sub-casts are invoked
+
+## Checklist
+
+- [ ] Overview clearly states cast purpose
+- [ ] Pattern is identified and appropriate
+- [ ] Architecture diagram shows all nodes and edges
+- [ ] Diagram has START and END nodes
+- [ ] All three state schemas defined (InputState, OutputState, OverallState)
+- [ ] Every node in diagram has a specification
+- [ ] Node specifications include Responsibility, Reads, Writes
+- [ ] Technology Stack lists additional dependencies
+- [ ] Environment variables documented
+- [ ] Links to parent Act CLAUDE.md work