playbook/outfitter-agents/plugins/outfitter/skills/session-analysis/references/signal-patterns.md

# Signal Patterns Reference

Extended taxonomy with edge cases, disambiguation guidance, and confidence scoring rubric.

## Success Signals

### Explicit Praise

**Core indicators**: Positive adjectives, exclamation marks, superlatives.

**Examples**:
- "Perfect!"
- "Exactly what I needed"
- "This is great work"
- "Love it"
- "Well done"

**Edge cases**:
- "Good enough" → Low confidence (lukewarm, not enthusiastic)
- "That works" → Low confidence (neutral acceptance, not praise)
- "Thanks" → Context-dependent (could be courtesy, not satisfaction)

**Confidence criteria**:
- **High**: Superlatives ("perfect", "excellent"), multiple exclamations, enthusiastic tone
- **Medium**: Positive adjectives ("good", "nice") with neutral tone
- **Low**: Minimal positive language, could be polite rather than satisfied

### Continuation

**Core indicators**: Building on previous work, extending scope, applying pattern elsewhere.

**Examples**:
- "Now do the same for the login page"
- "Apply this pattern to all API routes"
- "Great, next let's handle the error cases"

**Edge cases**:
- "Now try X instead" → Frustration (correction) if contradicts prior work
- "Also do Y" → Continuation only if X succeeded; check for corrections first
- "Next, fix the bug in Z" → Context switch, not continuation

**Confidence criteria**:
- **High**: Explicit reference to prior success + request to extend
- **Medium**: Implied satisfaction + new related task
- **Low**: Sequential tasks without confirmation of prior success

### Adoption

**Core indicators**: User implements agent's suggestion without modification or pushback.

**Examples**:
- Agent: "Use TanStack Router" → User: *next message shows TanStack Router implementation*
- Agent: "Refactor to use async/await" → User: "Done, looks cleaner"
- Agent suggests pattern → User's code follows pattern exactly

**Edge cases**:
- User modifies suggestion before implementing → Medium confidence (partial adoption)
- User implements after asking clarifying questions → Still adoption (high confidence)
- User implements weeks later → Weak adoption signal (confounded by time)

**Confidence criteria**:
- **High**: Immediate implementation with no modifications
- **Medium**: Implementation after clarification or with minor adjustments
- **Low**: Implementation significantly delayed or heavily modified

### Completion Acceptance

**Core indicators**: Approval language followed by action (merge, ship, close ticket).

**Examples**:
- "Looks good, merge it"
- "Ship it"
- "Perfect, closing this issue"
- "LGTM" (Looks Good To Me)

**Edge cases**:
- "Looks good, but..." → Conditional acceptance, check for follow-up corrections
- "Merge" without review → Context-dependent (could be trust or urgency, not satisfaction)
- "Ship it" with sarcasm → Rare but check surrounding context for frustration

**Confidence criteria**:
- **High**: Explicit approval + action directive
- **Medium**: Approval without action or action without explicit approval
- **Low**: Ambiguous approval ("fine", "okay") that could indicate resignation

## Frustration Signals

### Correction

**Core indicators**: Negation words, contradiction of agent output, explicit redirection.

**Examples**:
- "No, I meant X not Y"
- "That's wrong, do Z instead"
- "Actually, use A instead of B"

**Edge cases**:
- "Small correction: use X" → Frustration (low confidence) if agent should have known
- "Let's adjust to X" → Not frustration if iterating on shared work
- "Change X to Y" → Context-dependent (correction vs. evolution)

**Confidence criteria**:
- **High**: Explicit negation ("no", "wrong", "don't") + correction
- **Medium**: Implicit correction ("actually", "instead") without harsh language
- **Low**: Neutral adjustment language that could be iteration not correction

### Reversion

**Core indicators**: Request to undo agent's changes, return to previous state.

**Examples**:
- "Revert that change"
- "Go back to the original version"
- "Undo what you just did"
- User manually reverts agent's commit

