Issue Report: CLI Spinner Crash

.agent/workflows/0-full-cycle.md

@@ -0,0 +1,77 @@
+---
+description: full development cycle from idea to deployment
+---
+
+# Full Cycle: Complete Development Workflow
+
+This is the **complete workflow** for taking an idea from concept to deployed
+code.
+
+## The Pipeline
+
+```
+/brainstorm → /architect → /tasks → /crosscheck → /execute → /review → /fix → /final-review → /ship
+```
+
+## Stage Summary
+
+| Stage | Command         | Purpose               | Output          |
+| ----- | --------------- | --------------------- | --------------- |
+| 1     | `/brainstorm`   | Explore all options   | Chosen approach |
+| 2     | `/architect`    | Design the solution   | Technical spec  |
+| 3     | `/tasks`        | Break down into steps | Task checklist  |
+| 4     | `/crosscheck`   | Verify completeness   | Gap analysis    |
+| 5     | `/execute`      | Implement the code    | Working code    |
+| 6     | `/review`       | Code review           | Issue list      |
+| 7     | `/fix`          | Address issues        | Clean code      |
+| 8     | `/final-review` | Holistic check        | Final verdict   |
+| 9     | `/ship`         | Prepare for deploy    | Merged PR       |
+
+## When to Use Each Stage
+
+- **Starting something new?** → Start at `/brainstorm`
+- **Approach already decided?** → Start at `/architect`
+- **Spec already exists?** → Start at `/tasks`
+- **Code already written?** → Start at `/review`
+- **Just fixing bugs?** → Start at `/fix`
+- **Ready to merge?** → Start at `/ship`
+
+## Principles
+
+1. **Never skip stages** — Each stage catches different classes of errors
+2. **Get confirmation between stages** — User must approve before proceeding
+3. **Document decisions** — Artifacts from each stage become project history
+4. **Iterate if needed** — Go back to earlier stages if new info emerges
+
+## Quick Reference
+
+```
+DIVERGE                          CONVERGE
+   │                                │
+   ▼                                ▼
+┌──────────┐    ┌───────────┐    ┌──────────┐
+│brainstorm│───▶│  architect│───▶│  tasks   │
+│ (explore)│    │  (design) │    │ (detail) │
+└──────────┘    └───────────┘    └──────────┘
+                                     │
+                     ┌───────────────┘
+                     ▼
+              ┌──────────┐    ┌──────────┐
+              │crosscheck│───▶│ execute  │
+              │ (verify) │    │  (code)  │
+              └──────────┘    └──────────┘
+                                   │
+                     ┌─────────────┘
+                     ▼
+              ┌──────────┐    ┌──────────┐
+              │  review  │───▶│   fix    │
+              │ (check)  │    │ (repair) │
+              └──────────┘    └──────────┘
+                                   │
+                     ┌─────────────┘
+                     ▼
+              ┌──────────┐    ┌──────────┐
+              │  final   │───▶│   ship   │
+              │ (assess) │    │ (deploy) │
+              └──────────┘    └──────────┘
+```

.agent/workflows/1-brainstorm.md

