Self Discipline

Instructions written but never followed. Lessons logged but never read. The same mistakes repeated across sessions. This skill breaks that cycle permanently.

When something goes wrong — and the user makes it clear it cannot happen again — this skill doesn't just log it. It traces WHY the failure occurred, verifies the fix will actually be seen by future agents, and generates automated validators that make repetition impossible.

When to Use

User is frustrated that the agent ignored instructions. Something critical happened that cannot repeat. User explicitly says "this can never happen again" or "I told you not to..." User explicitly invokes /discipline to ensure compliance on a rule.

How It Works

         ┌──────────────────────────────────────────────┐
         │              DISCIPLINE TRIGGER              │
         └──────────────────────────────────────────────┘
                              │
         ┌────────────────────┼────────────────────┐
         ▼                    ▼                    ▼
    ┌─────────┐         ┌──────────┐         ┌─────────┐
    │  USER   │         │ CRITICAL │         │ COMMAND │
    │  UPSET  │         │ FAILURE  │         │  USED   │
    └────┬────┘         └────┬─────┘         └────┬────┘
         │                   │                    │
         │ "I told you..."   │  Security breach,  │  /discipline
         │ "Why did you..."  │  data loss...      │
         │                   │                    │
         └───────────────────┴────────────────────┘
                              │
                              ▼
                    ┌─────────────────┐
                    │    SEVERITY     │
                    │  🔴 🟡 🟢       │
                    └────────┬────────┘
                              │
                              ▼
                    ┌─────────────────┐
                    │  ROOT CAUSE     │
                    │  5 Whys: Why    │
                    │  wasn't it      │
                    │  followed?      │
                    └────────┬────────┘
                              │
                              ▼
                    ┌─────────────────┐
                    │ FLOW VERIFY     │
                    │ Will next agent │
                    │ see the fix?    │
                    └────────┬────────┘
                              │
                              ▼
                    ┌─────────────────┐
                    │  VALIDATOR      │
                    │  Script that    │
                    │  blocks action  │
                    └────────┬────────┘
                              │
                              ▼
                    ┌─────────────────┐
                    │    COMPLETE     │
                    │ Logged+Enforced │
                    └─────────────────┘

Setup

On first use, read setup.md for integration guidelines. Creates ~/self-discipline/ for rules, validators, and enforcement logs.

Architecture

Memory lives in ~/self-discipline/. See memory-template.md for structure.

~/self-discipline/
├── memory.md              # Status + severity thresholds + stats
├── rules.md               # Active discipline rules (ALWAYS loaded)
├── incidents.md           # Incident log with root cause analysis
├── validators/            # Executable validators
│   ├── pre-commit/        # Run before git commits
│   ├── pre-send/          # Run before sending messages
│   └── custom/            # Domain-specific validators
├── flow-analysis/         # Instruction flow traces
└── archive/               # Resolved incidents

Quick Reference

Core Rules

1. Detect Severity Immediately

When triggered, assess severity FIRST:

Default to one level higher if uncertain.

2. Root Cause Before Solution

Never jump to "I'll remember that." Instead:

1. What exactly failed? — Be specific
2. What was the instruction? — Quote it verbatim
3. Where was the instruction? — Path + line number
4. Why wasn't it followed? — 5 Whys:
• Why? → Not loaded in context
• Why? → File not in session's read path
• Why? → No reference in AGENTS.md / system prompt
• Why? → Setup assumed it would be read
• Why? → No verification mechanism

3. Verify Flow Reachability (CRITICAL)

After identifying where the instruction SHOULD be, trace the actual agent flow:

START: New session begins
  ↓
READ: System prompt loaded
  ↓
READ: AGENTS.md (if exists)
  ↓
READ: MEMORY.md (if referenced)
  ↓
READ: Other files (if referenced)
  ↓
QUESTION: Is the instruction in ANY of these?

If instruction is NOT in the flow:

• The fix is NOT to "write it somewhere"
• The fix IS to add it to a file ALREADY in the flow
• OR add a reference to its location in a file ALREADY in the flow

4. User Consent Required

NEVER modify files outside ~/self-discipline/ without explicit user permission.

When suggesting changes to AGENTS.md, HEARTBEAT.md, or other files:

Flow for external file changes:

1. Explain WHY the change is needed
2. Show EXACTLY what will be added/changed
3. Wait for explicit "yes" / approval
4. Only then make the change

5. Generate Validators for Critical Issues

For 🔴 CRITICAL issues, create automated validators:

# Example: ~/self-discipline/validators/pre-send/no-secrets.sh
#!/usr/bin/env bash
set -euo pipefail

# SECURITY MANIFEST:
# Environment variables accessed: none
# External endpoints called: none
# Local files read: message content (stdin)
# Local files written: none

# Check for secrets before sending messages
if echo "$1" | grep -qE '(password|token|key)='; then
  echo "❌ BLOCKED: Message contains potential secret"
  echo "Rule: no-secrets-in-messages (from incident 2024-02-15)"
  exit 1
fi

Validators must:

• Exit 0 = pass, exit 1 = block
• Include the rule origin (incident reference)
• Never modify data, only check

6. Track Enforcement

In ~/self-discipline/memory.md, maintain:

7. Escalation Path

If the same rule is violated twice:

1. First violation: Full analysis + fix
2. Second violation: Promote to CRITICAL + mandatory validator
3. Third violation: STOP and ask user for intervention

Severity Assessment Protocol

See severity.md for detailed criteria.

Quick Assessment

The Flow Verification Process

See flow-verification.md for complete protocol.

Why Instructions Get Ignored

Verification Steps

1. Identify all files in agent's load path (system prompt, AGENTS.md, etc.)
2. Check if instruction location is in that path
3. If not in path: Find where to add reference
4. If in path but buried: Move to more prominent location
5. If contradicted: Resolve with explicit priority

Validator Patterns

See validators.md for complete reference.

Types

Validator Template

#!/usr/bin/env bash
set -euo pipefail

# SECURITY MANIFEST:
# Environment variables accessed: [list]
# External endpoints called: [list or "none"]
# Local files read: [list]
# Local files written: [list or "none"]

# Validator: [rule-name]
# Created: YYYY-MM-DD
# Incident: [reference]
# Severity: CRITICAL

# [description of what this validates]

[validation logic]

if [condition that should fail]; then
  echo "❌ BLOCKED: [reason]"
  echo "Rule: [rule-name] (from incident [date])"
  exit 1
fi

exit 0

Common Traps

Commands

Security & Privacy

Data that stays local:

• All rules, incidents, and validators in ~/self-discipline/
• No data sent to external services
• No telemetry or analytics

This skill does NOT:

• Make network requests
• Access credentials or secrets
• Modify files without explicit user permission
• Run validators without user approval
• Access files outside ~/self-discipline/ without asking

File modifications outside ~/self-discipline/:

• Only suggested when needed for rule visibility (e.g., AGENTS.md reference)
• Always shown to user first
• Require explicit approval before execution
• Include backup before any edit

Related Skills

Install with clawhub install if user confirms:

• reflection — structured self-evaluation
• memory — persistent memory patterns
• decide — decision-making patterns
• escalate — know when to ask vs act
• learning — adaptive learning system

Feedback

• If useful: clawhub star self-discipline
• Stay updated: clawhub sync