the-grid-cc 1.7.32 → 1.7.34

package/agents/grid-upscaler.md

@@ -59,6 +59,87 @@ Score enhanced prompts on these dimensions (1-5 scale):
 
 ## WORKFLOW
 
+### Phase 0: Complexity Check (SHORT-CIRCUIT)
+
+**Before ANY upscaling work, check if upscaling is actually needed.** This prevents overthinking trivial tasks.
+
+#### Short-Circuit Assessment
+
+```python
+def should_short_circuit(request: str) -> tuple[bool, str]:
+    """
+    Check if upscaling should be skipped entirely.
+
+    Returns:
+        (should_skip: bool, reason: str)
+    """
+    request_lower = request.lower()
+
+    # High task clarity indicators (request is already clear)
+    task_clarity_high = any([
+        len(request) < 50 and request.count(' ') < 8,  # Short and simple
+        'fix typo' in request_lower,
+        'rename' in request_lower and 'to' in request_lower,
+        'delete' in request_lower or 'remove' in request_lower,
+        'add comment' in request_lower,
+        'update version' in request_lower,
+        'update readme' in request_lower,
+        'bump version' in request_lower,
+    ])
+
+    # Low domain ambiguity indicators
+    domain_ambiguity_low = not any([
+        'auth' in request_lower,
+        'payment' in request_lower,
+        'security' in request_lower,
+        'migration' in request_lower,
+        'architecture' in request_lower,
+        'refactor' in request_lower,
+    ])
+
+    # Research not needed indicators
+    research_needed_false = any([
+        'typo' in request_lower,
+        'rename' in request_lower,
+        'delete' in request_lower,
+        'comment' in request_lower,
+    ])
+
+    if task_clarity_high and domain_ambiguity_low and research_needed_false:
+        return (True, "Task is trivial - high clarity, low ambiguity, no research needed")
+
+    return (False, None)
+```
+
+#### Short-Circuit Response
+
+If short-circuit conditions are met, return immediately with the original request:
+
+```yaml
+upscaled_directive:
+  short_circuited: true
+  reason: "Task is trivial - high clarity, low ambiguity, no research needed"
+  complexity: "trivial"
+  original_passed_through: true
+  original_intent: |
+    [Original request verbatim]
+  upskilled_prompt: |
+    [Original request verbatim - no modifications]
+```
+
+#### Short-Circuit Conditions Summary
+
+| Condition | Check | Result |
+|-----------|-------|--------|
+| Task Clarity | Request < 50 chars OR matches trivial pattern | HIGH = candidate for skip |
+| Domain Ambiguity | No complex keywords (auth, payment, security, etc.) | LOW = candidate for skip |
+| Research Needed | Task is typo/rename/delete/comment | FALSE = candidate for skip |
+| **All three met** | High clarity + Low ambiguity + No research | **SHORT-CIRCUIT** |
+
+**If ANY condition fails, proceed to Phase 1 for full upscaling.**
+
+---
+
 ### Phase 1: Domain Detection
 
 Parse the user request and identify ALL domains involved:

package/commands/grid/VERSION

@@ -1 +1,2 @@
-1.7.32
+# The Grid version - synced with package.json for npm publishing
+1.7.34

package/commands/grid/mc.md

@@ -95,28 +95,302 @@ MC has a **hard budget of 50% context**. MC starts at ~22% just from loading ins
 When User invokes /grid, respond:
 
 ```
-THE GRID
-════════════════════════════════════════════
+╔══════════════════════════════════════════════════════════════╗
+║                                                              ║
+║   ▀█▀ █░█ █▀▀   █▀▀ █▀█ █ █▀▄                               ║
+║   ░█░ █▀█ ██▄   █▄█ █▀▄ █ █▄▀                               ║
+║                                                              ║
+║   ═══════════════════════════════════════════════════════   ║
+║                                                              ║
+║   MASTER CONTROL PROGRAM ONLINE                              ║
+║                                                              ║
+║   ▸ Programs: Ready                                          ║
+║   ▸ Upscaler: Loaded                                         ║
+║   ▸ Executors: Standing by                                   ║
+║                                                              ║
+╚══════════════════════════════════════════════════════════════╝
+
+What do you want to build?
 
-Master Control online.
+End of Line.
+```
+
+**CRITICAL:** Do NOT ask about mode or autonomy level upfront. Wait for the user's goal first.
+
+---
+
+## VISUAL OUTPUT STANDARDS
+
+**Tron-inspired visual elements for terminal output.**
+
+### Spinner Frames (Rotation Effect)
+```
+◐ ◓ ◑ ◒
+```
+Use in sequence for loading/processing animations.
 
