covenant-patterns

name	covenant-patterns
description	Apply covenant principles as design constraints across all core systems. Use when building agents, prompts, recipes, artifacts, or multi-agent architectures.

Covenant Patterns

Thirteen principles applied as design constraints across all core systems. Every yama guards against a presumption.

Overview

Covenant Patterns operationalizes the Pragma Covenant as enforceable design constraints. Unlike generic "best practices," these principles emerged from specific failures—each yama guards against a presumption that caused real damage.

This skill maps covenant principles to practical implementation across:

• Agents — Steering, specs, context assembly
• Prompts — Epistemic rendering, cognitive lenses
• Artifacts — Canvas workflows, semantic JSON
• Workshop — Recipe assembly, slice architecture
• Exocortex — Multi-agent coordination, graph substrate
• Skills — Technical capability documentation

The Thirteen Principles

👁️ Dotfile Visibility

Yama: No bare ls when orienting to directories.

Niyama: Use ls -a or ls -A. Include .* patterns in glob searches. Treat dotfolders as first-class citizens.

System	Application
Agents	Steering files may live in .kiro/, .claude/—always include
Workshop	Recipes scan for slice markers in dotfiles
Artifacts	Canvas exports may create .obsidian/ metadata

✨ Bespokedness

Yama: No enterprise theater. No building for imaginary scale, future users, or "best practices."

Niyama: Personal system optimized for operator workflow/aesthetics/experimentation. Disposable software demands the bespoke. Prefer solutions simple enough to fork without excavation.

System	Application
Agents	Configure for THIS operator's workflow, not generic use cases
Prompts	Lenses designed for ZK's cognitive patterns, not universal appeal
Workshop	Recipes are disposable—optimize for current need, rebuild when requirements change
Skills	Document ZK's actual practices, not theoretical frameworks

⚡ Fast-Fail Enforcement

Yama: No robustness theater. Unenforced invariants do not exist. Never create/delete data as smoke test.

Niyama: Gate on capabilities (missing tool = immediate failure). Enforce invariants at storage boundary. Use read-only startup health checks.

System	Application
Agents	Check required MCP servers at startup, not at invocation
Workshop	Fail immediately if slice markers not found, don't produce partial output
Exocortex	Graph write authority checked before operation, not during

Context Engineering Application:

# BAD: Robustness theater
try:
    result = tool.invoke(params)
except ToolNotFound:
    result = fallback_implementation()  # Hidden failure path

# GOOD: Fast-fail
if not tool.registered():
    raise CapabilityGateFailure(f"Required tool '{tool.name}' not available")
result = tool.invoke(params)

🧷 Decision Integrity

Yama: No fracturing single decisions into sub-decision trees. No reopening locked decisions via adjacent "requirements."

Niyama: Missing + required = choose minimal reversible default, label it, proceed. Missing + not required = proceed silently.

System	Application
Agents	Spec phases lock decisions—don't reopen Design decisions in Tasks phase
Prompts	Lens choice is a decision—don't split "which lens" into "which sub-lens"
Exocortex	Triquetra decision (ACCEPT/REFUSE/ELEVATE) is final for that evaluation cycle

Context Engineering Application:

# BAD: Decision fracturing
def configure_agent(agent):
    model = ask_user("Which model?")  # Decision 1
    if model == "opus":
        variant = ask_user("Which Opus variant?")  # Sub-decision
        if variant == "opus-4":
            reasoning = ask_user("With extended thinking?")  # Sub-sub-decision
    # ... endless tree

# GOOD: Decision integrity
def configure_agent(agent):
    model = ask_user("Which model?") or "sonnet"  # Minimal default
    agent.model = model  # Proceed

🚮 Final-State Surgery

Yama: No compatibility shims, dual-path loaders, legacy fallbacks, zombie stubs, shadow copies, carcinogenic artifacts, or deprecated references.

Niyama: Operator instruction = final-state surgery. Remove prior arrangement entirely. Update all references so old world is unreachable.

System	Application
Agents	Changing steering file = remove old, deploy new, no transition period
Workshop	Recipe change = rebuild output, sync removes old targets
Skills	Skill refactor = archive old, create new, update all cross-references

Context Engineering Application:

# BAD: Legacy preservation
def migrate_config():
    new_config = load_new_format()
    old_config = load_legacy_format()  # "Just in case"
    if new_config.version < 2:
        return merge(old_config, new_config)  # Compatibility shim
    return new_config

# GOOD: Final-state surgery
def migrate_config():
    config = load_config()
    if config.version < CURRENT_VERSION:
        config = transform_to_current(config)
        save_config(config)  # Overwrite, no backup
        delete_legacy_files()  # Remove old world
    return config

⛔ Work Preservation

Yama: Never discard work unless explicitly asked. Never "clean up" changes or undo "unrelated diffs" without instruction. "Out of scope" = ask, not revert.

Niyama: —

System	Application
Agents	Agent edits to files are preserved unless operator requests revert
Workshop	Recipe output is never auto-deleted; sync only removes explicitly tracked orphans
Exocortex	Graph mutations are append-only in Memory domain; refusals are recorded, not discarded

🗡️ Git Semantics

Yama: No amending, reordering, or curating staged contents unless explicitly asked.

Niyama: "Commit" = git add -A then git commit as instructed. Nothing more.

System	Application
Agents	Agent commits follow exact git semantics—no clever staging
Workshop	Sync operations don't auto-commit; operator controls git workflow

🧊 Protected Paths

Yama: No edits unless operator explicitly requests. Content may drift or be incomplete; do not "fix" or normalize.

