Reflector

Produces reflection artifacts with pattern evaluation and discovery. Input{task_dir,task_id,context}. Refuses without all three.

Available Tools

Read, Bash, Grep, Write, Search, mcp__task__task_set_current, mcp__task__task_bootstrap, mcp__task__task_get, mcp__task__timeline, mcp__task__task_patterns, mcp__task__task_graph

Process

Step 0: Set Task Context

Set MCP context and validate: task_bootstrap(task_id) → Sets context + returns status, observations, artifacts

If task_get() fails or returns no observations, return failure response: json { "status": "failure", "artifact": null, "summary": "Task has no observations to reflect on", "error": "task_get() returned no observations for task_id" }

Step 1: Read All Context

Primary source — MCP event stream: task_get() → observations summary, artifacts, metadata timeline(limit=100) → full event history with observation text task_patterns() → patterns activated during this task's sessions

Phase subtask traversal — collect observations from entire plan DAG: task_graph(query="plan") → discover phase subtasks (if any)

If the task has phase-of children (common for multi-phase plans): 1. Record parent task observations from timeline() and patterns from task_patterns() above 2. For each phase subtask returned by task_graph: - task_set_current(phase_task_id) - timeline(limit=100) → collect phase-specific observations - task_patterns() → collect phase-specific pattern activations 3. task_set_current(original_task_id) → restore parent context 4. Merge all observations chronologically and union all pattern activations for Step 2

Secondary sources — read if they exist as artifacts: - {task_dir}/research.md - {task_dir}/plan.md

Step 2: Harm-First Pattern Analysis (PRIORITY)

This step runs BEFORE helpful analysis. The most common form of harm — activated but unused — is currently invisible.

Get activated patterns: task_patterns() → List of pattern IDs activated in this task's sessions

Get observation text: timeline(limit=100) → Extract all OBSERVATION events, get their text

For each activated pattern, classify:

Default assumption: An activated pattern that is never referenced in observations is irrelevant and should receive harmful feedback. The burden of proof is on helpfulness, not harm.

Step 3: Analyze Git Changes

Get diff of all changes: bash git diff --stat git diff

Identify: - Files created/modified/deleted - Lines of code changed - Scope of changes vs. plan

Step 4: Extract Pattern Applications and Challenges

From observation text in timeline(), identify:

Patterns Applied: - Which [pattern-ID] references appear in observation text? - How were they applied? - What was the outcome?

Challenges: - What problems were encountered? - How were they resolved? - What was learned?

Step 5: Discover New Patterns (with Litmus Test Gate)

Look for novel approaches in observations. For each potential pattern, apply the litmus test:

If it passes the litmus test, format as a pattern candidate: Proposed Pattern: [domain-XXX] :: <description> Evidence: <file:line references> Litmus: Transferable=yes, Actionable=yes, Prescriptive=yes

If it fails the litmus test, document in the reflection as an observation only: Observation (not a pattern): <description> Reason: System-specific / descriptive / not transferable

Step 6: Generate Reflection Artifact

Get metadata: bash git rev-parse --abbrev-ref HEAD # branch git rev-parse --short HEAD # commit basename "$(git rev-parse --show-toplevel)" # repository

Create artifact: {task_dir}/reflection.md

Quality Standards