fennec-sprint

name: fennec-sprint description: Use when executing tasks, task groups, or missions from Fennec's DB. Triggers on "execute task", "run the group", "start mission", "work on these tasks", "dispatch agents". Covers full lifecycle from reading tasks through agent dispatch to status updates. All state in Fennec DB. Replaces markdown-file-based sprint-executor.

Fennec Sprint Executor

Overview

Execute planned work from Fennec's database with full lifecycle discipline. Read tasks first. Dispatch agents or work manually. Verify against acceptance criteria. Update all statuses. Everything goes through fennec_execute MCP tool — no local markdown files.

When to Use

• User says "execute", "run", "dispatch", "start" referencing tasks, task groups, or missions
• User wants to kick off agent execution for planned work
• User says "pick up where we left off" or "what's next"
• User wants to monitor running agents or check execution status

Do NOT use for: creating plans (use fennec-planning), research/exploration, or code review.

The Five Phases

RECON → PLAN → EXECUTE → VERIFY → CLOSE

Every phase is mandatory. No skipping.

Phase 1: RECON (Read Everything)

Before touching any code, read all tasks in scope from Fennec's DB.

For a task group:

// Get the group and its tasks
const group = await fennec.taskGroups.get(groupId);
const tasks = await fennec.tasks.list({ projectId: group.projectId });
const groupTasks = tasks.filter(t => t.groupId === groupId);

// Check dependencies for each task
for (const task of groupTasks) {
  const deps = await fennec.tasks.getDependencies(task.id);
  // deps.dependsOn: tasks that must complete first
  // deps.dependedBy: tasks waiting on this one
}

For a mission:

// Get mission with milestones and events
const { mission, milestones, events } = await fennec.missions.get(missionId);

// For each milestone, check its task IDs
for (const milestone of milestones) {
  for (const taskId of milestone.taskIds) {
    const task = await fennec.tasks.get(taskId);
    // Read task details, acceptance criteria, dependencies
  }
}

For ad-hoc tasks:

// List open tasks for a project
const tasks = await fennec.tasks.list({ projectId, status: "open" });

// Check which are ready (no unmet dependencies)
for (const task of tasks) {
  const deps = await fennec.tasks.getDependencies(task.id);
  const blocked = deps.dependsOn.some(d => d.status !== "done");
  // task is ready if !blocked
}

Output of RECON:

After reading, you MUST know:

• Which tasks are independent (can run in parallel)
• Which tasks have unmet dependencies (must wait)
• What each task's acceptance criteria require
• Current status of all items

STOP if dependencies aren't met. If task X depends on task Y and Y isn't done, flag this to the user.

Phase 2: PLAN (Execution Strategy)

Decision flow:

Agent dispatch (automated):

// Execute a single task via agent pipeline
const result = await fennec.tasks.execute(taskId);
// Returns immediately (202): { taskId, status, sessionId?, streamUrl? }

// Monitor progress
const status = await fennec.tasks.getExecutionStatus(taskId);
// status: { taskId, status: "running"|"completed"|"failed", sessionId?, streamUrl? }

Task group execution (sequential, one PR):

const result = await fennec.taskGroups.execute(groupId);
// Returns immediately (202): { groupId, status: "executing", statusUrl }

Mission execution (milestone-based):

await fennec.missions.start(missionId);

// Monitor milestones
const milestones = await fennec.missions.listMilestones(missionId);
// Each milestone has: status, taskIds, validationResult

// Check events for detailed progress
const events = await fennec.missions.listEvents(missionId, 20);

Manual execution (you do the work):

If executing manually (no agent dispatch), mark the task in progress:

await fennec.tasks.update(taskId, { status: "in_progress" });

Then implement the work yourself, following the task description and acceptance criteria.

Phase 3: EXECUTE

For agent-dispatched tasks:

1. Dispatch: fennec.tasks.execute(taskId)
2. Poll status every 15-30 seconds: fennec.tasks.getExecutionStatus(taskId)
3. Wait for status === "completed" or status === "failed"
4. If failed, read the error, fix the issue, re-dispatch or implement manually