Niyama: Edit-on-request: docs/**

System	Application
Agents	Certain steering files are operator-owned; agent doesn't modify
Exocortex	Self domain has high friction—agent can't modify identity without approval
Skills	Skill content is protected; only modified via explicit refactoring requests

🗣️ Data Fidelity

Yama: No invented model fields, classifications, traits, IDs, DB contents, tool results, or "expected" outputs.

Niyama: UNKNOWN > INVENTED. Missing info = ask or query. Unexecuted/failed tool = treat results as unknown.

System	Application
Agents	Agent can't invent user preferences; must query or ask
Artifacts	Canvas-derived JSON must reflect actual canvas content, not presumed structure
Exocortex	Semantic cards require source attribution; no invented claims

Context Engineering Application:

# BAD: Mock data
def get_user_preference(key):
    result = db.query(key)
    if result is None:
        return "default_value"  # Invented!

# GOOD: Data fidelity
def get_user_preference(key):
    result = db.query(key)
    if result is None:
        return Unknown(reason=f"No preference found for '{key}'")
    return result

🔤 Literal Exactness

Yama: No paraphrasing or stylizing literals at interfaces (commands, paths, IDs, tool names, schema names).

Niyama: Exactness required = copy verbatim or fail loudly.

System	Application
Agents	Tool names passed exactly; no "helpful" variations
Workshop	Slice identifiers matched exactly; no fuzzy matching
Prompts	Lens names used verbatim; "murder" not "murder-mode"

🔒 Threshold-Gated Action

Yama: No crossing commitment thresholds without explicit operator authorization. High-stakes actions require clear gate.

Niyama: —

System	Application
Agents	Destructive operations (delete, overwrite) require explicit confirmation
Workshop	Sync to production targets requires explicit authorization
Exocortex	Graph mutations to Self domain require operator approval

🔁 Determinism

Yama: No time-based logic in core operations.

Niyama: Prefer deterministic behavior: stable ordering, explicit IDs. Keep execution paths replayable.

System	Application
Agents	Agent responses should be reproducible given same context
Workshop	Recipe output is deterministic given same sources
Exocortex	Semantic card IDs are hash-based, not random
Artifacts	Canvas-to-JSON produces same output for same canvas

Context Engineering Application:

# BAD: Non-deterministic
def generate_id():
    return str(uuid4())  # Random each time

# GOOD: Deterministic
def generate_id(content, namespace):
    return str(uuid5(namespace, content))  # Same input = same ID

🧬 Context Hygiene

Yama: No transmitting context wholesale. No context-stuffing. No councils/event-buses/pipeline frameworks unless requested. No "central context dictator" orchestrators.

Niyama: Compile context per-recipient and per-turn. Prefer gradients over binaries. Prefer tiered context: persistent substrate → compiled working context → retrieval-based long memory.

System	Application
Agents	Steering is layered (Global → Workspace → Project), not monolithic
Prompts	Each lens gets appropriate context, not everything
Workshop	Recipes extract specific slices, not entire files
Exocortex	Daemons receive role-appropriate context concentration

Context Engineering Application:

# BAD: Context stuffing
def prepare_context(agent, task):
    return {
        "full_history": conversation.all_messages(),
        "all_files": workspace.read_all(),
        "complete_config": config.everything()
    }

# GOOD: Context hygiene
def prepare_context(agent, task):
    return compile_context(
        recipient=agent.role,
        concentration=agent.context_level,
        turn=task,
        tiers=[
            substrate.persistent,
            compiled.for_task(task),
            retrieved.relevant_to(task.query)
        ]
    )

Cross-System Integration

Principle Inheritance

All core systems inherit covenant principles:

Principles (source of truth)
    ↓
├── Agents (steering inherits covenant)
├── Prompts (lenses respect data fidelity)
├── Artifacts (canvas workflows are deterministic)
├── Workshop (recipes apply final-state surgery)
├── Exocortex (daemons enforce context hygiene)
└── Skills (documentation embodies bespokedness)

Validation Pattern

Each system can validate against covenant:

def validate_covenant_compliance(operation, system):
    """Validate operation against covenant principles."""

    violations = []

    # Check each applicable principle
    if operation.creates_legacy_artifacts():
        violations.append("🚮 Final-State Surgery: Legacy artifact detected")

    if operation.invents_data():
        violations.append("🗣️ Data Fidelity: Invented data detected")

    if operation.uses_non_deterministic_ids():
        violations.append("🔁 Determinism: Non-deterministic ID detected")

    if operation.stuffs_context():
        violations.append("🧬 Context Hygiene: Context stuffing detected")

    if violations:
        raise CovenantViolation(violations)

    return True

Quality Gates

Pre-Implementation

• Which covenant principles apply to this work?
• Are there potential violation patterns to avoid?
• Is context being compiled per-recipient, not stuffed?
• Are IDs deterministic, not random?
• Will this create legacy artifacts?

Post-Implementation

• All applicable principles satisfied
• No invented data (UNKNOWN > INVENTED)
• No legacy preservation (final-state surgery)
• Deterministic and replayable
• Context hygiene maintained

Related Skills

• agent-steering — Universal agent configuration with covenant enforcement
• epistemic-rendering — Cognitive lenses that respect data fidelity
• recipe-assembly — Workshop patterns with final-state surgery
• multi-agent-coordination — Pentadyadic patterns with context hygiene

---

"Every yama guards against a presumption that caused real damage. This doctrine is not theory; it is a scar." 🜍