/collect - Result Aggregation Agent

/​collect - Result Aggregation Agent

Version: 4.0.0 | Model: opus Pipeline: /​worker -> [/​collect] -> /​synthesis EFL: P1-P6 Complete

---

1. Purpose

Result Aggregation Agent that:

1. Aggregates worker outputs from all terminals
2. Verifies task completion status via TaskList
3. Validates completion manifests (SHA256 integrity)
4. Detects blockers and incomplete work
5. Generates collection report for /​synthesis

---

2. Task API Integration

Collection Pattern

// Get all tasks for workload
const allTasks = TaskList()

// Categorize by status
const completed = allTasks.filter(t => t.status === "completed")
const inProgress = allTasks.filter(t => t.status === "in_progress")
const pending = allTasks.filter(t => t.status === "pending")
const blocked = allTasks.filter(t => t.blockedBy?.length > 0)

// Verify each completed task has outputs
for (const task of completed) {
  const outputs = await collectTaskOutputs(task)
  verifyIntegrity(outputs)
}

Multi-Source Collection

// Source 1: Task System
const taskResults = collectFromTasks()

// Source 2: Output Files
const fileResults = collectFromFiles(workloadSlug)

// Source 3: Git Commits (optional)
const gitResults = collectFromGit()

// Source 4: Session State
const sessionResults = collectFromSession()

// Merge and deduplicate
const allResults = mergeResults([taskResults, fileResults, gitResults, sessionResults])

---

3. Invocation

# Collect all results
/​collect

# Collect specific phase
/​collect --phase phase1

# Collect from specific sources
/​collect --from-session
/​collect --from-git

# Full collection with all sources
/​collect --all

---

4. Execution Protocol

Phase 1: Source Discovery

// Determine collection sources
const sources = {
  tasks: true,           // Always check TaskList
  files: true,           // Always check output files
  git: args.includes('--from-git'),
  session: args.includes('--from-session')
}

// Get active workload
const workloadSlug = getActiveWorkloadSlug()
const outputDir = `.agent/​prompts/​${workloadSlug}/​outputs`

Phase 2: Task Collection

// Collect from Native Task System
const tasks = TaskList()

for (const task of tasks) {
  const detail = TaskGet({taskId: task.id})

  taskResults.push({
    taskId: task.id,
    subject: task.subject,
    status: task.status,
    owner: task.owner,
    completedAt: detail.metadata?.completedAt,
    outputs: detail.metadata?.outputs || []
  })
}

Phase 3: File Collection

// Collect from output directories
const terminals = ['terminal-b', 'terminal-c', 'terminal-d']

for (const terminal of terminals) {
  const terminalDir = `${outputDir}/​${terminal}`
  const files = Glob(`${terminalDir}/​*.md`)

  for (const file of files) {
    const content = Read(file)
    fileResults.push({
      terminal: terminal,
      file: file,
      type: detectOutputType(file), // l1, l2, l3, manifest
      content: extractSummary(content)
    })
  }
}

Phase 4: Integrity Verification

// Verify completion manifests
for (const result of completedResults) {
  const manifestPath = `${outputDir}/​${result.terminal}/​task-${result.taskId}-manifest.yaml`

  if (fileExists(manifestPath)) {
    const manifest = parseYAML(Read(manifestPath))

    // Verify SHA256 hashes
    for (const output of manifest.outputs) {
      const actualHash = computeSHA256(Read(output.path))
      if (actualHash !== output.hash) {
        integrityErrors.push({
          task: result.taskId,
          file: output.path,
          expected: output.hash,
          actual: actualHash
        })
      }
    }
  }
}

Phase 5: Gap Detection

// Detect missing deliverables
const gaps = []

for (const task of tasks) {
  if (task.status === "completed") {
    // Check for expected outputs
    const expectedOutputs = getExpectedOutputs(task)
    const actualOutputs = getActualOutputs(task)

    const missing = expectedOutputs.filter(e =>
      !actualOutputs.some(a => a.type === e.type)
    )

    if (missing.length > 0) {
      gaps.push({ taskId: task.id, missing })
    }
  }
}

Phase 6: Report Generation

// Generate collection report
const report = `
# Collection Report

## Summary
- Total Tasks: ${tasks.length}
- Completed: ${completed.length}
- In Progress: ${inProgress.length}
- Pending: ${pending.length}

## Completion Status
${completed.map(t => `- [x] Task #${t.id}: ${t.subject}`).join('\n')}
${inProgress.map(t => `- [ ] Task #${t.id}: ${t.subject} (in progress)`).join('\n')}
${pending.map(t => `- [ ] Task #${t.id}: ${t.subject} (pending)`).join('\n')}

## Deliverables
${deliverables.map(d => `- ${d.file}: ${d.type}`).join('\n')}

## Integrity Check
${integrityErrors.length === 0
  ? '- All manifests verified'
  : integrityErrors.map(e => `- ERROR: ${e.file} hash mismatch`).join('\n')
}

## Gaps Detected
${gaps.length === 0
  ? '- No gaps detected'
  : gaps.map(g => `- Task #${g.taskId}: Missing ${g.missing.join(', ')}`).join('\n')
}

## Next Steps
${getNextSteps(completed, pending, gaps)}
`

Write({
  file_path: `.agent/​prompts/​${workloadSlug}/​collection_report.md`,
  content: report
})

---

5. Output Files

---

6. Collection Sources

---

7. Error Handling

---

8. Handoff Contract

handoff:
  skill: "collect"
  workload_slug: "{slug}"
  status: "completed"
  report_path: ".agent/​prompts/​{slug}/​collection_report.md"
  next_action:
    skill: "/​synthesis"
    arguments: "--workload {slug}"
    required: true
    reason: "Results collected, ready for traceability validation"

---

9. Version History

End of Skill Documentation