backbay-labs/thrunt-god

<objective>
Display the complete THRUNT command reference.

Output ONLY the reference content below. Do NOT add:
- Project-specific analysis
- Git status or file context
- Next-step suggestions
- Commentary beyond the reference
</objective>

<execution_context>
@.github/thrunt-god/workflows/hunt-help.md
</execution_context>

<objective>
Create or refresh the environment map for this hunt program or case.

**Creates or updates:**
- `.planning/environment/ENVIRONMENT.md`
- `.planning/MISSION.md`
- `.planning/HYPOTHESES.md`
- `.planning/STATE.md`

Unknown tenants, tools, retention windows, access paths, and blind spots must remain `TBD` until the operator confirms them.
Confirmed environment facts should replace existing `TBD` markers immediately; only unresolved fields should stay `TBD`.

**After this command:** Run `/hunt-shape-hypothesis` or `/hunt-plan 1`.
</objective>

<context>
**Flags:**
- `--auto` - Use the supplied signal brief as the starting point and ask only for missing critical facts.
- `--pack <id>` - Bootstrap the case from a built-in or local hunt pack. Use `thrunt-tools pack bootstrap <id>` to inspect the generated mission, hypothesis, and phase seed content.
</context>

<objective>
Initialize a threat hunting case.

These hunt-native artifacts are the source of truth for the case.

**Creates:**
- `.planning/config.json`
- `.planning/MISSION.md`

<context>
**Flags:**
- `--auto` - Use the provided brief as the primary source of truth and ask only for missing critical facts.
</context>

<objective>
Initialize a threat hunting program.

These hunt-native artifacts are the source of truth for the program.

**Creates:**
- `.planning/config.json`
- `.planning/MISSION.md`
- `.planning/HYPOTHESES.md`

<objective>
Plan a hunt phase from the current HUNTMAP.

`HUNTMAP.md` remains the source of truth for phase layout and sequencing.

**Creates or updates:**
- `.planning/phases/[phase-slug]/`
- `CONTEXT.md`
- `PLAN.md` files
- `.planning/STATE.md`
- `.planning/HUNTMAP.md` when phase metadata changes

**After this command:** Run `/hunt-run <phase>`.
</objective>

<objective>
Publish the current hunt in the right format for action.

**Creates or updates:**
- `.planning/published/*.md`
- `.planning/STATE.md`

**After this command:** Route to follow-on hunting, escalation, or detection engineering based on the outcome.
</objective>

<execution_context>
@.github/thrunt-god/workflows/hunt-publish.md
</execution_context>

<objective>
Execute a hunt phase.

Documented flags are available behaviors, not implied active behaviors.
Treat `--wave N`, `--gaps-only`, and `--interactive` as active only when the literal token appears in `$ARGUMENTS`.
If none of these tokens appear, run the standard full-phase execution flow.

The execution boundary is the shared THRUNT runtime contract:
- each material hunt action is shaped as a `QuerySpec`
- connectors return one normalized result envelope
- query logs and receipts are emitted from runtime metadata, not connector-specific ad hoc blobs
- connector-backed execution can be inspected locally with `thrunt-tools runtime list-connectors`, `thrunt-tools runtime doctor`, `thrunt-tools runtime smoke`, `thrunt-tools pack render-targets`, and `thrunt-tools runtime execute`

`--wave N` executes only a single wave and must not mark the whole phase complete until no incomplete plans remain.

<objective>
Refine the active signal into testable hunt hypotheses.

`HYPOTHESES.md`, `SUCCESS_CRITERIA.md`, and `HUNTMAP.md` remain the source of truth.

**Updates:**
- `.planning/HYPOTHESES.md`
- `.planning/SUCCESS_CRITERIA.md`
- `.planning/HUNTMAP.md`
- `.planning/STATE.md`

**After this command:** Run `/hunt-plan 1` or `/hunt-run 1` if plans already exist.
</objective>

<objective>
Validate the current hunt's findings.

`FINDINGS.md` and `EVIDENCE_REVIEW.md` remain the source of truth for validation.

**Creates or updates:**
- `.planning/FINDINGS.md`
- `.planning/EVIDENCE_REVIEW.md`
- `.planning/STATE.md`

**After this command:** Run `/hunt-publish`.
</objective>

<execution_context>