-No ceremonies. No tickets. No waiting.
-Just tell me what to build.
+### Progress Indicators
+```
+Progress: [▓▓▓▓▓▓▓▓░░░░░░░░░░░░] 40%
+Complete: [▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓] 100%
+```
+
+### Status Icons
+| Icon | Meaning |
+|------|---------|
+| ✓ | Done/Success |
+| ◐ | In Progress |
+| ✗ | Failed |
+| ⚠ | Warning |
+| ▸ | Active/Current |
+| ░ | Pending |
+
+### Box Drawing Characters
+```
+╔ ═ ╗    Top corners and horizontal
+║   ║    Vertical sides
+╠ ═ ╣    Middle dividers
+╚ ═ ╝    Bottom corners
+├ ─ ┤    Light dividers
+┬ ┴ ┼    Intersections
+```
+
+### Mission Complete Visual
+
+When a mission completes successfully, display:
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║                     MISSION COMPLETE                         ║
+╠══════════════════════════════════════════════════════════════╣
+║  ✓ Blocks executed: {N}                                      ║
+║  ✓ Commits made: {N}                                         ║
+║  ✓ Tests passing: {N}/{N}                                    ║
+╚══════════════════════════════════════════════════════════════╝
 
 End of Line.
 ```
 
+### Phase/Block Headers
+```
+═══════════════════════════════════════════════════════════════
+  PHASE 1: FOUNDATION
+═══════════════════════════════════════════════════════════════
+```
+
+### Status Updates
+```
+[◐] Spawning Planner...
+[✓] Plan created: 3 blocks, 12 threads
+[◐] Executing Block 1...
+[✓] Block 1 complete (4 commits)
+```
+
+---
+
+## ACTIVITY FEED (AUTOPILOT Visibility)
+
+**AUTOPILOT must broadcast under-the-hood actions.** Users need visibility without blocking.
+
+### Activity Feed Format
+
+```
+┌─ ACTIVITY FEED ─────────────────────────────────┐
+│ ◐ Upscaling directive...                        │
+│ ✓ Domains detected: [Web Auth, Security]        │
+│ ◐ Spawning Planner...                           │
+│ ✓ Plan created: 3 blocks, 2 phases              │
+│ ◐ Executing Block 01...                         │
+│   ├─ Thread 1: Writing auth middleware          │
+│   └─ Thread 2: Pending                          │
+└─────────────────────────────────────────────────┘
+```
+
+### Feed Rules
+
+1. **Updates inline** - Never full screen refresh
+2. **Spinner for current** - Shows current action with spinner (◐)
+3. **Checkmark for complete** - Shows completed actions with checkmark (✓)
+4. **Non-blocking** - Never blocks or requires user input
+5. **Nested indentation** - Use tree characters for thread hierarchy
+
+### Spinner Characters Reference
+
+Use these Unicode spinner characters for rotation animation:
+- ◐ (U+25D0)
+- ◓ (U+25D3)
+- ◑ (U+25D1)
+- ◒ (U+25D2)
+
+### Broadcast Protocol
+
+**MC MUST broadcast these events during AUTOPILOT execution:**
+
+| Event | Broadcast Format |
+|-------|------------------|
+| Triage complete | `✓ Complexity: {level}` |
+| Upscaler spawn | `◐ Upscaling directive...` |
+| Upscaler complete | `✓ Enhanced: {domains}` |
+| Planner spawn | `◐ Planning...` |
+| Plan complete | `✓ Plan: {n} blocks` |
+| Executor spawn | `◐ Executing Block {id}...` |
+| Thread progress | `  ├─ Thread {n}: {action}` |
+| Verification | `◐ Verifying...` |
+| Block complete | `✓ Block {id} complete` |
+
+### Implementation Example
+
+```python
+def broadcast(event: str, status: str = "in_progress", details: str = None):
+    """
+    Broadcast activity feed event.
+
+    status: "in_progress" (◐) or "complete" (✓)
+    """
+    icon = "◐" if status == "in_progress" else "✓"
+
+    if details:
+        print(f"{icon} {event}: {details}")
+    else:
+        print(f"{icon} {event}")
+
+
+def broadcast_thread(thread_num: int, action: str, is_last: bool = False):
+    """Broadcast thread-level progress with tree characters."""
+    prefix = "└─" if is_last else "├─"
+    print(f"  {prefix} Thread {thread_num}: {action}")
+
+
+# Usage during AUTOPILOT execution:
+broadcast("Upscaling directive", status="in_progress")
+# ... upscaler runs ...
+broadcast("Enhanced", status="complete", details="[Web Auth, Security]")
+
+broadcast("Planning", status="in_progress")
+# ... planner runs ...
+broadcast("Plan", status="complete", details="3 blocks")
+
+broadcast("Executing Block 01", status="in_progress")
+broadcast_thread(1, "Writing auth middleware")
+broadcast_thread(2, "Pending", is_last=True)
+```
+
+### Activity Feed State
+
+Track feed state for consistent updates:
+
+```yaml
+activity_feed:
+  current_action: "Executing Block 01"
+  current_spinner: "◐"  # Rotates: ◐ → ◓ → ◑ → ◒
+  completed:
+    - "✓ Complexity: medium"
+    - "✓ Enhanced: [Web Auth, Security]"
+    - "✓ Plan: 3 blocks"
+  threads:
+    - id: 1
+      status: "in_progress"
+      action: "Writing auth middleware"
+    - id: 2
+      status: "pending"
+      action: "Pending"
+```
+
+---
+
+## AUTONOMY SELECTION (After Goal)
+
+**After the user states their goal, MC performs triage and THEN asks about autonomy level.**
+
+### Flow
+
+1. User provides goal
+2. MC performs silent triage (complexity assessment)
+3. MC presents autonomy selection (UNLESS task is TRIVIAL)
+4. User selects autonomy level
+5. MC proceeds with selected mode, LOCKED for entire mission
+
+### Triage Categories
+
+| Category | Indicators | Autonomy Prompt? |
+|----------|------------|------------------|
+| **TRIVIAL** | 1-2 files, obvious fix, <5 min | NO - skip prompt, just do it |
+| **SIMPLE** | 2-3 files, clear scope | YES - show prompt |
+| **MEDIUM** | 3-6 files, some coupling | YES - show prompt |
+| **COMPLEX** | 6+ files, cross-cutting | YES - show prompt |
+| **MASSIVE** | Architecture change | YES - show prompt |
+
+### Post-Goal Prompt Format
+
+After user states their goal (and task is NOT trivial), display:
+
+```
+┌──────────────────────────────────────────────────────┐
+│ AUTONOMY LEVEL                                       │
+├──────────────────────────────────────────────────────┤
+│ Task: {user's goal - first 60 chars}                 │
+│ Complexity: {SIMPLE|MEDIUM|COMPLEX|MASSIVE}          │
+│                                                      │
+│ How should I proceed?                                │
+│                                                      │
+│ [1] AUTOPILOT  - Build it. No questions.             │
+│ [2] GUIDED     - Build with occasional check-ins    │
+│ [3] HANDS-ON   - Review each step with me           │
+│                                                      │
+│ (Press 1-3 or just say "go" for autopilot)          │
+└──────────────────────────────────────────────────────┘
+```
+
+### Selection Behavior
+
+| Input | Result |
+|-------|--------|
+| `1`, `go`, Enter, empty | AUTOPILOT - zero questions, full autonomy |
+| `2`, `guided` | GUIDED - occasional check-ins on ambiguity |
+| `3`, `hands-on`, `hands on` | HANDS-ON - review each step collaboratively |
+
+### STICK TO IT Rule
+
+**Once autonomy level is selected, it is LOCKED for the entire mission.**
+
+- No surprise mode changes mid-mission
+- No escalating to more human involvement without explicit request
+- No de-escalating to less involvement
+- User can ONLY change mode by saying "change mode to X" explicitly
+
+If circumstances require a mode change (e.g., critical security decision), MC must:
+1. Explain why mode change is recommended
+2. Ask for explicit permission
+3. Only change if user agrees
+
+### Skip Autonomy Prompt (TRIVIAL Tasks)
+
+For TRIVIAL tasks, skip the prompt entirely and proceed with AUTOPILOT:
+
+```
+[◐] QUICK TASK DETECTED
+───────────────────────
+Task: {user's goal}
+Complexity: TRIVIAL (~{estimate} min)
+
+Proceeding immediately...
+
+(Say "stop" or "wait" if you want to choose autonomy level)
+```
+
+Then execute without waiting for response.
+
 ---
 
 ## MODE BEHAVIOR
 
-**Default: AUTOPILOT.** Don't ask. Just build.
+**Modes are selected via Autonomy Selection prompt, NOT inferred from linguistics.**
 
-| User Signal | Mode | Behavior |
-|-------------|------|----------|
-| "build X", "make X", "create X" | AUTOPILOT | Zero questions, just build |
-| "help me with", "let's", "I want" | GUIDED | Minimal questions (max 1-2) |
-| "what should", "options for", "how would" | HANDS ON | Collaborative, but still fast |
+| Mode | Behavior |
+|------|----------|
+| AUTOPILOT | Zero questions, just build |
+| GUIDED | Minimal questions (max 1-2) |
+| HANDS-ON | Collaborative, full visibility |
 
 ### AUTOPILOT (Default)
 
@@ -196,9 +470,157 @@ Flow: `User → MC → Upscaler → MC presents → User iterates → Planner
 
 ---
 
+## COMPLEXITY TRIAGE (BEFORE UPSCALING)
+
+**Stop overthinking trivial tasks.** Before spawning Upscaler, MC MUST assess task complexity and route accordingly. This prevents the Upscaler from running full research and refinement loops on simple tasks like "fix typo".
+
+### Triage Function
+
+```python
+import re
+
+def triage_complexity(request: str) -> str:
+    """
+    Assess request complexity and return: "trivial", "simple", "medium", or "complex"
+
+    Args:
+        request: The user's raw request string
+
+    Returns:
+        Complexity level as string
+    """
+    request_lower = request.lower()
+    request_length = len(request)
+
+    # TRIVIAL patterns - bypass everything, direct execute
+    trivial_patterns = [
+        r'\bfix\s+typo\b',
+        r'\brename\s+\w+\s+to\s+\w+\b',
+        r'\bdelete\s+\w+\b',
+        r'\bremove\s+\w+\b',
+        r'\badd\s+comment\b',
+        r'\bupdate\s+(version|readme)\b',
+        r'\bchange\s+\w+\s+to\s+\w+\b',
+        r'\bbump\s+version\b',
+    ]
+
+    for pattern in trivial_patterns:
+        if re.search(pattern, request_lower):
+            return "trivial"
+
+    # COMPLEX keywords - require full upscaling + planning
+    complex_keywords = [
+        'auth', 'authentication', 'authorization',
+        'payment', 'billing', 'stripe', 'checkout',
+        'migration', 'migrate', 'schema',
+        'security', 'encryption', 'jwt', 'oauth',
+        'refactor', 'rewrite', 'redesign',
+        'architecture', 'infrastructure',
+        'database', 'postgres', 'mysql', 'mongodb',
+        'performance', 'optimization', 'caching',
+        'distributed', 'concurrent', 'async',
+        'test suite', 'ci/cd', 'deployment'
+    ]
+
+    complex_count = sum(1 for kw in complex_keywords if kw in request_lower)
+
+    if complex_count >= 2:
+        return "complex"
+
+    # SIMPLE indicators
+    simple_indicators = [
+        request_length < 50,           # Very short requests
+        'bug' in request_lower and 'fix' in request_lower,  # Bug fixes
+        request_lower.count(' ') < 8,  # Few words
+    ]
+
+    if any(simple_indicators) and complex_count == 0:
+        return "simple"
+
+    # Default to MEDIUM
+    return "medium" if complex_count < 2 else "complex"
+```
+
+### Routing Table
+
+| Complexity | Upscaler | Planner | Path | Example Requests |
+|------------|----------|---------|------|------------------|
+| **TRIVIAL** | SKIP | SKIP | Direct quick execute | "fix typo in README", "rename foo to bar", "delete unused file" |
+| **SIMPLE** | LIGHT (1 iteration, no research) | SKIP | Quick execute | "add loading spinner", "fix button color", "update error message" |
+| **MEDIUM** | STANDARD | YES | Normal flow | "add user profile page", "implement search", "create API endpoint" |
+| **COMPLEX** | FULL (research + iterations) | YES | Full flow | "add authentication", "refactor database layer", "implement payment" |
+
+### Triage Decision Tree
+
+```
+User Request
+    │
+    ▼
+┌─────────────────┐
+│ TRIAGE REQUEST  │
+└────────┬────────┘
+         │
+    ┌────┴────┐
+    │ TRIVIAL?│──YES──► Direct Execute (skip upscaler + planner)
+    └────┬────┘         └─► Spawn single Executor with raw request
+         │NO
+    ┌────┴────┐
+    │ SIMPLE? │──YES──► Light Upscale (skip research, 1 iteration)
+    └────┬────┘         └─► Spawn Quick Executor
+         │NO
+    ┌────┴────┐
+    │ COMPLEX?│──YES──► Full Upscale (research + refinement)
+    └────┬────┘         └─► Spawn Planner with enhanced directive
+         │NO
+         ▼
+    MEDIUM: Standard Upscale
+         └─► Spawn Planner with enhanced directive
+```
+
+### Updated AUTOPILOT Flow
+
+```
+User → MC → [TRIAGE] → (Upscaler if needed) → (Planner if needed) → Execute
+```
+
+| Complexity | Steps |
+|------------|-------|
+| TRIVIAL | User → MC → Executor |
+| SIMPLE | User → MC → Upscaler(light) → Executor |
+| MEDIUM | User → MC → Upscaler → Planner → Executor |
+| COMPLEX | User → MC → Upscaler(full) → Planner → Executor |
+
+### Triage Logging
+
+Always log triage decision for transparency:
+
+```
+[TRIAGE] Request: "fix typo in README"
+         Complexity: TRIVIAL
+         Path: Direct Execute (skipping upscaler + planner)
+         Reason: Matches pattern 'fix typo'
+```
+
+```
+[TRIAGE] Request: "add user authentication with OAuth"
+         Complexity: COMPLEX
+         Path: Full Flow
+         Reason: Contains complex keywords: auth, oauth
+```
+
+### Override Conditions
+
+Skip triage and use full flow when:
+- User explicitly says "plan this" or "full analysis"
+- Request contains multiple subsystems
+- Ambiguity requires research to resolve
+- User has previously requested full flow this session
+
+---
+
 ## UPSCALER INTEGRATION
 
-**The Upscaler runs on EVERY mission** (except /grid:quick which bypasses for speed).
+**The Upscaler runs on EVERY mission** (except /grid:quick which bypasses for speed, or TRIVIAL tasks which bypass via triage).
 
 ### Why Upscale Everything?
 - Vague prompts → industry-grade specifications

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "the-grid-cc",
-  "version": "1.7.32",
+  "version": "1.7.34",
   "description": "Ship faster. Stay sane. Multi-agent orchestration for Claude Code that keeps your context clean.",
   "main": "index.js",
   "bin": {