ONE TASK = ONE ATOMIC CHANGE = ONE VERIFICATION = DONE ✅

flowchart TB
    subgraph Playground["Node.js Playground"]
        WS[websocket.ts]
        API_C[api-client.ts]
        SOCK_C[socket-client.ts]
        PLAYER[audio-player.ts]
    end

    subgraph Go["Go Audio Server"]
        API[api.go]
        SESSION[session.go]
        SOCKET[socket.go]
        FFMPEG[ffmpeg.go]
        YTDLP[youtube.go]
    end

    WS --> API_C -->|HTTP :8180| API
    WS --> SOCK_C <-->|Unix Socket| SOCKET
    SOCK_C --> PLAYER
    API --> SESSION --> YTDLP --> FFMPEG --> SOCKET

graph TD
    START((START)) --> SELECT[0. Task Selection]
    SELECT --> C3[1. Load C3 Context]
    C3 --> PARALLEL{Can Parallelize?}
    PARALLEL -->|Yes, Different Layers| COORD[→ Parallel Streams]
    PARALLEL -->|No, Same Layer| CONTEXT[2. Load Task Context]
    COORD --> SPAWN[Node.js Stream + Go Stream]
    CONTEXT --> PLAN[3. Micro Plan]
    PLAN --> CONFIRM[4. User Confirm]
    CONFIRM --> EXEC[5. Execute]
    EXEC --> TEST[6. Verify]
    TEST --> LOG[7. Log & Done]
    LOG --> NEXT{More Tasks?}
    NEXT -->|Yes| SELECT
    NEXT -->|No| DONE((DONE))

📋 **Select a Story to Implement**

**Existing Stories:**
┌────┬─────────────────────────┬─────────┬──────────────┐
│ #  │ Story Name              │ Layer   │ C3 Component │
├────┼─────────────────────────┼─────────┼──────────────┤
│ 1  │ add-volume-command      │ Both    │ c3-101, c3-203│
│ 2  │ implement-skip-command  │ Node.js │ c3-101, c3-103│
│ 3  │ optimize-jitter-buffer  │ Go      │ c3-204       │
└────┴─────────────────────────┴─────────┴──────────────┘

**Options:**
- Type a number (e.g., `1`) to select a story
- Type a new story name to create new

👉 **Your choice:**

flowchart LR
    STORY[Read Story] --> IDENTIFY[Identify C3 Components]
    IDENTIFY --> READ_C3[Read C3 Docs]
    READ_C3 --> PATTERNS[Extract Patterns]

## Task: T001 - Add /volume command handler

### C3 Component: c3-101 Discord Bot
### Layer: Node.js
### Pattern: Follow `node/src/commands/play.ts`

### Files to Create/Modify
- [ ] `node/src/commands/volume.ts` (CREATE)
- [ ] `node/src/socket/commands.ts` (MODIFY - add volume type)

### Code Changes
1. Create volume command following play.ts pattern
2. Add volume command type to socket commands
3. Follow C3-101 interface from `.c3/c3-1-nodejs/c3-101-discord-bot/README.md`

### Verification
- [ ] File exists at correct path
- [ ] TypeScript compiles: `cd node && npm run build`
- [ ] Pattern matches C3 component doc
- [ ] Command registered with Discord

### Dependencies
- Requires c3-203 Opus Encoder to support volume (Go task)

Ready to implement:

**Node.js Tasks:**
- T001: Add /volume command handler (c3-101)

**Go Tasks:**
- T002: Add volume to FFmpeg pipeline (c3-203)

**Integration Tasks:**
- T003: Add volume to IPC protocol (c3-104 + c3-201)

Stream: [Node.js first] → [Go] → [Integration]

- Reply `go` to proceed
- Reply `adjust` to modify plan
- Reply `skip` to pick different task

flowchart LR
    subgraph Node["Node.js Stream"]
        N1[Commands] --> N2[Socket]
    end

    subgraph Go["Go Stream"]
        G1[Handler] --> G2[Encoder]
    end

    subgraph Int["Integration"]
        I1[Protocol] --> I2[E2E Test]
    end

    Node --> Int
    Go --> Int

## Verification: T001 - Add /volume command

### C3 Compliance
✅ Follows c3-101 Discord Bot interface
✅ Pattern matches existing commands

### Build
✅ Node.js compiles without errors
⬜ Go compiles without errors (if applicable)

### Quality
✅ Type safe (no `any`)
✅ Lint passes
⬜ Tests pass (if applicable)

**Result**: PASS ✅ / FAIL ❌

## T001 - Add /volume command handler

**State**: done ✅
**Completed**: 2026-02-02
**C3 Component**: c3-101 Discord Bot
**Layer**: Node.js

### What Was Done
- Created `node/src/commands/volume.ts`
- Added volume command type to socket commands
- Followed c3-101 pattern from C3 docs

### Verification
- TypeScript: ✅ compiles
- Pattern: ✅ matches c3-101 interface
- Lint: ✅ passes

✅ Task T001 complete! (c3-101 Discord Bot)

Next pending task: T002 - Add volume to FFmpeg (c3-203 Go)
Continue? (yes/no/pick different)

flowchart TB
    subgraph Streams["Task Streams"]
        subgraph NodeStream["Node.js Stream"]
            N1[c3-101 Tasks]
            N2[c3-102 Tasks]
            N3[c3-103 Tasks]
            N4[c3-104 Tasks]
        end

        subgraph GoStream["Go Stream"]
            G1[c3-201 Tasks]
            G2[c3-202 Tasks]
            G3[c3-203 Tasks]
            G4[c3-204 Tasks]
        end

        subgraph IntStream["Integration Stream"]
            I1[Protocol Tasks]
            I2[E2E Tasks]
        end
    end

    NodeStream --> IntStream
    GoStream --> IntStream

✅ Good for parallel (different layers):
- Node.js Stream  ➜ c3-101 command (T001)
- Go Stream       ➜ c3-203 encoder (T002)

❌ Bad for parallel (cross-layer dependencies):
- T003 (Integration) depends on T001 (Node.js) + T002 (Go)
  -> Must wait for both streams to complete