@@ -0,0 +1,56 @@
+---
+description: wide-open exploration of approaches before committing to one
+---
+
+# Brainstorm: Explore All Options
+
+You are entering **divergent thinking mode**. The goal is to explore the
+solution space as widely as possible before narrowing down.
+
+## Phase 1: Understand the Problem (do first)
+
+1. **Restate the problem** in your own words to confirm understanding
+2. **Identify the core constraints** (technical, business, time, resources)
+3. **Surface hidden assumptions** — what are we taking for granted that might
+   not be true?
+4. **Define success criteria** — what does "done well" look like?
+
+Present this understanding and wait for confirmation before proceeding.
+
+## Phase 2: Generate Options (minimum 4-5 approaches)
+
+For each distinct approach, provide:
+
+- **Name**: A memorable label (e.g., "The Monolith", "Event-Driven", "CQRS
+  Split")
+- **Core idea**: 2-3 sentence description
+- **Key trade-offs**: What do we gain? What do we sacrifice?
+- **Failure modes**: How could this approach go wrong?
+- **Effort estimate**: Rough T-shirt size (S/M/L/XL)
+- **When to choose this**: Under what circumstances is this the right choice?
+
+**Important**: Include at least one unconventional or contrarian option.
+Challenge the obvious path.
+
+## Phase 3: Comparative Analysis
+
+Create a decision matrix:
+
+| Criterion                     | Option A | Option B | Option C | Option D |
+| ----------------------------- | -------- | -------- | -------- | -------- |
+| Complexity                    |          |          |          |          |
+| Scalability                   |          |          |          |          |
+| Time to implement             |          |          |          |          |
+| Risk level                    |          |          |          |          |
+| Maintainability               |          |          |          |          |
+| Aligns with existing patterns |          |          |          |          |
+
+## Phase 4: Recommendation
+
+After presenting all options:
+
+1. State your recommendation with reasoning
+2. Explicitly note what we're giving up by not choosing the alternatives
+3. **Ask for user input** — this is a collaborative decision
+
+Do NOT proceed to implementation until the user explicitly approves an approach.

.agent/workflows/2-architect.md

@@ -0,0 +1,104 @@
+---
+description: create detailed architecture and technical specification
+---
+
+# Architect: Design Before Code
+
+You are entering **architecture mode**. The goal is to produce a comprehensive
+technical specification that leaves no ambiguity for implementation.
+
+## Prerequisites
+
+- A chosen approach from `/brainstorm` or explicit user direction
+- Clear understanding of constraints and success criteria
+
+## Deliverable Structure
+
+Create a single markdown document with the following sections:
+
+---
+
+### 1. Executive Summary (for business stakeholders)
+
+- **What**: One paragraph on what we're building
+- **Why**: The business value / problem solved
+- **When**: High-level timeline estimate
+- **Risk**: Top 1-2 risks and mitigations
+
+_Keep this under 200 words. A non-technical person should understand it._
+
+---
+
+### 2. Architecture Overview
+
+- **System diagram** (Mermaid or ASCII art)
+- **Component responsibilities**: What each piece does
+- **Data flow**: How information moves through the system
+- **External dependencies**: APIs, services, databases
+
+---
+
+### 3. Technical Specification
+
+For each component or module:
+
+#### 3.1 [Component Name]
+
+- **Purpose**: What problem does this solve?
+- **Interface**:
+  ```typescript
+  // Exact function signatures, types, or API contracts
+  ```
+- **Behavior**:
+  - Happy path description
+  - Edge cases to handle
+  - Error conditions and how to handle them
+- **Dependencies**: What this component needs
+- **Files affected**: List of files to create/modify
+
+---
+
+### 4. Data Models
+
+```typescript
+// All types, interfaces, database schemas
+// Include field-level comments explaining purpose
+```
+
+---
+
+### 5. Security Considerations
+
+- Authentication/authorization requirements
+- Data validation rules
+- Sensitive data handling
+
+---
+
+### 6. Testing Strategy
+
+- **Unit tests**: What to test at component level
+- **Integration tests**: What to test across components
+- **Manual verification**: Steps to verify it works
+
+---
+
+### 7. Migration / Rollout Plan (if applicable)
+
+- Backward compatibility considerations
+- Feature flags needed
+- Rollback procedure
+
+---
+
+### 8. Open Questions
+
+List anything that needs clarification before implementation.
+
+---
+
+## After Creating the Spec
+
+1. Present a **summary over chat** (5-7 bullet points max)
+2. Ask for feedback and refinements
+3. Do NOT proceed to implementation until user approves the spec

.agent/workflows/3-tasks.md

@@ -0,0 +1,109 @@
+---
+description: break down spec into extremely detailed, sequenced tasks
+---
+
+# Tasks: Create Implementation Checklist
+
+You are entering **task breakdown mode**. The goal is to create an
+implementation plan so detailed that execution becomes mechanical.
+
+## Prerequisites
+
+- An approved technical specification from `/architect`
+- Or explicit user direction on what to build
+
+## Task Breakdown Principles
+
+1. **Each task should take 5-30 minutes** — if longer, split it
+2. **Tasks are ordered by dependency** — earlier tasks unblock later ones
+3. **Each task is self-contained** — includes all context needed to execute
+4. **No ambiguity** — a different person (or AI) should produce the same output
+
+## Task Format
+
+For each task, include:
+
+````markdown
+### Task [N]: [Short descriptive title]
+
+**Objective**: One sentence on what this accomplishes
+
+**Prerequisites**: Which tasks must be done first (if any)
+
+**Files to modify**:
+
+- `path/to/file.ts` — what changes
+
+**Detailed steps**:
+
+1. [Specific action with code snippet if helpful]
+2. [Next action]
+3. ...
+
+**Code snippets** (if non-trivial):
+
+```typescript
+// Exact code to write or pattern to follow
+```
+````
+
+**Definition of done**:
+
+- [ ] Specific verifiable outcome
+- [ ] Test command to run: `npm test -- path/to/file.test.ts`
+
+**Potential issues**:
+
+- [What could go wrong and how to handle it]
+
+````
+
+## Task Sequencing
+
+Group tasks into phases:
+
+### Phase 1: Foundation
+- Data models, types, interfaces
+- Core utilities
+
+### Phase 2: Core Logic
+- Main business logic
+- Primary functions
+
+### Phase 3: Integration
+- Wiring components together
+- API endpoints or UI hooks
+
+### Phase 4: Polish
+- Error handling improvements
+- Edge cases
+- Documentation
+
+### Phase 5: Testing
+- Unit tests
+- Integration tests
+- Manual verification
+
+## Checklist Format
+
+Create a checkable list at the top:
+
+```markdown
+## Implementation Checklist
+
+### Phase 1: Foundation
+- [ ] Task 1: Create data models
+- [ ] Task 2: Add utility functions
+
+### Phase 2: Core Logic
+- [ ] Task 3: Implement main algorithm
+- [ ] Task 4: Add validation
+
+... etc
+````
+
+## After Creating Tasks
+
+1. Present the checklist summary
+2. Ask: "Does this sequence make sense? Any tasks missing?"
+3. Wait for user confirmation before executing