<objective>
Add a backlog item to the huntmap using 999.x numbering. Backlog items are
unsequenced ideas that aren't ready for active planning — they live outside
the normal phase sequence and accumulate context over time.
</objective>

<process>

1. **Read HUNTMAP.md** to find existing backlog entries:
   ```bash
   cat .planning/HUNTMAP.md
   ```

<objective>
Add a new integer phase to the end of the current milestone in the huntmap.

Routes to the add-phase workflow which handles:
- Phase number calculation (next sequential integer)
- Directory creation with slug generation
- Huntmap structure updates
- STATE.md huntmap evolution tracking
</objective>

<execution_context>
@.github/thrunt-god/workflows/add-phase.md
</execution_context>

<objective>
Generate unit and E2E tests for a completed phase, using its SUMMARY.md, CONTEXT.md, and FINDINGS.md as specifications.

Analyzes implementation files, classifies them into TDD (unit), E2E (browser), or Skip categories, presents a test plan for user approval, then generates tests following RED-GREEN conventions.

Output: Test files committed with message `test(phase-{N}): add unit and E2E tests from add-tests command`
</objective>

<execution_context>
@.github/thrunt-god/workflows/add-tests.md
</execution_context>

<context>
Phase: $ARGUMENTS

<objective>
Capture an idea, task, or issue that surfaces during a THRUNT session as a structured todo for later work.

Routes to the add-todo workflow which handles:
- Directory structure creation
- Content extraction from arguments or conversation
- Area inference from file paths
- Duplicate detection and resolution
- Todo file creation with frontmatter
- STATE.md updates
- Git commits
</objective>

<objective>
Scan all phases for pending, skipped, blocked, and human_needed Evidence Review items. Cross-reference against codebase to detect stale documentation. Produce prioritized human test plan.
</objective>

<execution_context>
@.github/thrunt-god/workflows/audit-evidence.md
</execution_context>

<context>
Core planning files are loaded in-workflow via CLI.

**Scope:**
Glob: .planning/phases/*/*-EVIDENCE_REVIEW.md
Glob: .planning/phases/*/*-FINDINGS.md

<objective>
Verify milestone achieved its definition of done. Check requirements coverage, cross-phase integration, and end-to-end flows.

**This command IS the orchestrator.** Reads existing FINDINGS.md files (phases already verified during hunt-run), aggregates tech debt and deferred gaps, then spawns integration checker for cross-phase wiring.
</objective>

<execution_context>
@.github/thrunt-god/workflows/audit-milestone.md
</execution_context>

<context>
Version: $ARGUMENTS (optional — defaults to current milestone)

Core planning files are resolved in-workflow (`init milestone-op`) and loaded only as needed.

<objective>
Execute all remaining milestone phases autonomously. For each phase: discuss → plan → execute. Pauses only for user decisions (grey area acceptance, blockers, validation requests).

Uses HUNTMAP.md phase discovery and Skill() flat invocations for each phase command. After all phases complete: milestone audit → complete → cleanup.

**Creates/Updates:**
- `.planning/STATE.md` — updated after each phase
- `.planning/HUNTMAP.md` — progress updated after each phase
- Phase artifacts — CONTEXT.md, PLANs, SUMMARYs per phase

**After:** Milestone is complete and cleaned up.
</objective>

<execution_context>

<objective>
List all pending todos, allow selection, load full context for the selected todo, and route to appropriate action.

Routes to the check-todos workflow which handles:
- Todo counting and listing with area filtering
- Interactive selection with full context loading
- Huntmap correlation checking
- Action routing (work now, add to phase, brainstorm, create phase)
- STATE.md updates and git commits
</objective>

<execution_context>
@.github/thrunt-god/workflows/check-todos.md

<objective>
Archive phase directories from completed milestones into `.planning/milestones/v{X.Y}-phases/`.

Use when `.planning/phases/` has accumulated directories from past milestones.
</objective>

<execution_context>
@.github/thrunt-god/workflows/cleanup.md
</execution_context>

<process>
Follow the cleanup workflow at @.github/thrunt-god/workflows/cleanup.md.
Identify completed milestones, show a dry-run summary, and archive on confirmation.
</process>

<objective>
Mark milestone {{version}} complete, archive to milestones/, and update HUNTMAP.md and HYPOTHESES.md.

Purpose: Create historical record of published version, archive milestone artifacts (huntmap + requirements), and prepare for next milestone.
Output: Milestone archived (huntmap + requirements), MISSION.md evolved, git tagged.
</objective>

