team-control

$npx mdskill add Tibsfox/gsd-skill-creator/team-control

Orchestrates autonomous mission control with human-in-the-loop for UC and Dev branches.

  • Prevents pipeline stalls by providing a human-in-the-loop automation layer.
  • Depends on Opus models for lab-director and flight-ops agents.
  • Selects mode based on active branch or explicit user invocation.
  • Delivers go/no-go decisions, plan approvals, and pipeline management.

SKILL.md

.github/skills/team-controlView on GitHub ↗
---
name: team-control
description: "Unit Circle Laboratory + sc-dev-team autonomous mission control. Provides human-in-the-loop automation layer, pipeline management, context lifecycle, stuck-state prevention. UC re-execution series and dev branch milestones. Adapted from uc-lab pattern for code plan/execute/verify/complete. Auto-activates during UC milestone work; trigger: user says 'bring up the dev team'."
format: 2025-10-02
version: 1.0.0
status: ACTIVE
updated: 2026-04-15
triggers:
  - during UC milestone work
  - user says 'bring up the dev team'
---

# Team Control — Autonomous Mission Control

Autonomous mission-control skill with two parameterized modes for the two team branches:

- **UC Mode** — Unit Circle Laboratory, v1.50 milestone review series (formerly `uc-lab`)
- **Dev Mode** — SC Dev Team, dev branch code execution (formerly `sc-dev-team`)

Both modes share the same four-agent architecture, autonomy principles, context management, and stuck-state prevention. The mode is selected by the active branch (UC on `v1.50`, Dev on `dev`) or by explicit invocation. Either way, the team acts as the human-in-the-loop layer so the pipeline never stalls waiting for decisions.

## Team Architecture (shared)

| Agent | Model | Role | Key Responsibility |
|-------|-------|------|-------------------|
| **lab-director** | Opus | Authority | Go/no-go, plan approval, quality rubric, strategic direction |
| **flight-ops** | Opus | Operations | Pipeline management, milestone/phase spawning, error handling |
| **capcom** | Sonnet | Communications | Context lifecycle, handoffs, warm starts, continuity |
| **watchdog** | Haiku | Monitor | Stuck detection, health checks, overload alerts |

Agent definitions: `.claude/agents/lab-director.md`, `flight-ops.md`, `capcom.md`, `watchdog.md`.

**Team pre-flight (topology check).** Before launching the team — spawning the four agents, or any larger fan-out flight-ops sizes up — run the `spectral-topology-preflight` skill on the proposed communication graph. It builds the row-stochastic operator from the team graph and emits a (ρ, Δ, κ) coordination signature plus a pass/fail verdict against per-task-class thresholds, so coordination defects are caught **pre-dispatch** rather than mid-run. Honor a fail verdict (adjust the topology) before flight-ops spawns work.

## Autonomy Principles (shared)

1. **lab-director IS the human** — no waiting for external approval
2. **Auto-approve** plans that pass quality gates (TDD, tests, NASA SE or clean commits)
3. **Auto-close** milestones when enforcement checks pass
4. **Auto-handoff** context when pressure detected (>80%)
5. **Auto-scale** parallelism based on observed metrics (UC Mode)
6. **Auto-heal** stuck states via watchdog detection + flight-ops resolution

## Context Management (shared)

- **Green (0-60%):** Normal operations
- **Yellow (60-80%):** Prepare handoff materials
- **Red (80%+):** Initiate handoff immediately
- Handoffs stored at `.planning/uc-observatory/handoffs/` (UC Mode) or repo-local (Dev Mode)
- STATE.md is always the source of truth

## Stuck State Prevention (shared)

| Pattern | Detection | Resolution |
|---------|-----------|------------|
| Waiting for user | Watchdog | lab-director decides |
| Context full | Capcom | Handoff protocol |
| Agent idle | Watchdog | flight-ops reassigns |
| Repeated failure | Watchdog | flight-ops escalates |
| Lost state | Capcom | Restore from handoff |

---

## UC Mode — Unit Circle Laboratory

Autonomous mission control for the Unit Circle re-execution series (v1.50.14+). Branch-bound to `v1.50`.

### Pipeline Flow

```
QUEUE → PRE-FLIGHT → INIT → PLAN → APPROVE → EXECUTE → VERIFY → ANALYZE → RETRO → CLOSE → HANDOFF → NEXT
  ↑                                                                                                    |
  +----------------------------------------------------------------------------------------------------+
```

### Quality Rubric (UC Mode, VERBATIM)

| Dimension | Weight | Min Score |
|-----------|--------|-----------|
| Completeness | 25% | 3.0 |
| Depth | 30% | 3.0 |
| Connections | 25% | 3.0 |
| Honesty | 20% | 3.0 |

Weighted average must be >= 3.0 for auto-approval.

### Integration with Observatory

The lab team coordinates with `uc-observatory` agents:

- **Pre-milestone:** Spawns uc-brainstorm-engine, uc-skill-forger
- **Post-milestone:** Spawns uc-perf-analyst, uc-proof-engineer, uc-retro-analyst
- **Between milestones:** Reviews observatory reports for strategic decisions

### Chipset & Files (UC Mode)

- Lab chipset: `.planning/uc-observatory/lab-chipset.yaml`
- Observatory chipset: `.planning/uc-observatory/chipset.yaml`
- Handoffs: `.planning/uc-observatory/handoffs/`
- Reports: `.planning/uc-observatory/reports/`
- Metrics: `.planning/uc-observatory/metrics/`

