conflict-detection（冲突检测）

Conflict Detection Skill

This skill provides patterns for detecting and resolving conflicts between requirements, decisions, and plans throughout the workflow.

Core Principles

1. Early Detection: Catch conflicts as soon as they arise
2. Immediate Stop: Halt workflow when conflict detected
3. User Resolution: Never auto-resolve conflicts
4. Documented Rationale: Record why resolutions were chosen

Conflict Types

Requirement vs Requirement

Two requirements that cannot both be satisfied.

Detection Point: DISCUSS phase Example: "User wants real-time updates AND offline mode"

Indicators:

• Mutually exclusive features
• Resource contention
• Contradictory behaviors

Decision vs Decision

A new decision contradicts an earlier decision.

Detection Point: DISCUSS phase Example: "Earlier said 'no database', now requesting PostgreSQL"

Indicators:

• Opposite stance on same topic
• Changed constraints
• Reversed priorities

New vs Existing Plan

Proposed work conflicts with pending tasks.

Detection Point: PLAN phase Example: "This change conflicts with TASK-003 in current ITEM-XXX.md"

Indicators:

• Same files modified differently
• Contradicting goals
• Circular dependencies

Scope vs Timeline

Requested features exceed achievable scope.

Detection Point: DISCUSS phase Example: "Features exceed what's achievable in stated timeline"

Indicators:

• Too many must-haves
• Complex features with tight deadline
• Dependencies on unavailable resources

Tech vs Requirement

Chosen technology cannot support a requirement.

Detection Point: PLAN phase Example: "Chosen tech doesn't support requested feature"

Indicators:

• Technical limitations
• Incompatible versions
• Missing capabilities

Detection Protocol

On Each New Input

┌─────────────────────────────────────────────────────────────────┐
│              CONFLICT DETECTION FLOW                             │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  1. EXTRACT assertions from new input                           │
│     ├─ Requirements stated                                      │
│     ├─ Decisions made                                           │
│     ├─ Constraints imposed                                      │
│     └─ Priorities expressed                                     │
│                                                                 │
│  2. SCAN for contradictions                                     │
│     ├─ Compare against ITEM-XXX.md decisions                    │
│     ├─ Compare against ITEM-XXX.md requirements                 │
│     ├─ Compare against existing tasks in ITEM-XXX.md            │
│     └─ Check implicit assumptions                               │
│                                                                 │
│  3. IF CONFLICT DETECTED:                                       │
│     ├─ STOP workflow immediately                                │
│     ├─ Document conflict in ITEM-XXX.md                         │
│     ├─ Present conflict clearly to user                         │
│     └─ Wait for resolution before continuing                    │
│                                                                 │
│  4. IF NO CONFLICT:                                             │
│     └─ Continue workflow normally                               │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

Comparison Matrix

For each new assertion, check against:

Conflict Documentation

In ITEM-XXX.md

## Conflicts

### CONFLICT-001: [Descriptive Title]
**Status**: ACTIVE | RESOLVED | DEFERRED
**Detected**: [TIMESTAMP]
**Type**: Requirement | Decision | Plan | Technical | Scope

**What conflicts:**
- A: [First item with reference]
- B: [Second item with reference]

**Why they conflict:**
[Clear explanation of why both cannot coexist]

**Resolution options:**
1. [Option 1 - description and implications]
2. [Option 2 - description and implications]
3. [Option 3 - description and implications]

**User choice**: [PENDING | Option N]
**Rationale**: [Why user chose this option]
**Resolved**: [TIMESTAMP]
**Actions taken**: [What changed as a result]

Automatic Triggers

The system MUST stop and present conflict when detecting:

Contradictory Statements

Trigger: "You said X earlier, now saying not-X"
Example: "Earlier you said no database needed, but now you're
         asking for PostgreSQL integration"

Mutually Exclusive Features

Trigger: "Feature A requires condition C, Feature B requires not-C"
Example: "Real-time sync requires constant internet, but you also
         want full offline functionality"

Resource Conflicts

Trigger: "Both items need exclusive access to same resource"
Example: "Two tasks both want to restructure the database schema
         in incompatible ways"

Timeline Impossibilities

Trigger: "Features exceed reasonable scope for constraints"
Example: "You're asking for 15 major features with a 2-week deadline"

Technical Incompatibilities

Trigger: "Technologies don't work together"
Example: "You want to use Library A and Library B, but they have
         conflicting peer dependencies"

Resolution Options

Option 1: Prioritize One

Choose one item over the other.

Resolution: Prioritize A over B
- A remains as requirement
- B is removed or deferred
- Rationale recorded

Option 2: Modify One

Adjust one item to remove conflict.

Resolution: Modify B to accommodate A
- A remains unchanged
- B is adjusted: [specific changes]
- Both now compatible

Option 3: Modify Both

Adjust both items to find middle ground.

Resolution: Adjust both for compromise
- A adjusted: [changes]
- B adjusted: [changes]
- Trade-off documented

Option 4: Accept with Trade-off

Keep both, document the trade-off.

Resolution: Accept both with trade-off
- Both remain
- Trade-off: [what is sacrificed]
- Risk documented

Option 5: Defer

Postpone resolution.

Resolution: Deferred
- Marked as DEFERRED
- Reason: [why can't resolve now]
- Blocker for: [what can't proceed]
- Revisit: [when/condition]

Cross-Plan Verification

Before creating tasks, verify:

## Cross-Plan Verification Checklist

**Against ITEM-XXX.md requirements:**
- [ ] All requirements have at least one task
- [ ] No tasks contradict requirements
- [ ] Priority order respected
- [ ] No requirements orphaned

**Against ITEM-XXX.md decisions:**
- [ ] Tasks align with recorded decisions
- [ ] No tasks contradict decisions
- [ ] Deferred items not accidentally included

**Against existing tasks in ITEM-XXX.md:**
- [ ] New tasks don't conflict with pending tasks
- [ ] File modifications don't overlap dangerously
- [ ] Dependency order preserved
- [ ] No circular dependencies created

**Against FLOW.md backlog:**
- [ ] Tasks fit within item scope
- [ ] No scope creep detected
- [ ] Dependencies on other items documented

**Conflicts found**: [List or "None"]

Integration Points

• State Management: Document conflicts in ITEM-XXX.md
• Exploration Tracking: Flag areas with detected conflicts
• Interviewer Agent: Stop and present conflicts during discussion
• Planner Agent: Verify cross-plan consistency
• Workflow Orchestration: Block phase transitions on active conflicts

See resolution.md for detailed resolution strategies.