**Edge cases**:
- "Let's try the original approach" → Could be exploration, not frustration
- Revert after testing both options → Scientific method, not frustration
- Partial revert → Medium confidence (some parts worked, some didn't)

**Confidence criteria**:
- **High**: Explicit revert request with no justification (implies failure)
- **Medium**: Revert with explanation that agent's approach had issues
- **Low**: Revert as part of A/B testing or exploration

### Repetition

**Core indicators**: Same request issued 2+ times with escalating specificity or frustration.

**Examples**:
- Message 1: "Use Bun not npm"
- Message 2: "Again, use Bun"
- Message 3: "I already told you to use Bun!"

**Edge cases**:
- Repetition after context switch → May not be frustration, could be reminder
- Repetition with new information → Evolution, not frustration
- Repetition across different tasks → Preference signal, not frustration

**Confidence criteria**:
- **High**: 3+ repetitions with escalating tone or "again"/"already told you"
- **Medium**: 2 repetitions with no new context
- **Low**: 2 similar requests in different contexts (could be unrelated)

### Explicit Frustration

**Core indicators**: Direct expression of dissatisfaction, questioning agent's behavior.

**Examples**:
- "This isn't working"
- "Why did you do X when I said Y?"
- "I already told you not to..."
- "This is frustrating"

**Edge cases**:
- "Hmm, that's odd" → Confusion, not necessarily frustration
- "Why X?" → Curiosity if neutral tone; frustration if accusatory
- "Not quite" → Gentle correction, low frustration

**Confidence criteria**:
- **High**: Explicit frustration words ("frustrating", "annoying") or accusatory questions
- **Medium**: Implied dissatisfaction ("not working", "this is wrong")
- **Low**: Neutral problem statements without emotional language

## Workflow Signals

### Sequence Markers

**Core indicators**: Ordinal language, numbered lists, temporal connectives.

**Examples**:
- "First, do X. Then Y. Finally Z."
- "Step 1: A, Step 2: B, Step 3: C"
- "Before we start, let's..."

**Edge cases**:
- Single "first" without "second" → Low confidence (could be emphasis, not sequence)
- "Then" without "first" → Continuation, not new sequence
- Numbered list describing features (not steps) → Not workflow signal

**Confidence criteria**:
- **High**: Multiple ordinal markers (first, second, third) or numbered steps
- **Medium**: Single sequence marker with clear temporal relationship
- **Low**: Ambiguous temporal language ("before", "after") without clear sequence

### Stage Transitions

**Core indicators**: Reference to completion + new direction, explicit context shift.

**Examples**:
- "Now that X is done, let's work on Y"
- "Moving on to the API layer"
- "With that complete, next is..."

**Edge cases**:
- "Let's do Y" without completion reference → Context switch, not stage transition
- "After X, do Y" (pre-planning) → Sequence marker, not transition
- "Y is next" → Future reference, not active transition

**Confidence criteria**:
- **High**: Explicit completion reference + new task
- **Medium**: Implied completion + new direction
- **Low**: New task without completion signal (could be interruption)

### Tool Chains

**Core indicators**: Consistent sequence of tool usage across multiple tasks.

**Examples**:
- Pattern: Read → Edit → Bash (test) appears 5+ times
- Pattern: Glob → Grep → Read appears 3+ times for search tasks
- Pattern: Write → Bash (validate) appears 4+ times

**Edge cases**:
- Same tools in different order → Not a chain, separate usage
- Tool chain appears once → Not a pattern yet
- Tool chain broken by user interruption → Still valid if resumes afterward

**Confidence criteria**:
- **High**: 5+ occurrences of same tool sequence
- **Medium**: 3-4 occurrences with occasional variation
- **Low**: 2 occurrences or significant variation in sequence

### Context Switches

**Core indicators**: Abrupt topic change, new file focus, no transition language.

**Examples**:
- Working on auth.ts → Suddenly "Fix the database schema"
- Discussing React components → "Now debug the API"
- Mid-task: "Actually, let's work on something else"

**Edge cases**:
- Switch after completing task → Stage transition, not context switch
- Switch with explanation → Intentional pivot, still a switch but lower friction
- Return to previous context → Resumption, not new switch

**Confidence criteria**:
- **High**: Abrupt change with no transition, different domain
- **Medium**: Change with minimal transition or related domain
- **Low**: Change with explanation or natural task completion

## Request Signals

### Prohibition

**Core indicators**: Negative imperatives, explicit constraints, "don't" statements.

**Examples**:
- "Don't use any types"
- "Never use npm, always use Bun"
- "Avoid using classes"

**Edge cases**:
- "I wouldn't use X" → Preference, not prohibition (softer language)
- "Don't do X unless Y" → Conditional prohibition
- "Try not to X" → Soft prohibition (low confidence)

**Confidence criteria**:
- **High**: Absolute negatives ("never", "don't", "no") with no conditions
- **Medium**: Soft negatives ("avoid", "try not to") or conditional prohibitions
- **Low**: Implicit discouragement without explicit prohibition

### Requirement

**Core indicators**: Absolute language, modal verbs (must, should, always), imperatives.

**Examples**:
- "Always run tests before committing"
- "You must validate input"
- "Make sure to check for errors"

**Edge cases**:
- "It's good to X" → Preference, not requirement
- "Should probably X" → Weak requirement (medium confidence)
- "Try to X" → Suggestion, not requirement

**Confidence criteria**:
- **High**: Absolute modal verbs ("must", "always") or strong imperatives
- **Medium**: Soft modal verbs ("should") or qualified requirements
- **Low**: Suggestions ("could", "might want to") without strong language

### Preference

**Core indicators**: Comparative language, subjective statements, "prefer" / "better" / "rather".

**Examples**:
- "I prefer TypeScript over JavaScript"
- "It's better to use async/await"
- "I'd rather use functional components"

**Edge cases**:
- "I like X" → Weak preference (low confidence)
- "X is better" (stated as fact) → Could be requirement depending on tone
- "Prefer X, but Y works too" → Flexible preference (medium confidence)

**Confidence criteria**:
- **High**: Explicit preference language ("prefer", "I'd rather") with comparison
- **Medium**: Implied preference through evaluation ("better", "cleaner")
- **Low**: Weak positive statements without comparison

### Conditional

**Core indicators**: Logical connectives (if/then, when, unless), situational rules.

**Examples**:
- "If X then Y"
- "When working on auth, always use Z"
- "Unless A, do B"

**Edge cases**:
- "Maybe if X" → Uncertain conditional (low confidence)
- "X or Y depending on Z" → Multiple conditionals, complex rule
- "If X" without "then" → Incomplete conditional, infer consequence from context

**Confidence criteria**:
- **High**: Explicit if/then structure with clear condition and action
- **Medium**: Implied conditional (when, unless) or incomplete structure
- **Low**: Vague conditional ("depending on", "maybe if")

## Disambiguation Guidance

### Success vs. Frustration

**Ambiguous case**: "That works"

- **Success** if: No prior corrections, agent's first attempt, user moves on
- **Frustration** if: After multiple attempts, lukewarm tone, user makes adjustments

**Rule**: Check for prior corrections. If 0-1, success. If 2+, frustration.

### Continuation vs. Correction

**Ambiguous case**: "Now do X for Y too"

- **Continuation** if: X succeeded for original target, Y is similar target
- **Correction** if: X failed for original target, Y is different approach

**Rule**: Verify success of X before classifying as continuation.

### Request vs. Workflow

**Ambiguous case**: "Always run tests before committing"

- **Request (requirement)** if: User establishing new rule
- **Workflow (sequence)** if: User describing existing process

**Rule**: Check if user is prescribing (request) or describing (workflow). Use tense as clue: imperative = request, present tense = workflow.

### Preference vs. Requirement

**Ambiguous case**: "Use TypeScript"

- **Preference** if: Soft language, alternatives mentioned, presented as opinion
- **Requirement** if: Absolute language, no alternatives, presented as rule

**Rule**: Look for qualifiers. "I prefer X" = preference. "Use X" = requirement. "Always use X" = strong requirement.

## Confidence Scoring Rubric

### High Confidence (0.8 - 1.0)

- Explicit signal keywords match taxonomy exactly
- No ambiguity in language or intent
- Context strongly supports classification
- Multiple supporting clues (tone, punctuation, surrounding messages)

**Example**: "Don't use npm, always use Bun" → Prohibition (high confidence)

### Medium Confidence (0.5 - 0.79)

- Implicit signal requiring some interpretation
- Context provides partial support
- Minor ambiguity but best classification is clear
- Single supporting clue or mixed signals

**Example**: "Bun is better here" → Preference (medium confidence)

### Low Confidence (0.2 - 0.49)

- Ambiguous language with multiple possible interpretations
- Weak or contradictory context
- Signal requires significant inference
- Borderline between two signal types

**Example**: "That's fine" → Success? Frustration? (low confidence)

### No Signal (< 0.2)

- Neutral language with no clear signal
- Insufficient context to classify
- Pure information exchange with no behavioral indicator

**Example**: "The file is at /path/to/file" → No signal

## Signal Combinations

Certain signal combinations indicate specific patterns:

### Success → Continuation

Pattern: **Positive Reinforcement Loop**

User satisfied with approach and wants to extend it.

```
Message 1: "Perfect! This works great" (success: explicit praise)
Message 2: "Now apply this to all the other routes" (success: continuation)
```

**Recommendation**: Internalize the successful approach as a pattern to reuse.

### Frustration (repetition) → Success

Pattern: **Learning Curve Overcome**

Agent initially misunderstood but eventually delivered correctly.

```
Message 1: "Use Bun not npm" (frustration: correction)
Message 2: "Again, Bun not npm" (frustration: repetition)
Message 3: "Perfect, that's the right package manager" (success: praise)
```

**Recommendation**: Add the learned requirement to memory to avoid future repetition.

### Request (prohibition) + Frustration (repetition)

Pattern: **Persistent Violation**

Agent repeatedly violates an explicit constraint.

```
Message 1: "Don't use any types" (request: prohibition)
Message 3: "I said no any types" (frustration: repetition + request)
Message 5: "Again, avoid any types" (frustration: repetition + request)
```

**Recommendation**: Escalate to memory update or configuration change. This is a critical user requirement being violated.

### Workflow (tool chain) + Success (adoption)

Pattern: **Workflow Optimization**

User established efficient tool sequence and agent adopted it.

```
Message 1: "Read, then Edit, then run tests" (workflow: sequence)
Message 3: *agent follows sequence* (workflow: tool chain)
Message 5: "Great, you've got the workflow down" (success: praise)
```

**Recommendation**: Codify tool chain as a standard workflow template.

### Context Switch + Frustration (explicit)

Pattern: **Blocked Progress**

User abandons current task due to persistent issues.

```
Message 1: "This isn't working" (frustration: explicit)
Message 2: "Let's work on something else instead" (workflow: context switch)
```

**Recommendation**: Mark the abandoned task for later review. Likely indicates a blocker or knowledge gap.

## Temporal Patterns

### Escalation Pattern

Signal intensity increases over time.

```
T1: "Use Bun" (request: preference)
T2: "Please use Bun, not npm" (request: requirement)
T3: "I already told you to use Bun!" (frustration: repetition + explicit)
```

**Detection**: Same topic, increasing frustration or stronger modal verbs.

**Recommendation**: High-priority memory update. User is emphasizing this requirement.

### De-escalation Pattern

Frustration decreases as issue resolves.

```
T1: "This is broken" (frustration: explicit)
T2: "Getting closer" (neutral)
T3: "Perfect!" (success: praise)
```

**Detection**: Same topic, decreasing frustration and increasing success signals.

**Recommendation**: Identify what changed between T2 and T3. This is the successful approach.

### Cyclical Pattern

Same issue recurs periodically.

```
Day 1: "Use TypeScript" (request)
Day 5: "Remember to use TypeScript" (frustration: repetition)
Day 10: "Again, TypeScript not JavaScript" (frustration: repetition)
```

**Detection**: Same request/correction across multiple sessions with time gaps.

**Recommendation**: Critical memory failure. Agent is not retaining this requirement across sessions.