<execution_context>
**Load these files NOW (before proceeding):**

- @.github/thrunt-god/workflows/complete-milestone.md (main workflow)
- @.github/thrunt-god/templates/milestone-archive.md (archive template)
  </execution_context>

<objective>
Debug issues using scientific method with subagent isolation.

**Orchestrator role:** Gather symptoms, spawn thrunt-incident-debugger agent, handle checkpoints, spawn continuations.

**Why subagent:** Investigation burns context fast (reading files, forming hypotheses, testing). Fresh 200k context per investigation. Main context stays lean for user interaction.
</objective>

<available_agent_types>
Valid THRUNT subagent types (use exact names — do not fall back to 'general-purpose'):
- thrunt-incident-debugger — Diagnoses and fixes issues
</available_agent_types>

<objective>
Analyze freeform natural language input and dispatch to the most appropriate hunt or THRUNT command.

Acts as a smart dispatcher — never does the work itself. Matches intent to the best command using routing rules, confirms the match, then hands off.

Use when you know what you want but don't know which `/thrunt:*` or `/hunt:*` command to run.
</objective>

<execution_context>
@.github/thrunt-god/workflows/do.md
@.github/thrunt-god/references/ui-brand.md
</execution_context>

<context>

<objective>
Execute a trivial task directly in the current context without spawning subagents
or generating PLAN.md files. For tasks too small to justify planning overhead:
typo fixes, config changes, small refactors, forgotten commits, simple additions.

This is NOT a replacement for /thrunt-quick — use /thrunt-quick for anything that
needs research, multi-step planning, or findings validation. /thrunt-fast is for tasks
you could describe in one sentence and execute in under 2 minutes.
</objective>

<execution_context>
@.github/thrunt-god/workflows/fast.md
</execution_context>

<objective>
Investigate what went wrong during a THRUNT workflow execution. Analyzes git history, `.planning/` artifacts, and file system state to detect anomalies and generate a structured diagnostic report.

Purpose: Diagnose failed or stuck workflows so the user can understand root cause and take corrective action.
Output: Forensic report saved to `.planning/forensics/`, presented inline, with optional issue creation.
</objective>

<execution_context>
@.github/thrunt-god/workflows/forensics.md
</execution_context>

<context>
**Data sources:**

<objective>
Validate `.planning/` directory integrity and report actionable issues. Checks for missing files, invalid configurations, inconsistent state, and orphaned plans.
</objective>

<execution_context>
@.github/thrunt-god/workflows/health.md
</execution_context>

<process>
Execute the health workflow from @.github/thrunt-god/workflows/health.md end-to-end.
Parse --repair flag from arguments and pass to workflow.
</process>

<objective>
Display the complete THRUNT command reference.

Output ONLY the reference content below. Do NOT add:
- Project-specific analysis
- Git status or file context
- Next-step suggestions
- Any commentary beyond the reference
</objective>

<execution_context>
@.github/thrunt-god/workflows/help.md
</execution_context>

<objective>
Insert a decimal phase for urgent work discovered mid-milestone that must be completed between existing integer phases.

Uses decimal numbering (72.1, 72.2, etc.) to preserve the logical sequence of planned phases while accommodating urgent insertions.

Purpose: Handle urgent work discovered during execution without renumbering entire huntmap.
</objective>

<execution_context>
@.github/thrunt-god/workflows/insert-phase.md
</execution_context>

<context>

<objective>
Display the current THRUNT community entry points.
</objective>

<output>
# THRUNT Community

Connect with other THRUNT users, get help, share what you're building, and stay updated.

**Discord invite:**
https://discord.gg/zTegcebS
</output>

<objective>
Analyze a phase and present the agent's assumptions about technical approach, implementation order, scope boundaries, risk areas, and dependencies.

Purpose: Help users see what the agent thinks BEFORE planning begins - enabling course correction early when assumptions are wrong.
Output: Conversational output only (no file creation) - ends with "What do you think?" prompt
</objective>

<execution_context>
@.github/thrunt-god/workflows/list-phase-assumptions.md
</execution_context>

<context>
Phase number: $ARGUMENTS (required)

<objective>
Scan `~/thrunt-workspaces/` for workspace directories containing `WORKSPACE.md` manifests. Display a summary table with name, path, repo count, strategy, and THRUNT project status.
</objective>

