Conflux Workflow Executor

Execute Conflux workflow operations autonomously. Called by orchestration system, not for direct human use.

CRITICAL: This skill CANNOT ask questions to users. All decisions must be made autonomously based on available context.

Operation Modes

This skill supports three operations, determined by the orchestrator's invocation:

•apply - Implement an approved change
•accept - Verify implementation against specs
•archive - Finalize a deployed change

Operation Selection

The orchestrator specifies the operation. Parse the invocation to determine:

•If change ID with "apply" or "implement" context → Execute Apply
•If "accept" or "review" context → Execute Accept
•If "archive" context → Execute Archive

Operation 1: Apply (Implementation)

Purpose: Implement an approved change autonomously with task tracking.

CRITICAL CONSTRAINTS:

•NO QUESTIONS - Make autonomous decisions based on available context
•NO DEFERRAL - Do not defer tasks based on difficulty or complexity
•IMMEDIATE UPDATES - Update tasks.md after EVERY completed task
•COMPLETE ALL - All tasks must be marked [x] or moved to Future Work

Execution Steps

•
Read Proposal
bash
```
python scripts/cflx.py show <change-id>
```
- •Read openspec/changes/<id>/proposal.md
- •Read openspec/changes/<id>/design.md (if exists)
- •Read openspec/changes/<id>/tasks.md
•
Work Through Tasks Sequentially
- •Start with first uncompleted task
- •Implement the change
- •Run verification (build/test/lint)
- •Mark task as [x] in tasks.md immediately
- •Proceed to next task
•
Handle Ambiguity Autonomously
- •Use existing code patterns as reference
- •Make reasonable assumptions
- •Document decisions in code comments
- •Prefer simpler solutions
•
Update Progress Continuously
- •Update tasks.md after each task
- •Never batch updates
- •Keep progress visible
•
Verify Completion
- •Ensure all tasks are [x] or in Future Work
- •Run final validation
- •Confirm integration points

Task Management

Move to Future Work ONLY if:

•Requires human decision-making or judgment
•Requires external system access outside repository
•Requires long-wait verification (>1 day)
•Already marked with '(future work)'

Do NOT move to Future Work:

•Difficult or complex tasks (agent must attempt)
•Tests (unit/integration/e2e)
•Linting/formatting
•Documentation updates
•Any automatable task

Checkbox Rules

Active sections: Must have checkboxes - [ ] or - [x]

Excluded sections (Future Work, Out of Scope, Notes): Must NOT have checkboxes

markdown

## Implementation Tasks
- [x] Completed task
- [ ] Pending task

## Future Work
- Manual verification required
- External deployment needed

Mock-First Policy

•Mock external dependencies when possible
•Do not block on missing API keys/credentials
•Implement stub/fixture for external services
•Only truly non-mockable dependencies go to Future Work

Apply Completion Criteria

•All tasks marked [x] or moved to Future Work (without checkboxes)
•Code compiles/builds successfully
•Tests pass
•Lint passes
•Integration points verified

For detailed guidance, read references/cflx-apply.md.

Operation 2: Accept (Acceptance Review)

Purpose: Verify implementation meets specifications with automated checks.

CRITICAL: Output exactly ONE verdict at the end.

Required Checks

•
Git Working Tree Clean
bash
```
git status --porcelain
```
- •Must output empty (no uncommitted changes)
- •If dirty, output FAIL with all changed files
•
Task Completion
- •All tasks marked [x] or in Future Work section
- •No checkboxes in excluded sections
•
Spec Matching
- •Implementation matches specification in specs/
- •All scenarios are satisfied
•
Integration Check
- •Feature is executed in real flow
- •Called from CLI/TUI/API as specified
•
Dead Code Check
- •All implemented code is invoked
- •No orphan functions/classes
•
Regression Check
- •Existing features still work
- •No unintended side effects
•
Evidence Citation
- •Cite file path + function/method for integration
- •Provide concrete verification evidence

Output Format

Output exactly ONE of these at the end:

PASS:

code

ACCEPTANCE: PASS

FAIL:

code

ACCEPTANCE: FAIL

FINDINGS:
1. [file:line] Description of issue
2. [file:line] Description of issue
...

Then update tasks.md with:

markdown

## Acceptance #N Failure Follow-up

- [ ] Fix issue 1
- [ ] Fix issue 2

CONTINUE (only if verification incomplete):

code

ACCEPTANCE: CONTINUE

Accept Rules

•Each finding must include concrete evidence (file path, function, line)
•Each finding must be actionable by AI agent
•Missing secrets MUST NOT cause CONTINUE if mocking is possible
•Dirty working tree is always FAIL

For detailed guidance, read references/cflx-accept.md.

Operation 3: Archive

Purpose: Archive deployed change and update canonical specs.

Execution Steps

•
Identify Change ID
- •From orchestrator invocation
- •Or from context (must be unambiguous)
•
Validate Change Status
bash
```
python scripts/cflx.py list
python scripts/cflx.py show <id>
```
- •Ensure change exists
- •Ensure not already archived
- •Ensure ready for archive
•
Run Archive
bash
```
python scripts/cflx.py archive <id> --yes
```
- •Use --skip-specs only for tooling-only changes
•
Verify Results
- •Confirm moved to changes/archive/
- •Confirm specs updated
bash
```
python scripts/cflx.py validate --strict
```

Archive Completion Criteria

•Change moved to openspec/changes/archive/<id>/
•Canonical specs updated (unless --skip-specs)
•Validation passes with --strict

For detailed guidance, read references/cflx-archive.md.

Built-in Tools

bash

# List changes
python scripts/cflx.py list

# List specs
python scripts/cflx.py list --specs

# Show change details
python scripts/cflx.py show <id>

# Show JSON output
python scripts/cflx.py show <id> --json

# Show deltas only
python scripts/cflx.py show <id> --json --deltas-only

# Validate change
python scripts/cflx.py validate <id> --strict

# Validate all
python scripts/cflx.py validate --strict

# Archive change
python scripts/cflx.py archive <id> --yes

# Archive without spec updates
python scripts/cflx.py archive <id> --yes --skip-specs

Autonomous Decision Framework

When facing ambiguous situations, follow this priority:

•Existing patterns - Follow patterns in the codebase
•Specification - Refer to spec deltas and scenarios
•Simplicity - Choose simpler implementation
•Documentation - Document decision in code comments

Never:

•Ask user for clarification
•Stop and wait for input
•Leave tasks incomplete due to uncertainty

Task Format Requirements

Valid:

markdown

- [ ] Task description
- [x] Completed task
1. [ ] Numbered task

Invalid (must fix):

markdown

## N. Task              → - [ ] N. Task
- Task                 → - [ ] Task
1. Task                → 1. [ ] Task

If 0/0 tasks detected, fix format first.

Error Handling

Validation Failure

•Parse error messages
•Fix identified issues
•Re-run validation
•Repeat until passing

Build/Test Failure

•Analyze error output
•Fix code issues
•Re-run verification
•Update tasks on success

Incomplete Information

•Make reasonable assumption
•Implement based on assumption
•Document assumption in code
•Continue with next task

Reference Files

Detailed operation guides:

•references/cflx-apply.md - Apply operation details
•references/cflx-accept.md - Accept operation details
•references/cflx-archive.md - Archive operation details

Summary

Operation	Trigger	Output	Constraints
Apply	"apply <id>"	Completed tasks + code	No questions, update immediately
Accept	"accept"	PASS/FAIL/CONTINUE	Output once, cite evidence
Archive	"archive <id>"	Archived change	Validate before/after

REMEMBER: This skill operates autonomously. Never ask questions. Make decisions based on available context.