feat(taskctl): [EPIC] Autonomous task pipeline — Composer + Pulse + developer loop

[randomm]

Overview

This epic tracks the full implementation of taskctl — an autonomous task pipeline built directly into our OpenCode fork. The goal is for PM to hand a GitHub issue to taskctl start and receive incremental notifications as subtasks complete, without manually coordinating any agents in between.

The Problem Today

• PM must manually coordinate every agent handoff (spawn developer → wait → check adversarial → retry → commit)
• Workflow state lives in PM's context window — session death or context compaction loses all progress
• PM has to parse string patterns like "Adversarial: APPROVED" as quality gates
• PM must remember to start newly-unblocked tasks as dependencies complete

The Solution

A six-agent autonomous pipeline:

1. Composer — LLM that reads a GitHub issue, validates the spec, and decomposes it into a dependency-ordered list of tasks stored on disk
2. Pulse — deterministic TypeScript loop (not an LLM) that fires every 5 seconds and owns scheduling, heartbeat, timeout detection, steering evaluation, and completion notification
3. Developer — implements a single task in an isolated git worktree (simplified — no longer manages adversarial or commits)
4. Adversarial — reviews the developer's work and writes a structured JSON verdict directly to the task store (no longer returns text to PM)
5. Steering agent — lightweight LLM spawned by Pulse every 15 minutes to assess whether a stuck developer needs guidance or replacement
6. @ops — called by Pulse to commit approved work to the feature branch

What PM does after this is built

PM: taskctl start 201        → Composer decomposes, Pulse starts
PM: [receives incremental notifications as tasks complete]
PM: taskctl status 201       → live dashboard at any time
PM: @ops → gh pr create      → only after pipeline reports completion

Implementation issues (in order)

• feat(taskctl): Phase 1 — Task store: types, storage, scheduler, validation, CRUD tool #202 — Phase 1: Task store (types, storage, scheduler, validation, CRUD tool)
• feat(taskctl): Phase 2 — Composer agent: spec validation and task decomposition #203 — Phase 2: Composer agent (spec validation, decomposition, job start)
• feat(taskctl): Phase 3a — Pulse core loop: heartbeat, scheduling, singleton lock, crash recovery #204 — Phase 3a: Pulse core loop (heartbeat, scheduling, singleton lock, crash recovery)
• feat(taskctl): Phase 3b — Developer + adversarial pipeline: verdict tool, retry loop, @ops commit #205 — Phase 3b: Developer + adversarial pipeline (verdict tool, retry loop, @ops commit)
• feat(taskctl): Phase 3c — PM-facing commands: status, stop, resume, override, retry, inspect #206 — Phase 3c: PM-facing commands (status, stop, resume, override, retry, inspect)
• feat(taskctl): Phase 4 — Steering agent + timeout recovery #207 — Phase 4: Steering agent + timeout recovery
• feat(taskctl): Phase 5 — PM prompt migration and agent definitions into codebase #208 — Phase 5: PM prompt migration + agent definitions moved into codebase

Reference

Full design: lievo/plan-v2.md in the repository (git-ignored, local only).
Key OpenCode integration points: Session.createNext(), SessionPrompt.prompt(), BackgroundTaskEvent, src/worktree/index.ts, Agent.state(), Tool.define().