<execution_context>
@.github/thrunt-god/workflows/list-workspaces.md
@.github/thrunt-god/references/ui-brand.md
</execution_context>

<process>
Execute the list-workspaces workflow from @.github/thrunt-god/workflows/list-workspaces.md end-to-end.
</process>

<objective>
Single-terminal command center for managing a milestone or hunt campaign. Shows a dashboard of all phases with visual status indicators, recommends optimal next actions, and dispatches work. In hunt mode that means shape/plan/run; in THRUNT utility mode it means management, audit, and workspace flows.

Designed for power users who want to parallelize work across phases from one terminal: shape or discuss a phase while another plans or runs in the background.

**Creates/Updates:**
- No files created directly — dispatches to existing hunt or THRUNT commands and background Task agents.
- Reads `.planning/STATE.md`, `MISSION.md`, `HUNTMAP.md`, and phase directories for status.

**After:** User exits when done managing, or all phases complete and the appropriate publish/verify lifecycle is suggested.
</objective>

<execution_context>
@.github/thrunt-god/workflows/manager.md

<objective>
Generate a structured milestone summary for team onboarding and project review. Reads completed milestone artifacts (HUNTMAP, HYPOTHESES, CONTEXT, SUMMARY, VERIFICATION files) and produces a human-friendly overview of what was built, how, and why.

Purpose: Enable new team members to understand a completed project by reading one document and asking follow-up questions.
Output: MILESTONE_SUMMARY written to `.planning/reports/`, presented inline, optional interactive Q&A.
</objective>

<execution_context>
@.github/thrunt-god/workflows/milestone-summary.md
</execution_context>

<context>
**Project files:**

<context>
**Flags:**
- `--name` (required) — Workspace name
- `--repos` — Comma-separated repo paths or names. If omitted, interactive selection from child git repos in cwd
- `--path` — Target directory. Defaults to `~/thrunt-workspaces/<name>`
- `--strategy` — `worktree` (default, lightweight) or `clone` (fully independent)
- `--branch` — Branch to checkout. Defaults to `workspace/<name>`
- `--auto` — Skip interactive questions, use defaults
</context>

<objective>
Create a physical workspace directory containing copies of specified git repos (as worktrees or clones) with an independent `.planning/` directory for isolated THRUNT sessions.

**Use cases:**

<objective>
Detect the current project or hunt state and automatically invoke the next logical workflow step.
No arguments needed — reads `STATE.md`, `MISSION.md`, `HUNTMAP.md`, and phase directories to determine what comes next.

Designed for rapid multi-project workflows where remembering which phase/step you're on is overhead.
</objective>

<execution_context>
@.github/thrunt-god/workflows/next.md
</execution_context>

<process>
Execute the next workflow from @.github/thrunt-god/workflows/next.md end-to-end.
</process>

<objective>
Zero-friction idea capture — one Write call, one confirmation line.

Three subcommands:
- **append** (default): Save a timestamped note file. No questions, no formatting.
- **list**: Show all notes from project and global scopes.
- **promote**: Convert a note into a structured todo.

Runs inline — no Task, no AskUserQuestion, no Bash.
</objective>

<execution_context>
@.github/thrunt-god/workflows/note.md
@.github/thrunt-god/references/ui-brand.md

<objective>
Create `.continue-here.md` handoff file to preserve complete work state across sessions.

Routes to the pause-work workflow which handles:
- Current phase detection from recent files
- Complete state gathering (position, completed work, remaining work, decisions, blockers)
- Handoff file creation with all context sections
- Git commit as WIP
- Resume instructions
</objective>

<execution_context>
@.github/thrunt-god/workflows/pause-work.md

<objective>
Create all phases necessary to close gaps identified by `/thrunt-audit-milestone`.

Reads MILESTONE-AUDIT.md, groups gaps into logical phases, creates phase entries in HUNTMAP.md, and offers to plan each phase.

One command creates all fix phases — no manual `/thrunt-add-phase` per gap.
</objective>

<execution_context>
@.github/thrunt-god/workflows/plan-milestone-gaps.md
</execution_context>

<context>
**Audit results:**

<objective>
Capture an idea that's too big for now but should surface automatically when the right
milestone arrives. Seeds solve context rot: instead of a one-liner in Deferred that nobody
reads, a seed preserves the full WHY, WHEN to surface, and breadcrumbs to details.

