name: ct description: Create technical task documentation for developer implementation in ETNA_TRADER. Use when asked to 'create task', 'technical decomposition', 'plan implementation', 'task documentation', or 'decompose feature'. NOT for feature discovery (use /nf), NOT for implementation (use /si), NOT for brainstorming. argument-hint: "[feature-name]" user-invocable: true

Create Task — ETNA_TRADER

PRIMARY OBJECTIVE

Create implementation-ready technical documentation for a feature or fix in ETNA_TRADER. Thoroughly understand the requirement, review the codebase with Explore sub-agent and all relevant documents. Adopt a TDD-first workflow where the test plan is authored first and guides the decomposition. Exclude time estimates. Ask clarifying questions when requirements are ambiguous.

Control Gates

GATE 0: Context Gathering & Requirements Understanding

Complete BEFORE technical decomposition.

STEP 1: Check for pre-work documentation

Look for existing documentation:

tasks/task-<date>-[feature-name]/discovery-[feature-name].md (Feature discovery from /nf)
docs/adr/ for relevant Architecture Decision Records

STEP 2: Gather context

IF pre-work documentation exists:

Read all available documents
Use Explore sub-agent to understand affected codebase areas
Confirm readiness with user

IF NO pre-work documentation:

Ask user to describe the task/feature
Ask clarifying questions about objective, acceptance criteria, affected layers
Use Explore sub-agent to understand affected codebase
Summarize understanding and confirm with user

Explore sub-agent focus areas:

Contracts: src/Etna.Trading.Contracts/ or src/Etna.Trader.Contracts/
Services: relevant *.Services/ projects
DAL: src/Etna.Dao.EntityFramework/ or src/Etna.Dao.NHibernate/
API: src/Etna.Trader.Api/Controllers/, src/Etna.Trader.Api/Models/
Frontend: frontend/ACAT/src/features/<feature>/
Existing tests: qa/ projects
DB: db/Etna.Trader.Database/Tables/, db/Etna.Trader.Database/Scripts/

GATE 0.7: UI Planning Agent (CONDITIONAL)

Trigger: IF task is UI-heavy (screens, components, grids, forms, styling in the ACAT frontend)

| Signal | Use agent? | |--------|-----------| | Implement screen from design mock | YES | | Create trading UI component (DataGrid, OrderForm, PositionCard) | YES | | Styling or layout changes | YES | | Backend service / repository only | NO | | DB migration only | NO | | API endpoint only | NO |

IF UI-heavy task: Invoke frontend-ui-planning-agent:

Analyze UI requirements for [feature-name] in the ACAT frontend (TypeScript + Vite).

Feature name: [feature-name]
Task directory: [absolute path to task folder]

Available pre-work (check and use if exists):
- discovery-[feature-name].md

Read rules: .claude/rules/trading-component-patterns.md
Check existing components in frontend/ACAT/src/shared/ui/ and frontend/ACAT/src/features/

Output: ui-planning-analysis-[feature-name].md in task directory (consultative reference)

GATE 1: Technical Decomposition & Test Plan Creation

FILE: Create tasks/task-<date>-[kebab-case]/tech-decomposition-[feature-name].md

TEMPLATE: Use docs/product-docs/templates/technical-decomposition-template.md if it exists, otherwise use the structure below.

Create technical implementation plan with TEST PLAN FIRST (TDD approach):

ETNA_TRADER-specific requirements in every plan:

[ ] Test file locations specified: qa/<Project>.Tests/ or qa/<Project>.IntegrationTests/
[ ] Test runner commands: dotnet test qa/<Project>/ with optional --filter
[ ] Layer boundaries respected (Services depend on Contracts only; API depends on Services)
[ ] ConfigureAwait(false) in all service/repository async methods
[ ] CancellationToken propagated through the call chain
[ ] Logging statements at entry/exit of high-value operations
[ ] Unity DI registration updated if new interfaces/implementations added
[ ] SSDT schema changes described if DB tables/indexes change
[ ] Named exports only for TypeScript components (frontend tasks)
[ ] No hardcoded connection strings — always use config / IConfiguration

If the plan touches UI/screens:

Add a "Skill Compliance" section listing which trading-component-patterns.md rules apply

AUTOMATIC PLAN REVIEW: After creating technical decomposition, automatically invoke agents:

plan-reviewer
senior-architecture-reviewer

ITERATIVE FEEDBACK LOOP: When either reviewer requires revisions:

Address feedback by updating the technical decomposition OR ask user for clarification
Re-submit with updated document + previous review for context + summary of changes
Repeat until both approve

After approvals, proceed directly to task splitting evaluation.

GATE 2: Task Splitting Evaluation

Complete AFTER plan review and BEFORE final task packaging.

STEP 2.1: Invoke task-splitter agent:

Evaluate if this task should be split into smaller sub-tasks.

Task directory: [absolute path to task folder]

Please analyze tech-decomposition-[feature-name].md and provide your decision and reasoning.

STEP 2.2: Check splitting decision:

IF splitting-decision.md created with SPLIT RECOMMENDED:
1. Present the splitting decision summary to user
2. Ask user: "Task splitter recommends splitting into N phases. Confirm: Proceed with decomposition?"
3. IF user approves: Invoke task-decomposer agent
4. IF user rejects: Proceed to GATE 3 (single task package)
IF NO SPLIT RECOMMENDED:
- Proceed to GATE 3

GATE 3: Final Task Packaging

ACTION: Confirm the task package is implementation-ready:

Tech decomposition is approved by both reviewers
Splitting decision saved (if applicable)
All required docs/paths are present
ADR reference added if an architectural decision was made (new ORM choice, layer restructure, etc.)

FINAL TASK DOCUMENT STRUCTURE

Single Task (no split)

tasks/task-<date>-[feature-name]/
├── discovery-[feature-name].md              (optional, from /nf)
├── ui-planning-analysis-[feature-name].md   (optional, from GATE 0.7)
├── Plan Review - [feature-name].md          (from plan-reviewer)
└── tech-decomposition-[feature-name].md     (required)

Split Task (after task-decomposer)

tasks/task-<date>-[feature-name]/
├── discovery-[feature-name].md
├── initial-tech-decomposition-[feature]-ARCHIVED.md
├── splitting-decision.md
├── phase-1-[name]/
│   └── tech-decomposition-phase-1-[name].md
├── phase-2-[name]/
│   └── tech-decomposition-phase-2-[name].md
└── phase-N-[name]/
    └── tech-decomposition-phase-N-[name].md

Key Sections in every tech-decomposition:

Primary Objective: Clear statement of what is being built
Test Plan (TDD): Given/When/Then test cases for NUnit/xUnit; test runner commands
Architecture Layers Touched: which projects are modified (Contracts, Services, DAL, API, Frontend, DB)
Implementation Steps: detailed steps with ETNA_TRADER file paths and layer notes
DB Changes: SSDT objects to create/modify, data migrations if needed
Unity DI Changes: new registrations or lifetime changes
Tracking & Progress: branch, PR
Dependencies: (for split tasks) phase dependencies

FLEXIBILITY NOTES

For Simple Tasks (quick workflow):

Gather requirements directly from user
Create technical decomposition based on conversation
Still follow TDD approach with test plan first
Still get plan-reviewer and senior-architecture-reviewer approval

For Complex Features (full workflow):

Run /nf first for discovery
Use frontend-ui-planning-agent for UI-heavy work
More detailed planning and review

Create Task - ETNA_TRADER

Recommended for