For manual tasks:

1. Mark in progress: fennec.tasks.update(taskId, { status: "in_progress" })
2. Read the task description and acceptance criteria
3. Implement the work
4. Build: pnpm exec turbo run build --filter="!@fennec/web"
5. Test: pnpm test --filter @fennec/<affected-package>

For task groups:

1. Dispatch: fennec.taskGroups.execute(groupId)
2. Monitor: poll individual task statuses
3. The executor handles sequencing, workspace isolation, and PR creation

For missions:

1. Start: fennec.missions.start(missionId)
2. Monitor milestones: fennec.missions.listMilestones(missionId)
3. The mission engine handles milestone validation, replan on failure, and follow-up tasks
4. Pause if needed: fennec.missions.pause(missionId)
5. Resume: fennec.missions.resume(missionId)

Phase 4: VERIFY

Hard gate. No task is done until acceptance criteria pass.

Per task:

1. Read the task's acceptance criteria from its description
2. For each criterion:
   • Verify it's met (run code, check output, inspect files)
   • If testable, run the test
3. Run full verification:

   pnpm exec turbo run build --filter="!@fennec/web"
   pnpm test --filter @fennec/<affected-packages>
   

4. If ANY criterion fails:
   • Fix the implementation
   • Re-verify
   • Do NOT proceed until all pass

For agent-executed tasks:

The agent pipeline includes a verification step (build + test in worktree). Check the execution status for verification results:

const status = await fennec.tasks.getExecutionStatus(taskId);
// If completed, the agent verified successfully
// If failed, check events for error details

For missions:

Each milestone has a validation step that runs build + test:

const milestones = await fennec.missions.listMilestones(missionId);
for (const m of milestones) {
  if (m.validationResult) {
    // m.validationResult: { passed, buildOutput?, testOutput?, errors?, warnings? }
  }
}

Phase 5: CLOSE (Update All Statuses)

Per completed task:

// Mark task done
await fennec.tasks.update(taskId, { status: "done" });

// Log what was accomplished
await fennec.decisions.log({
  projectId,
  title: `Completed: ${task.title}`,
  rationale: "Build passes, tests pass, acceptance criteria verified",
  context: `Task ${taskId} executed via agent/manual`
});

Per completed task group:

// Update group status (if not auto-updated by executor)
await fennec.taskGroups.update(groupId, { status: "completed" });

Per completed mission:

The mission engine auto-updates status. Verify:

const { mission } = await fennec.missions.get(missionId);
// mission.status should be "completed"
// mission.progress: { totalTasks, completedTasks, failedTasks }

Final sweep:

// Check for any tasks still not done
const remaining = await fennec.tasks.list({ projectId, status: "in_progress" });
if (remaining.length > 0) {
  // Flag these to the user — they were missed
}

// Report summary
const allTasks = await fennec.tasks.list({ projectId });
const done = allTasks.filter(t => t.status === "done").length;
const total = allTasks.length;
return `${done}/${total} tasks complete`;

Monitoring Cheat Sheet

// What's running right now?
const tasks = await fennec.tasks.list({ projectId, status: "in_progress" });

// Check a specific execution
const status = await fennec.tasks.getExecutionStatus(taskId);

// Cancel a stuck execution
await fennec.tasks.cancelExecution(taskId);

// Mission progress
const { mission } = await fennec.missions.get(missionId);
// mission.progress: { totalTasks, completedTasks, failedTasks, currentMilestone }

// Recent activity
const events = await fennec.activity.list({ projectId, limit: 20 });

Red Flags — STOP and Recheck

Quick Reference

RECON:   tasks.list + tasks.get + tasks.getDependencies + taskGroups.get
PLAN:    Decide: solo / tasks.execute / taskGroups.execute / missions.start / agent teams
EXECUTE: Dispatch + poll getExecutionStatus / implement manually + build + test
VERIFY:  Check acceptance criteria + build + test. Fix failures. Re-verify.
CLOSE:   tasks.update(status: "done") + decisions.log + check remaining