Creates: .planning/seeds/SEED-NNN-slug.md
Consumed by: /hunt-new-program (scans seeds and presents matches)
</objective>

<execution_context>
@.github/thrunt-god/workflows/plant-seed.md
</execution_context>

<objective>
Create a clean branch suitable for pull requests by filtering out .planning/ commits
from the current branch. Reviewers see only code changes, not THRUNT planning artifacts.

This solves the problem of PR diffs being cluttered with PLAN.md, SUMMARY.md, STATE.md
changes that are irrelevant to code review.
</objective>

<execution_context>
@.github/thrunt-god/workflows/pr-branch.md
</execution_context>

<process>

<objective>
Generate a developer behavioral profile from session analysis (or questionnaire) and produce artifacts (USER-PROFILE.md, /thrunt-dev-preferences, copilot-instructions.md section) that personalize the agent's responses.

Routes to the profile-user workflow which orchestrates the full flow: consent gate, session analysis or questionnaire fallback, profile generation, result display, and artifact selection.
</objective>

<execution_context>
@.github/thrunt-god/workflows/profile-user.md
@.github/thrunt-god/references/ui-brand.md
</execution_context>

<context>
Flags from $ARGUMENTS:

<objective>
Check project or hunt progress, summarize recent work and what's ahead, then intelligently route to the next action within the active hunt or THRUNT workflow.

Provides situational awareness before continuing work.
</objective>

<execution_context>
@.github/thrunt-god/workflows/progress.md
</execution_context>

<process>
Execute the progress workflow from @.github/thrunt-god/workflows/progress.md end-to-end.
Preserve the hunt-native routing plus the THRUNT utility branches and edge case handling.
</process>

<objective>
Execute small, ad-hoc tasks with THRUNT guarantees (atomic commits, STATE.md tracking).

Quick mode is the same system with a shorter path:
- Spawns thrunt-hunt-planner (quick mode) + thrunt-telemetry-executor(s)
- Quick tasks live in `.planning/quick/` separate from planned phases
- Updates STATE.md "Quick Tasks Completed" table (NOT HUNTMAP.md)

**Default:** Skips research, discussion, plan-checker, and findings validation. Use when you know exactly what to do.

**`--discuss` flag:** Lightweight discussion phase before planning. Surfaces assumptions, clarifies gray areas, captures decisions in CONTEXT.md. Use when the task has ambiguity worth resolving upfront.

**`--full` flag:** Enables plan-checking (max 2 iterations) and post-execution findings validation. Use when you want quality guarantees without full milestone ceremony.

<purpose>
After a THRUNT update wipes and reinstalls files, this command merges user's previously saved local modifications back into the new version. Uses intelligent comparison to handle cases where the upstream file also changed.
</purpose>

<process>

## Step 1: Detect backed-up patches

Check for local patches directory:

```bash
# Global install — detect runtime config directory
if [ -d "$HOME/.config/opencode/thrunt-local-patches" ]; then

<objective>
Remove an unstarted future phase from the huntmap and renumber all subsequent phases to maintain a clean, linear sequence.

Purpose: Clean removal of work you've decided not to do, without polluting context with cancelled/deferred markers.
Output: Phase deleted, all subsequent phases renumbered, git commit as historical record.
</objective>

<execution_context>
@.github/thrunt-god/workflows/remove-phase.md
</execution_context>

<context>
Phase: $ARGUMENTS

<context>
**Arguments:**
- `<workspace-name>` (required) — Name of the workspace to remove
</context>

<objective>
Remove a workspace directory after confirmation. For worktree strategy, runs `git worktree remove` for each member repo first. Refuses if any repo has uncommitted changes.
</objective>

<execution_context>
@.github/thrunt-god/workflows/remove-workspace.md
@.github/thrunt-god/references/ui-brand.md
</execution_context>

<objective>
Restore complete hunt context and resume the active workflow seamlessly from the previous session.

Routes to the resume-program workflow which handles:

- STATE.md loading (or reconstruction if missing)
- Checkpoint detection (.continue-here files)
- Incomplete work detection (PLAN without SUMMARY)
- Active planning doc detection (`MISSION.md`, `HUNTMAP.md`)
- Status presentation
- Context-aware next action routing into `/hunt:*` or `/thrunt:*`
  </objective>

<objective>
Invoke external AI CLIs (Gemini, the agent, Codex) to independently review phase plans.
Produces a structured REVIEWS.md with per-reviewer feedback that can be fed back into
planning via /hunt-plan --reviews.

**Flow:** Detect CLIs → Build review prompt → Invoke each CLI → Collect responses → Write REVIEWS.md
</objective>

<execution_context>
@.github/thrunt-god/workflows/review.md
</execution_context>

<context>

<objective>
Review all 999.x backlog items and optionally promote them into the active
milestone sequence or remove stale entries.
</objective>

<process>

1. **List backlog items:**
   ```bash
   ls -d .planning/phases/999* 2>/dev/null || echo "No backlog items found"
   ```

2. **Read HUNTMAP.md** and extract all 999.x phase entries:

<objective>
Generate a structured SESSION_REPORT.md document capturing session outcomes, work performed, and estimated resource usage. Provides a shareable artifact for post-session review.
</objective>

<execution_context>
@.github/thrunt-god/workflows/session-report.md
</execution_context>

<process>
Execute the session-report workflow from @.github/thrunt-god/workflows/session-report.md end-to-end.
</process>

Show the following output to the user verbatim, with no extra commentary:

!`node ".github/thrunt-god/bin/thrunt-tools.cjs" config-set-model-profile $ARGUMENTS --raw`

<objective>
Interactive configuration of THRUNT workflow agents and model profile via multi-question prompt.

Routes to the settings workflow which handles:
- Config existence ensuring
- Current settings reading and parsing
- Interactive settings prompt (model profile, research, plan checker, findings validator, branching, and workflow toggles)
- Config merging and writing
- Confirmation display with quick command references
</objective>

<execution_context>
@.github/thrunt-god/workflows/settings.md

<objective>
Display comprehensive project statistics including phase progress, plan execution metrics, hypotheses completion, git history stats, and project timeline.
</objective>

<execution_context>
@.github/thrunt-god/workflows/stats.md
</execution_context>

<process>
Execute the stats workflow from @.github/thrunt-god/workflows/stats.md end-to-end.
</process>

<objective>
Create, list, or resume persistent context threads. Threads are lightweight
cross-session knowledge stores for work that spans multiple sessions but
doesn't belong to any specific phase.
</objective>

<process>

**Parse $ARGUMENTS to determine mode:**

<mode_list>
**If no arguments or $ARGUMENTS is empty:**

<objective>
Create a UI design contract (UI-SPEC.md) for a frontend phase.
Orchestrates thrunt-ui-researcher and thrunt-ui-checker.
Flow: Validate → Research UI → Verify UI-SPEC → Done
</objective>

<execution_context>
@.github/thrunt-god/workflows/ui-phase.md
@.github/thrunt-god/references/ui-brand.md
</execution_context>

<context>
Phase number: $ARGUMENTS — optional, auto-detects next unplanned phase if omitted.
</context>

<objective>
Conduct a retroactive 6-pillar visual audit. Produces UI-REVIEW.md with
graded assessment (1-4 per pillar). Works on any project.
Output: {phase_num}-UI-REVIEW.md
</objective>

<execution_context>
@.github/thrunt-god/workflows/ui-review.md
@.github/thrunt-god/references/ui-brand.md
</execution_context>

<context>
Phase: $ARGUMENTS — optional, defaults to last completed phase.
</context>

<objective>
Check for THRUNT updates, install if available, and display what changed.

Routes to the update workflow which handles:
- Version detection (local vs global installation)
- npm version checking
- Changelog fetching and display
- User confirmation with clean install warning
- Update execution and cache clearing
- Restart reminder
</objective>

<execution_context>

<objective>
Audit Nyquist validation coverage for a completed phase. Three states:
- (A) VALIDATION.md exists — audit and fill gaps
- (B) No VALIDATION.md, SUMMARY.md exists — reconstruct from artifacts
- (C) Phase not executed — exit with guidance

Output: updated VALIDATION.md + generated test files.
</objective>

<execution_context>
@.github/thrunt-god/workflows/validate-phase.md
</execution_context>

<context>

# /thrunt-workstreams

Manage parallel workstreams for concurrent milestone work.

## Usage

`/thrunt-workstreams [subcommand] [args]`

### Subcommands

| Command | Description |
|---------|-------------|
| `list` | List all workstreams with status |