tasks

## Runtime Configuration (Step 0 — before any processing)

Read these files to configure domain-specific behavior:

1. **`ops/derivation-manifest.md`** — vocabulary mapping
   - Use `vocabulary.notes` for the notes folder name
   - Use `vocabulary.note` / `vocabulary.note_plural` for note type references
   - Use `vocabulary.topic_map` for MOC references
   - Use `vocabulary.cmd_reflect` / `vocabulary.cmd_reweave` / `vocabulary.cmd_verify` for phase command names

2. **`ops/config.yaml`** — pipeline chaining mode, automation settings

If no derivation file exists, use universal terms.

---

## EXECUTE NOW

**Target: $ARGUMENTS**

Parse the operation:
- No arguments or `status`: show task stack + queue state (combined view)
- `add [description]`: add a task to the stack
- `done [task-number]`: mark a task as completed
- `drop [task-number]`: remove a task without completing
- `reorder [number] [position]`: move a task to a different position in the stack
- `discoveries`: show only the Discoveries section

**START NOW.** Execute the requested operation.

---

## Philosophy

**Two systems, one view.**

The task stack (`ops/tasks.md`) and the pipeline queue (`ops/queue/queue.yaml` or `ops/queue/queue.json`) serve different purposes:

| System | Purpose | Managed By | Updated By |
|--------|---------|-----------|------------|
| Task stack | Human priorities — what YOU want to work on | You (via /tasks) | Manual: /tasks add, /tasks done |
| Pipeline queue | Automated processing state — what the SYSTEM needs to process | Pipeline skills | Automatic: /reduce, /ralph, /reflect |

/tasks shows BOTH so you always have a unified view of all pending work. The task stack is your working memory. The pipeline queue is the system's working memory. Together they answer: "What should I do next?"

---

## Operations

### /tasks (or /tasks status)

Show both the human task stack and the automated queue.

**Step 1: Read task stack**

```bash
# Read ops/tasks.md
cat ops/tasks.md 2>/dev/null
```

Parse the task stack into sections:
- **Current** (or Active): items marked `- [ ]`
- **Completed**: items marked `- [x]`
- **Discoveries**: items noted during work (plain text, no checkbox)

If `ops/tasks.md` does not exist, note: "No task stack found. Run `/tasks add [description]` to create one."

**Step 2: Read queue state**

```bash
# Check for queue file (YAML or JSON)
if [[ -f "ops/queue/queue.yaml" ]]; then
  QUEUE_FILE="ops/queue/queue.yaml"
  PENDING_TASKS=$(grep -c 'status: pending' "$QUEUE_FILE" 2>/dev/null || echo 0)
  DONE_TASKS=$(grep -c 'status: done' "$QUEUE_FILE" 2>/dev/null || echo 0)
elif [[ -f "ops/queue/queue.json" ]]; then
  QUEUE_FILE="ops/queue/queue.json"
  PENDING_TASKS=$(grep -c '"status": "pending"' "$QUEUE_FILE" 2>/dev/null || echo 0)
  DONE_TASKS=$(grep -c '"status": "done"' "$QUEUE_FILE" 2>/dev/null || echo 0)
else
  QUEUE_FILE=""
  PENDING_TASKS=0
  DONE_TASKS=0
fi
```

If a queue file exists, extract pending task details:
- Task ID
- Current phase
- Target (note title)
- Batch name

**Step 3: Check for archivable batches**

A batch is archivable when ALL its tasks have `status: done`:

```bash
# For each unique batch in the queue, check if all tasks are done
if [[ -n "$QUEUE_FILE" ]]; then
  # Extract unique batch names
  # Check each batch: are all tasks done?
  # Report archivable batches
fi
```

**Step 4: Present combined view**

```
--=={ tasks }==--

  Task Stack (ops/tasks.md)
  =========================
  Current:
    1. [ ] {task description}
    2. [ ] {task description}
    3. [ ] {task description}

  Completed:
    - [x] {task description} (2026-02-10)
    - [x] {task description} (2026-02-08)

  Discoveries:
    - {discovery noted during work}

  Pipeline Queue
  ==============
  Pending: {count} tasks
    - {task-id}: {current_phase} — {target title} (batch: {batch})
    - {task-id}: {current_phase} — {target title} (batch: {batch})
    ...

  Done: {count} tasks
  Archivable batches: {list of batch names where all tasks are done}

  Summary: {total current} tasks on stack, {queue pending} in pipeline
```

**Interpretation notes:**

| Condition | Note |
|-----------|------|
| Task stack empty | "No tasks on stack. Use `/tasks add [description]` to add one, or `/next` for suggestions." |
| Pipeline has pending tasks | "Pipeline has {N} pending tasks. Run /ralph to process them." |
| Archivable batches exist | "Batch '{name}' is ready to archive. Run /archive-batch {name}." |
| Both empty | "All clear. Use `/next` to find what to work on." |

### /tasks add [description]

Add a new task to the task stack.

**Step 1: Read current ops/tasks.md**

If the file does not exist, create it with the standard structure:

```markdown
# Task Stack

## Current

## Completed

## Discoveries
```

**Step 2: Add to Current section**

Append the new task as a checkbox item at the END of the Current section:

```markdown
- [ ] {description}
```

**Step 3: Write updated file**

Use Edit tool to insert the new item at the end of the Current section, preserving existing content.

**Step 4: Report**

```
Added to task stack: {description}
Position: #{N} of {total}

Stack now has {total} current tasks.
```

### /tasks done [number]

Mark a task as completed.

**Step 1: Read current ops/tasks.md**

Parse the Current section to find the Nth task.

**Step 2: Validate**

If the number is out of range (< 1 or > number of current tasks):
```
Error: Task #{number} does not exist. Current tasks: 1-{max}.
```

**Step 3: Move to Completed**

1. Remove the item from Current section
2. Add to Completed section with today's date:
   ```markdown
   - [x] {description} ({YYYY-MM-DD})
   ```
3. Renumber remaining Current items (if display uses numbers)

**Step 4: Write updated file**

**Step 5: Report**

```
Completed: {description}

Remaining: {N} current tasks.
```

**Integration with /next:** If the completed task was the top-priority item, suggest: "Top task completed. Run `/next` for the next recommendation