---

## Dev Mode — SC Dev Team

Autonomous execution team for dev branch milestones. Adapted from the UC pattern for code execution (plan/execute/verify/complete). Trigger: user says "bring up the dev team" or "sc-dev-team". Branch-bound to `dev`.

### Activation

1. Read `.planning/STATE.md` for current position
2. Read `~/.claude/teams/sc-dev-team/config.json` for team state
3. Check `TaskList` for pending work
4. Create team if not exists: `TeamCreate(team_name: "sc-dev-team")`
5. Spawn agents into team:
   - `flight-ops` (opus) — drives execution
   - `lab-director` (opus) — approves, unblocks
   - `capcom` (sonnet) — context management
   - `watchdog` (haiku) — health monitoring
6. Assign first pending task to flight-ops

### Pipeline Flow (Dev Mode)

```
STATE.md → PLAN PHASE → EXECUTE PHASE → VERIFY → NEXT PHASE → ... → COMPLETE MILESTONE
```

### Key Differences from UC Mode

- **Branch:** dev (not v1.50)
- **Work type:** Code execution (not review milestones)
- **GSD commands:** `/gsd:plan-phase`, `/gsd:execute-phase`, `/gsd:complete-milestone`
- **No observatory integration** (dev milestones don't use the UC review rubric)
- **Quality gate:** Tests pass + clean commits (not the review scoring rubric above)

### Team Files (Dev Mode)

- Team config: `~/.claude/teams/sc-dev-team/config.json`
- Tasks: `~/.claude/tasks/sc-dev-team/`

More from Tibsfox/gsd-skill-creator

SkillDescription
3d-interaction-designDesign heuristics for three-dimensional interaction — input modalities (6DoF controllers, gaze, gesture, voice), selection and manipulation techniques (ray-cast, virtual hand, go-go, world-in-miniature), navigation (teleport, continuous, redirected walking), and feedback loops (haptic, audio, visual). Covers Fitts' law in 3D, discoverability vs affordance, safe-zone design, and comfort/simulator sickness mitigation. Use when designing VR/AR interactions, immersive walkthroughs, or any input system where the user's body is the controller.
accessibility-patternsProvides web accessibility best practices for semantic HTML, ARIA, keyboard navigation, color contrast, and screen reader patterns. Use when building UI components, reviewing accessibility, or when user mentions 'a11y', 'accessibility', 'ARIA', 'screen reader', 'keyboard navigation', 'WCAG'.
active-listeningActive listening techniques for effective communication. Covers attending behaviors, paraphrasing, reflective listening, clarifying questions, empathic response, barriers to listening, listening in conflict, and cross-cultural listening. Use when building listening skills, improving understanding in conversation, mediating disputes, or analyzing communication breakdowns.
adversarial-pr-reviewAdversarial spec-compliance PR review — cross-references diffs against approved specs, verifies runtime claims against source, detects competing PRs, audits scope/convention compliance. Use before merging.
agile-methodsAgile and Lean software development methodologies for iterative, adaptive project execution. Covers Scrum (roles, ceremonies, artifacts), Kanban (WIP limits, flow metrics), XP (TDD, pair programming, CI), SAFe overview, Lean Software Development (Poppendieck's 7 principles), user stories (INVEST criteria), estimation via story points and velocity, and the Agile Manifesto's values and principles. Includes Cynefin framework for methodology selection and GSD's relationship to Agile as a structured Lean variant.
algebraic-reasoningSymbolic manipulation, equation solving, and algebraic structures for mathematical reasoning. Covers distributive law, factoring, completing the square, linear through polynomial equation solving, systems of equations (substitution, elimination, Gaussian elimination, matrix methods), algebraic structures (groups, rings, fields), modular arithmetic, polynomial theory, and inequalities. Use when solving equations, simplifying expressions, working with algebraic structures, or performing symbolic manipulation.
algorithmic-awarenessUnderstanding how algorithmic systems shape what users see, know, and do -- from recommendation feeds to search ranking to credit scoring to hiring software. Covers the mechanics of recommendation systems, algorithmic bias and its sources, personalization's effects on information diets, opacity and accountability, AI limitations (hallucination, confident wrongness), and the human-in-the-loop question. Use when a learner needs to think critically about why particular content reached them.
algorithms-data-structuresAlgorithms and data structures from first principles through advanced analysis. Covers sorting (bubble, insertion, selection, merge, quick, heap, radix), searching (linear, binary, BFS, DFS, Dijkstra, A*), fundamental data structures (arrays, linked lists, stacks, queues, hash tables, trees, heaps, graphs, tries), complexity analysis (Big-O, Big-Omega, Big-Theta, amortized), recurrence relations, and algorithm design paradigms (divide-and-conquer, greedy, dynamic programming, backtracking). Use when analyzing, selecting, implementing, or comparing algorithms and data structures.
aminet-browserAminet search and browse: full-text search, category tree navigation, architecture filtering, package detail, and curated collections. Use when searching, browsing, or managing package collections.
aminet-emulatorFS-UAE emulator configuration and launch: hardware profiles, ROM management, WHDLoad integration, config generation, and state snapshots. Use when configuring emulation, managing ROMs, or launching Amiga software.